You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1113 lines
30 KiB
1113 lines
30 KiB
|
|
/*
|
|
Copyright (c) 2003,2004,2005 Clarence Dang <dang@kde.org>
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
|
|
#define DEBUG_KP_COLOR_TOOL_BAR 0
|
|
|
|
|
|
#include <kpcolortoolbar.h>
|
|
|
|
#include <tqbitmap.h>
|
|
#include <tqdrawutil.h>
|
|
#include <tqframe.h>
|
|
#include <tqlayout.h>
|
|
#include <tqpainter.h>
|
|
#include <tqsize.h>
|
|
#include <tqtooltip.h>
|
|
#include <tqwidget.h>
|
|
|
|
#include <kapplication.h>
|
|
#include <kcolordialog.h>
|
|
#include <kcolordrag.h>
|
|
#include <tdeconfig.h>
|
|
#include <kdebug.h>
|
|
#include <kiconloader.h>
|
|
#include <klocale.h>
|
|
|
|
#include <kpcolorsimilaritydialog.h>
|
|
#include <kpdefs.h>
|
|
#include <kpmainwindow.h>
|
|
#include <kppixmapfx.h>
|
|
#include <kptool.h>
|
|
#include <kpview.h>
|
|
|
|
|
|
/*
|
|
* kpDualColorButton
|
|
*/
|
|
|
|
kpDualColorButton::kpDualColorButton (kpMainWindow *mainWindow,
|
|
TQWidget *parent, const char *name)
|
|
: TQFrame (parent, name, TQt::WNoAutoErase/*no flicker*/),
|
|
m_mainWindow (mainWindow),
|
|
m_backBuffer (0)
|
|
{
|
|
setFrameStyle (TQFrame::Panel | TQFrame::Sunken);
|
|
|
|
m_color [0] = kpColor (0, 0, 0); // black
|
|
m_color [1] = kpColor (255, 255, 255); // white
|
|
|
|
setAcceptDrops (true);
|
|
}
|
|
|
|
kpDualColorButton::~kpDualColorButton ()
|
|
{
|
|
delete m_backBuffer; m_backBuffer = 0;
|
|
}
|
|
|
|
|
|
kpColor kpDualColorButton::color (int which) const
|
|
{
|
|
if (which < 0 || which > 1)
|
|
{
|
|
kdWarning () << "kpDualColorButton::color (" << which
|
|
<< ") - out of range" << endl;
|
|
which = 0;
|
|
}
|
|
|
|
return m_color [which];
|
|
}
|
|
|
|
kpColor kpDualColorButton::foregroundColor () const
|
|
{
|
|
return color (0);
|
|
}
|
|
|
|
kpColor kpDualColorButton::backgroundColor () const
|
|
{
|
|
return color (1);
|
|
}
|
|
|
|
|
|
void kpDualColorButton::setColor (int which, const kpColor &color)
|
|
{
|
|
if (which < 0 || which > 1)
|
|
{
|
|
kdWarning () << "kpDualColorButton::setColor (" << which
|
|
<< ") - out of range" << endl;
|
|
which = 0;
|
|
}
|
|
|
|
if (m_color [which] == color)
|
|
return;
|
|
|
|
m_oldColor [which] = m_color [which];
|
|
m_color [which] = color;
|
|
update ();
|
|
|
|
if (which == 0)
|
|
emit foregroundColorChanged (color);
|
|
else
|
|
emit backgroundColorChanged (color);
|
|
}
|
|
|
|
void kpDualColorButton::setForegroundColor (const kpColor &color)
|
|
{
|
|
setColor (0, color);
|
|
}
|
|
|
|
void kpDualColorButton::setBackgroundColor (const kpColor &color)
|
|
{
|
|
setColor (1, color);
|
|
}
|
|
|
|
|
|
// public
|
|
kpColor kpDualColorButton::oldForegroundColor () const
|
|
{
|
|
return m_oldColor [0];
|
|
}
|
|
|
|
// public
|
|
kpColor kpDualColorButton::oldBackgroundColor () const
|
|
{
|
|
return m_oldColor [1];
|
|
}
|
|
|
|
|
|
// public virtual [base TQWidget]
|
|
TQSize kpDualColorButton::sizeHint () const
|
|
{
|
|
return TQSize (52, 52);
|
|
}
|
|
|
|
|
|
// protected
|
|
TQRect kpDualColorButton::swapPixmapRect () const
|
|
{
|
|
TQPixmap swapPixmap = UserIcon ("colorbutton_swap_16x16");
|
|
|
|
return TQRect (contentsRect ().width () - swapPixmap.width (),
|
|
0,
|
|
swapPixmap.width (),
|
|
swapPixmap.height ());
|
|
}
|
|
|
|
// protected
|
|
TQRect kpDualColorButton::foregroundBackgroundRect () const
|
|
{
|
|
TQRect cr (contentsRect ());
|
|
return TQRect (cr.width () / 8,
|
|
cr.height () / 8,
|
|
cr.width () * 6 / 8,
|
|
cr.height () * 6 / 8);
|
|
}
|
|
|
|
// protected
|
|
TQRect kpDualColorButton::foregroundRect () const
|
|
{
|
|
TQRect fbr (foregroundBackgroundRect ());
|
|
return TQRect (fbr.x (),
|
|
fbr.y (),
|
|
fbr.width () * 3 / 4,
|
|
fbr.height () * 3 / 4);
|
|
}
|
|
|
|
// protected
|
|
TQRect kpDualColorButton::backgroundRect () const
|
|
{
|
|
TQRect fbr (foregroundBackgroundRect ());
|
|
return TQRect (fbr.x () + fbr.width () / 4,
|
|
fbr.y () + fbr.height () / 4,
|
|
fbr.width () * 3 / 4,
|
|
fbr.height () * 3 / 4);
|
|
}
|
|
|
|
|
|
// TODO: drag a colour from this widget
|
|
|
|
// protected virtual [base TQWidget]
|
|
void kpDualColorButton::dragMoveEvent (TQDragMoveEvent *e)
|
|
{
|
|
e->accept ((foregroundRect ().contains (e->pos ()) ||
|
|
backgroundRect ().contains (e->pos ())) &&
|
|
KColorDrag::canDecode (e));
|
|
}
|
|
|
|
// protected virtual [base TQWidget]
|
|
void kpDualColorButton::dropEvent (TQDropEvent *e)
|
|
{
|
|
TQColor col;
|
|
KColorDrag::decode (e, col/*ref*/);
|
|
|
|
if (col.isValid ())
|
|
{
|
|
if (foregroundRect ().contains (e->pos ()))
|
|
setForegroundColor (kpColor (col.rgb ()));
|
|
else if (backgroundRect ().contains (e->pos ()))
|
|
setBackgroundColor (kpColor (col.rgb ()));
|
|
}
|
|
}
|
|
|
|
|
|
// protected virtual [base TQWidget]
|
|
void kpDualColorButton::mousePressEvent (TQMouseEvent * /*e*/)
|
|
{
|
|
// eat right-mouse click to prevent it from getting to the toolbar
|
|
}
|
|
|
|
// protected virtual [base TQWidget]
|
|
void kpDualColorButton::mouseDoubleClickEvent (TQMouseEvent *e)
|
|
{
|
|
int whichColor = -1;
|
|
|
|
if (foregroundRect ().contains (e->pos ()))
|
|
whichColor = 0;
|
|
else if (backgroundRect ().contains (e->pos ()))
|
|
whichColor = 1;
|
|
|
|
if (whichColor == 0 || whichColor == 1)
|
|
{
|
|
TQColor col = TQt::black;
|
|
if (color (whichColor).isOpaque ())
|
|
col = color (whichColor).toTQColor ();
|
|
else
|
|
{
|
|
// TODO: If you double-click on a transparent color and press OK, you get
|
|
// black, instead of the color staying as transparent.
|
|
//
|
|
// We should modify or fork KColorDialog to allow us to fix this.
|
|
//
|
|
// It would be wrong to stop the user from double-clicking on a
|
|
// transparent color as that would make the UI inconsistent, compared
|
|
// to opaque colors.
|
|
}
|
|
|
|
// TODO: parent
|
|
if (KColorDialog::getColor (col/*ref*/))
|
|
setColor (whichColor, kpColor (col.rgb ()));
|
|
}
|
|
}
|
|
|
|
// protected virtual [base TQWidget]
|
|
void kpDualColorButton::mouseReleaseEvent (TQMouseEvent *e)
|
|
{
|
|
if (swapPixmapRect ().contains (e->pos ()) &&
|
|
m_color [0] != m_color [1])
|
|
{
|
|
#if DEBUG_KP_COLOR_TOOL_BAR && 1
|
|
kdDebug () << "kpDualColorButton::mouseReleaseEvent() swap colors:" << endl;
|
|
#endif
|
|
m_oldColor [0] = m_color [0];
|
|
m_oldColor [1] = m_color [1];
|
|
|
|
kpColor temp = m_color [0];
|
|
m_color [0] = m_color [1];
|
|
m_color [1] = temp;
|
|
|
|
update ();
|
|
|
|
emit colorsSwapped (m_color [0], m_color [1]);
|
|
emit foregroundColorChanged (m_color [0]);
|
|
emit backgroundColorChanged (m_color [1]);
|
|
}
|
|
}
|
|
|
|
|
|
// protected virtual [base TQFrame]
|
|
void kpDualColorButton::drawContents (TQPainter *p)
|
|
{
|
|
#if DEBUG_KP_COLOR_TOOL_BAR && 1
|
|
kdDebug () << "kpDualColorButton::draw() rect=" << rect ()
|
|
<< " contentsRect=" << contentsRect ()
|
|
<< endl;
|
|
#endif
|
|
|
|
if (!m_backBuffer ||
|
|
m_backBuffer->width () != contentsRect ().width () ||
|
|
m_backBuffer->height () != contentsRect ().height ())
|
|
{
|
|
delete m_backBuffer;
|
|
m_backBuffer = new TQPixmap (contentsRect ().width (), contentsRect ().height ());
|
|
}
|
|
|
|
|
|
TQPainter backBufferPainter (m_backBuffer);
|
|
|
|
if (isEnabled () && m_mainWindow)
|
|
{
|
|
kpView::drawTransparentBackground (&backBufferPainter,
|
|
m_backBuffer->width (), m_backBuffer->height (),
|
|
m_backBuffer->rect (),
|
|
true/*preview*/);
|
|
}
|
|
else
|
|
{
|
|
backBufferPainter.fillRect (m_backBuffer->rect (),
|
|
colorGroup ().color (TQColorGroup::Background));
|
|
}
|
|
|
|
TQPixmap swapPixmap = UserIcon ("colorbutton_swap_16x16");
|
|
if (!isEnabled ())
|
|
{
|
|
// swapPixmap has a mask after all
|
|
swapPixmap.fill (colorGroup ().color (TQColorGroup::Dark));
|
|
}
|
|
backBufferPainter.drawPixmap (swapPixmapRect ().topLeft (), swapPixmap);
|
|
|
|
// foreground patch must be drawn after background patch
|
|
// as it overlaps on top of background patch
|
|
TQRect bgRect = backgroundRect ();
|
|
TQRect bgRectInside = TQRect (bgRect.x () + 2, bgRect.y () + 2,
|
|
bgRect.width () - 4, bgRect.height () - 4);
|
|
if (isEnabled ())
|
|
{
|
|
#if DEBUG_KP_COLOR_TOOL_BAR && 1
|
|
kdDebug () << "\tbackgroundColor=" << (int *) m_color [1].toTQRgb ()
|
|
<< endl;
|
|
#endif
|
|
if (m_color [1].isOpaque ())
|
|
backBufferPainter.fillRect (bgRectInside, m_color [1].toTQColor ());
|
|
else
|
|
backBufferPainter.drawPixmap (bgRectInside, UserIcon ("color_transparent_26x26"));
|
|
}
|
|
else
|
|
backBufferPainter.fillRect (bgRectInside, colorGroup ().color (TQColorGroup::Button));
|
|
qDrawShadePanel (&backBufferPainter, bgRect, colorGroup (),
|
|
false/*not sunken*/, 2/*lineWidth*/,
|
|
0/*never fill*/);
|
|
|
|
TQRect fgRect = foregroundRect ();
|
|
TQRect fgRectInside = TQRect (fgRect.x () + 2, fgRect.y () + 2,
|
|
fgRect.width () - 4, fgRect.height () - 4);
|
|
if (isEnabled ())
|
|
{
|
|
#if DEBUG_KP_COLOR_TOOL_BAR && 1
|
|
kdDebug () << "\tforegroundColor=" << (int *) m_color [0].toTQRgb ()
|
|
<< endl;
|
|
#endif
|
|
if (m_color [0].isOpaque ())
|
|
backBufferPainter.fillRect (fgRectInside, m_color [0].toTQColor ());
|
|
else
|
|
backBufferPainter.drawPixmap (fgRectInside, UserIcon ("color_transparent_26x26"));
|
|
}
|
|
else
|
|
backBufferPainter.fillRect (fgRectInside, colorGroup ().color (TQColorGroup::Button));
|
|
qDrawShadePanel (&backBufferPainter, fgRect, colorGroup (),
|
|
false/*not sunken*/, 2/*lineWidth*/,
|
|
0/*never fill*/);
|
|
|
|
backBufferPainter.end ();
|
|
|
|
p->drawPixmap (contentsRect (), *m_backBuffer);
|
|
}
|
|
|
|
|
|
/*
|
|
* kpColorCells
|
|
*/
|
|
|
|
static inline int roundUp2 (int val)
|
|
{
|
|
return val % 2 ? val + 1 : val;
|
|
}
|
|
|
|
static inline int btwn0_255 (int val)
|
|
{
|
|
if (val < 0)
|
|
return 0;
|
|
else if (val > 255)
|
|
return 255;
|
|
else
|
|
return val;
|
|
}
|
|
|
|
enum
|
|
{
|
|
blendDark = 25,
|
|
blendNormal = 50,
|
|
blendLight = 75,
|
|
blendAdd = 100
|
|
};
|
|
|
|
static TQColor blend (const TQColor &a, const TQColor &b, int percent = blendNormal)
|
|
{
|
|
return TQColor (btwn0_255 (roundUp2 (a.red () + b.red ()) * percent / 100),
|
|
btwn0_255 (roundUp2 (a.green () + b.green ()) * percent / 100),
|
|
btwn0_255 (roundUp2 (a.blue () + b.blue ()) * percent / 100));
|
|
}
|
|
|
|
static TQColor add (const TQColor &a, const TQColor &b)
|
|
{
|
|
return blend (a, b, blendAdd);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// make our own colors in case weird ones like "TQt::cyan"
|
|
// (turquoise) get changed by TQt
|
|
//
|
|
|
|
// primary colors + B&W
|
|
static TQColor kpRed;
|
|
static TQColor kpGreen;
|
|
static TQColor kpBlue;
|
|
static TQColor kpBlack;
|
|
static TQColor kpWhite;
|
|
|
|
// intentionally _not_ an HSV darkener
|
|
static TQColor dark (const TQColor &color)
|
|
{
|
|
return blend (color, kpBlack);
|
|
}
|
|
|
|
// full-brightness colors
|
|
static TQColor kpYellow;
|
|
static TQColor kpPurple;
|
|
static TQColor kpAqua;
|
|
|
|
// mixed colors
|
|
static TQColor kpGrey;
|
|
static TQColor kpLightGrey;
|
|
static TQColor kpOrange;
|
|
|
|
// pastel colors
|
|
static TQColor kpPink;
|
|
static TQColor kpLightGreen;
|
|
static TQColor kpLightBlue;
|
|
static TQColor kpTan;
|
|
|
|
static bool ownColorsInitialised = false;
|
|
|
|
/* TODO: clean up this code!!!
|
|
* (probably when adding palette load/save)
|
|
*/
|
|
#define rows 2
|
|
#define cols 11
|
|
kpColorCells::kpColorCells (TQWidget *parent,
|
|
Qt::Orientation o,
|
|
const char *name)
|
|
: KColorCells (parent, rows, cols),
|
|
m_mouseButton (-1)
|
|
{
|
|
setName (name);
|
|
|
|
setShading (false); // no 3D look
|
|
|
|
// Trap KColorDrag so that kpMainWindow does not trap it.
|
|
// See our impl of dropEvent().
|
|
setAcceptDrops (true);
|
|
setAcceptDrags (true);
|
|
|
|
connect (this, TQT_SIGNAL (colorDoubleClicked (int)),
|
|
TQT_SLOT (slotColorDoubleClicked (int)));
|
|
|
|
if (!ownColorsInitialised)
|
|
{
|
|
// Don't initialise globally when we probably don't have a colour
|
|
// allocation context. This way, the colours aren't sometimes
|
|
// invalid (e.g. at 8-bit).
|
|
|
|
kpRed = TQColor (255, 0, 0);
|
|
kpGreen = TQColor (0, 255, 0);
|
|
kpBlue = TQColor (0, 0, 255);
|
|
kpBlack = TQColor (0, 0, 0);
|
|
kpWhite = TQColor (255, 255, 255);
|
|
|
|
kpYellow = add (kpRed, kpGreen);
|
|
kpPurple = add (kpRed, kpBlue);
|
|
kpAqua = add (kpGreen, kpBlue);
|
|
|
|
kpGrey = blend (kpBlack, kpWhite);
|
|
kpLightGrey = blend (kpGrey, kpWhite);
|
|
kpOrange = blend (kpRed, kpYellow);
|
|
|
|
kpPink = blend (kpRed, kpWhite);
|
|
kpLightGreen = blend (kpGreen, kpWhite);
|
|
kpLightBlue = blend (kpBlue, kpWhite);
|
|
kpTan = blend (kpYellow, kpWhite);
|
|
|
|
ownColorsInitialised = true;
|
|
}
|
|
|
|
setOrientation (o);
|
|
}
|
|
|
|
kpColorCells::~kpColorCells ()
|
|
{
|
|
}
|
|
|
|
Qt::Orientation kpColorCells::orientation () const
|
|
{
|
|
return m_orientation;
|
|
}
|
|
|
|
void kpColorCells::setOrientation (Qt::Orientation o)
|
|
{
|
|
int c, r;
|
|
|
|
if (o == Qt::Horizontal)
|
|
{
|
|
c = cols;
|
|
r = rows;
|
|
}
|
|
else
|
|
{
|
|
c = rows;
|
|
r = cols;
|
|
}
|
|
|
|
#if DEBUG_KP_COLOR_TOOL_BAR
|
|
kdDebug () << "kpColorCells::setOrientation(): r=" << r << " c=" << c << endl;
|
|
#endif
|
|
|
|
setNumRows (r);
|
|
setNumCols (c);
|
|
|
|
setCellWidth (26);
|
|
setCellHeight (26);
|
|
|
|
setFixedSize (numCols () * cellWidth () + frameWidth () * 2,
|
|
numRows () * cellHeight () + frameWidth () * 2);
|
|
|
|
/*
|
|
kdDebug () << "\tlimits: array=" << sizeof (colors) / sizeof (colors [0])
|
|
<< " r*c=" << r * c << endl;
|
|
kdDebug () << "\tsizeof (colors)=" << sizeof (colors)
|
|
<< " sizeof (colors [0])=" << sizeof (colors [0])
|
|
<< endl;*/
|
|
TQColor colors [] =
|
|
{
|
|
kpBlack,
|
|
kpGrey,
|
|
kpRed,
|
|
kpOrange,
|
|
kpYellow,
|
|
kpGreen,
|
|
kpAqua,
|
|
kpBlue,
|
|
kpPurple,
|
|
kpPink,
|
|
kpLightGreen,
|
|
|
|
kpWhite,
|
|
kpLightGrey,
|
|
dark (kpRed),
|
|
dark (kpOrange)/*brown*/,
|
|
dark (kpYellow),
|
|
dark (kpGreen),
|
|
dark (kpAqua),
|
|
dark (kpBlue),
|
|
dark (kpPurple),
|
|
kpLightBlue,
|
|
kpTan
|
|
};
|
|
|
|
for (int i = 0;
|
|
/*i < int (sizeof (colors) / sizeof (colors [0])) &&*/
|
|
i < r * c;
|
|
i++)
|
|
{
|
|
int y, x;
|
|
int pos;
|
|
|
|
if (o == Qt::Horizontal)
|
|
{
|
|
y = i / cols;
|
|
x = i % cols;
|
|
pos = i;
|
|
}
|
|
else
|
|
{
|
|
y = i % cols;
|
|
x = i / cols;
|
|
// int x = rows - 1 - i / cols;
|
|
pos = y * rows + x;
|
|
}
|
|
|
|
KColorCells::setColor (pos, colors [i]);
|
|
//TQToolTip::add (this, cellGeometry (y, x), colors [i].name ());
|
|
}
|
|
|
|
m_orientation = o;
|
|
}
|
|
|
|
// virtual protected [base KColorCells]
|
|
void kpColorCells::dropEvent (TQDropEvent *e)
|
|
{
|
|
// Eat event so that:
|
|
//
|
|
// 1. User doesn't clobber the palette (until we support reconfigurable
|
|
// palettes)
|
|
// 2. kpMainWindow::dropEvent() doesn't try to paste colour code as text
|
|
// (when the user slips and drags colour cell a little instead of clicking)
|
|
e->accept ();
|
|
}
|
|
|
|
// virtual protected
|
|
void kpColorCells::paintCell (TQPainter *painter, int row, int col)
|
|
{
|
|
TQColor oldColor;
|
|
int cellNo;
|
|
|
|
if (!isEnabled ())
|
|
{
|
|
cellNo = row * numCols () + col;
|
|
|
|
// make all cells 3D (so that disabled palette doesn't look flat)
|
|
setShading (true);
|
|
|
|
oldColor = KColorCells::color (cellNo);
|
|
KColorCells::colors [cellNo] = backgroundColor ();
|
|
}
|
|
|
|
|
|
// no focus rect as it doesn't make sense
|
|
// since 2 colors (foreground & background) can be selected
|
|
KColorCells::selected = -1;
|
|
KColorCells::paintCell (painter, row, col);
|
|
|
|
|
|
if (!isEnabled ())
|
|
{
|
|
KColorCells::colors [cellNo] = oldColor;
|
|
setShading (false);
|
|
}
|
|
}
|
|
|
|
// virtual protected
|
|
void kpColorCells::mouseReleaseEvent (TQMouseEvent *e)
|
|
{
|
|
m_mouseButton = -1;
|
|
|
|
TQt::ButtonState button = e->button ();
|
|
#if DEBUG_KP_COLOR_TOOL_BAR
|
|
kdDebug () << "kpColorCells::mouseReleaseEvent(left="
|
|
<< (button & Qt::LeftButton)
|
|
<< ",right="
|
|
<< (button & Qt::RightButton)
|
|
<< ")"
|
|
<< endl;
|
|
#endif
|
|
if (!((button & Qt::LeftButton) && (button & Qt::RightButton)))
|
|
{
|
|
if (button & Qt::LeftButton)
|
|
m_mouseButton = 0;
|
|
else if (button & Qt::RightButton)
|
|
m_mouseButton = 1;
|
|
}
|
|
|
|
connect (this, TQT_SIGNAL (colorSelected (int)), this, TQT_SLOT (slotColorSelected (int)));
|
|
KColorCells::mouseReleaseEvent (e);
|
|
disconnect (this, TQT_SIGNAL (colorSelected (int)), this, TQT_SLOT (slotColorSelected (int)));
|
|
|
|
#if DEBUG_KP_COLOR_TOOL_BAR
|
|
kdDebug () << "kpColorCells::mouseReleaseEvent() setting m_mouseButton back to -1" << endl;
|
|
#endif
|
|
m_mouseButton = -1;
|
|
}
|
|
|
|
// protected virtual [base KColorCells]
|
|
void kpColorCells::resizeEvent (TQResizeEvent *e)
|
|
{
|
|
// KColorCells::resizeEvent() tries to adjust the cellWidth and cellHeight
|
|
// to the current dimensions but doesn't take into account
|
|
// frame{Width,Height}().
|
|
//
|
|
// In any case, we already set the cell{Width,Height} and a fixed
|
|
// widget size and don't want any of it changed. Eat the resize event.
|
|
(void) e;
|
|
}
|
|
|
|
// protected slot
|
|
void kpColorCells::slotColorSelected (int cell)
|
|
{
|
|
#if DEBUG_KP_COLOR_TOOL_BAR
|
|
kdDebug () << "kpColorCells::slotColorSelected(cell=" << cell
|
|
<< ") mouseButton = " << m_mouseButton << endl;
|
|
#endif
|
|
TQColor c = KColorCells::color (cell);
|
|
|
|
if (m_mouseButton == 0)
|
|
{
|
|
emit foregroundColorChanged (c);
|
|
emit foregroundColorChanged (kpColor (c.rgb ()));
|
|
}
|
|
else if (m_mouseButton == 1)
|
|
{
|
|
emit backgroundColorChanged (c);
|
|
emit backgroundColorChanged (kpColor (c.rgb ()));
|
|
}
|
|
|
|
m_mouseButton = -1; // just in case
|
|
}
|
|
|
|
// protected slot
|
|
void kpColorCells::slotColorDoubleClicked (int cell)
|
|
{
|
|
#if DEBUG_KP_COLOR_TOOL_BAR
|
|
kdDebug () << "kpColorCells::slotColorDoubleClicked(cell="
|
|
<< cell << ")" << endl;
|
|
#endif
|
|
|
|
TQColor color = KColorCells::color (cell);
|
|
|
|
// TODO: parent
|
|
if (KColorDialog::getColor (color/*ref*/))
|
|
KColorCells::setColor (cell, color);
|
|
}
|
|
|
|
|
|
/*
|
|
* kpTransparentColorCell
|
|
*/
|
|
|
|
kpTransparentColorCell::kpTransparentColorCell (TQWidget *parent, const char *name)
|
|
: TQFrame (parent, name)
|
|
{
|
|
#if DEBUG_KP_COLOR_TOOL_BAR
|
|
kdDebug () << "kpTransparentColorCell::kpTransparentColorCell()" << endl;
|
|
#endif
|
|
|
|
setFrameStyle (TQFrame::Panel | TQFrame::Sunken);
|
|
#if DEBUG_KP_COLOR_TOOL_BAR && 0
|
|
kdDebug () << "\tdefault line width=" << lineWidth ()
|
|
<< " frame width=" << frameWidth () << endl;
|
|
#endif
|
|
//setLineWidth (2);
|
|
#if DEBUG_KP_COLOR_TOOL_BAR && 0
|
|
kdDebug () << "\tline width=" << lineWidth ()
|
|
<< " frame width=" << frameWidth () << endl;
|
|
#endif
|
|
|
|
m_pixmap = UserIcon ("color_transparent_26x26");
|
|
|
|
TQToolTip::add (this, i18n ("Transparent"));
|
|
}
|
|
|
|
kpTransparentColorCell::~kpTransparentColorCell ()
|
|
{
|
|
}
|
|
|
|
|
|
// public virtual [base TQWidget]
|
|
TQSize kpTransparentColorCell::sizeHint () const
|
|
{
|
|
return TQSize (m_pixmap.width () + frameWidth () * 2,
|
|
m_pixmap.height () + frameWidth () * 2);
|
|
}
|
|
|
|
// protected virtual [base TQWidget]
|
|
void kpTransparentColorCell::mousePressEvent (TQMouseEvent * /*e*/)
|
|
{
|
|
// eat right-mouse click to prevent it from getting to the toolbar
|
|
}
|
|
|
|
// protected virtual [base TQWidget]
|
|
void kpTransparentColorCell::mouseReleaseEvent (TQMouseEvent *e)
|
|
{
|
|
if (TQT_TQRECT_OBJECT(rect ()).contains (e->pos ()))
|
|
{
|
|
if (e->button () == Qt::LeftButton)
|
|
{
|
|
emit transparentColorSelected (0);
|
|
emit foregroundColorChanged (kpColor::transparent);
|
|
}
|
|
else if (e->button () == Qt::RightButton)
|
|
{
|
|
emit transparentColorSelected (1);
|
|
emit backgroundColorChanged (kpColor::transparent);
|
|
}
|
|
}
|
|
}
|
|
|
|
// protected virtual [base TQFrame]
|
|
void kpTransparentColorCell::drawContents (TQPainter *p)
|
|
{
|
|
TQFrame::drawContents (p);
|
|
if (isEnabled ())
|
|
{
|
|
#if DEBUG_KP_COLOR_TOOL_BAR
|
|
kdDebug () << "kpTransparentColorCell::drawContents() contentsRect="
|
|
<< contentsRect ()
|
|
<< endl;
|
|
#endif
|
|
p->drawPixmap (contentsRect (), m_pixmap);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* kpColorPalette
|
|
*/
|
|
|
|
kpColorPalette::kpColorPalette (TQWidget *parent,
|
|
Qt::Orientation o,
|
|
const char *name)
|
|
: TQWidget (parent, name),
|
|
m_boxLayout (0)
|
|
{
|
|
#if DEBUG_KP_COLOR_TOOL_BAR
|
|
kdDebug () << "kpColorPalette::kpColorPalette()" << endl;
|
|
#endif
|
|
|
|
m_transparentColorCell = new kpTransparentColorCell (this);
|
|
m_transparentColorCell->setSizePolicy (TQSizePolicy::Fixed, TQSizePolicy::Fixed);
|
|
connect (m_transparentColorCell, TQT_SIGNAL (foregroundColorChanged (const kpColor &)),
|
|
this, TQT_SIGNAL (foregroundColorChanged (const kpColor &)));
|
|
connect (m_transparentColorCell, TQT_SIGNAL (backgroundColorChanged (const kpColor &)),
|
|
this, TQT_SIGNAL (backgroundColorChanged (const kpColor &)));
|
|
|
|
m_colorCells = new kpColorCells (this);
|
|
connect (m_colorCells, TQT_SIGNAL (foregroundColorChanged (const kpColor &)),
|
|
this, TQT_SIGNAL (foregroundColorChanged (const kpColor &)));
|
|
connect (m_colorCells, TQT_SIGNAL (backgroundColorChanged (const kpColor &)),
|
|
this, TQT_SIGNAL (backgroundColorChanged (const kpColor &)));
|
|
|
|
setOrientation (o);
|
|
}
|
|
|
|
kpColorPalette::~kpColorPalette ()
|
|
{
|
|
}
|
|
|
|
// public
|
|
Qt::Orientation kpColorPalette::orientation () const
|
|
{
|
|
return m_orientation;
|
|
}
|
|
|
|
void kpColorPalette::setOrientation (Qt::Orientation o)
|
|
{
|
|
m_colorCells->setOrientation (o);
|
|
|
|
delete m_boxLayout;
|
|
|
|
if (o == Qt::Horizontal)
|
|
{
|
|
m_boxLayout = new TQBoxLayout (this, TQBoxLayout::LeftToRight, 0/*margin*/, 5/*spacing*/);
|
|
m_boxLayout->addWidget (m_transparentColorCell, 0/*stretch*/, TQt::AlignVCenter);
|
|
m_boxLayout->addWidget (m_colorCells);
|
|
}
|
|
else
|
|
{
|
|
m_boxLayout = new TQBoxLayout (this, TQBoxLayout::TopToBottom, 0/*margin*/, 5/*spacing*/);
|
|
m_boxLayout->addWidget (m_transparentColorCell, 0/*stretch*/, TQt::AlignHCenter);
|
|
m_boxLayout->addWidget (m_colorCells);
|
|
}
|
|
|
|
m_orientation = o;
|
|
}
|
|
|
|
|
|
/*
|
|
* kpColorSimilarityToolBarItem
|
|
*/
|
|
|
|
kpColorSimilarityToolBarItem::kpColorSimilarityToolBarItem (kpMainWindow *mainWindow,
|
|
TQWidget *parent,
|
|
const char *name)
|
|
: kpColorSimilarityCube (kpColorSimilarityCube::Depressed |
|
|
kpColorSimilarityCube::DoubleClickInstructions,
|
|
mainWindow, parent, name),
|
|
m_mainWindow (mainWindow),
|
|
m_processedColorSimilarity (kpColor::Exact)
|
|
{
|
|
setColorSimilarity (mainWindow->configColorSimilarity ());
|
|
}
|
|
|
|
kpColorSimilarityToolBarItem::~kpColorSimilarityToolBarItem ()
|
|
{
|
|
}
|
|
|
|
|
|
// public
|
|
int kpColorSimilarityToolBarItem::processedColorSimilarity () const
|
|
{
|
|
return m_processedColorSimilarity;
|
|
}
|
|
|
|
|
|
// public slot
|
|
void kpColorSimilarityToolBarItem::setColorSimilarity (double similarity)
|
|
{
|
|
m_oldColorSimilarity = colorSimilarity ();
|
|
|
|
kpColorSimilarityCube::setColorSimilarity (similarity);
|
|
if (similarity > 0)
|
|
TQToolTip::add (this, i18n ("Color similarity: %1%").arg (tqRound (similarity * 100)));
|
|
else
|
|
TQToolTip::add (this, i18n ("Color similarity: Exact"));
|
|
|
|
m_processedColorSimilarity = kpColor::processSimilarity (colorSimilarity ());
|
|
|
|
m_mainWindow->configSetColorSimilarity (colorSimilarity ());
|
|
|
|
emit colorSimilarityChanged (colorSimilarity (), m_processedColorSimilarity);
|
|
}
|
|
|
|
// public
|
|
double kpColorSimilarityToolBarItem::oldColorSimilarity () const
|
|
{
|
|
return m_oldColorSimilarity;
|
|
}
|
|
|
|
|
|
// private virtual [base TQWidget]
|
|
void kpColorSimilarityToolBarItem::mousePressEvent (TQMouseEvent * /*e*/)
|
|
{
|
|
// eat right-mouse click to prevent it from getting to the toolbar
|
|
}
|
|
|
|
// private virtual [base TQWidget]
|
|
void kpColorSimilarityToolBarItem::mouseDoubleClickEvent (TQMouseEvent * /*e*/)
|
|
{
|
|
kpColorSimilarityDialog dialog (m_mainWindow, this);
|
|
dialog.setColorSimilarity (colorSimilarity ());
|
|
if (dialog.exec ())
|
|
{
|
|
setColorSimilarity (dialog.colorSimilarity ());
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* kpColorToolBar
|
|
*/
|
|
|
|
kpColorToolBar::kpColorToolBar (const TQString &label, kpMainWindow *mainWindow, const char *name)
|
|
: KToolBar (mainWindow, name),
|
|
m_mainWindow (mainWindow)
|
|
{
|
|
setText (label);
|
|
|
|
|
|
TQWidget *base = new TQWidget (this);
|
|
m_boxLayout = new TQBoxLayout (base, TQBoxLayout::LeftToRight,
|
|
5/*margin*/, (10 * 4)/*spacing*/);
|
|
|
|
m_dualColorButton = new kpDualColorButton (mainWindow, base);
|
|
m_dualColorButton->setSizePolicy (TQSizePolicy::Fixed, TQSizePolicy::Fixed);
|
|
connect (m_dualColorButton, TQT_SIGNAL (colorsSwapped (const kpColor &, const kpColor &)),
|
|
this, TQT_SIGNAL (colorsSwapped (const kpColor &, const kpColor &)));
|
|
connect (m_dualColorButton, TQT_SIGNAL (foregroundColorChanged (const kpColor &)),
|
|
this, TQT_SIGNAL (foregroundColorChanged (const kpColor &)));
|
|
connect (m_dualColorButton, TQT_SIGNAL (backgroundColorChanged (const kpColor &)),
|
|
this, TQT_SIGNAL (backgroundColorChanged (const kpColor &)));
|
|
m_boxLayout->addWidget (m_dualColorButton, 0/*stretch*/);
|
|
|
|
m_colorPalette = new kpColorPalette (base);
|
|
connect (m_colorPalette, TQT_SIGNAL (foregroundColorChanged (const kpColor &)),
|
|
m_dualColorButton, TQT_SLOT (setForegroundColor (const kpColor &)));
|
|
connect (m_colorPalette, TQT_SIGNAL (backgroundColorChanged (const kpColor &)),
|
|
m_dualColorButton, TQT_SLOT (setBackgroundColor (const kpColor &)));
|
|
m_boxLayout->addWidget (m_colorPalette, 0/*stretch*/);
|
|
|
|
m_colorSimilarityToolBarItem = new kpColorSimilarityToolBarItem (mainWindow, base);
|
|
m_colorSimilarityToolBarItem->setSizePolicy (TQSizePolicy::Fixed, TQSizePolicy::Fixed);
|
|
connect (m_colorSimilarityToolBarItem, TQT_SIGNAL (colorSimilarityChanged (double, int)),
|
|
this, TQT_SIGNAL (colorSimilarityChanged (double, int)));
|
|
m_boxLayout->addWidget (m_colorSimilarityToolBarItem, 0/*stretch*/);
|
|
|
|
// HACK: couldn't get TQSpacerItem to work
|
|
TQWidget *fakeSpacer = new TQWidget (base);
|
|
m_boxLayout->addWidget (fakeSpacer, 1/*stretch*/);
|
|
|
|
m_lastDockedOrientationSet = false;
|
|
setOrientation (orientation ());
|
|
|
|
KToolBar::insertWidget (0, base->width (), base);
|
|
}
|
|
|
|
// virtual
|
|
void kpColorToolBar::setOrientation (Qt::Orientation o)
|
|
{
|
|
// (TQDockWindow::undock() calls us)
|
|
bool isOutsideDock = (place () == TQDockWindow::OutsideDock);
|
|
|
|
if (!m_lastDockedOrientationSet || !isOutsideDock)
|
|
{
|
|
m_lastDockedOrientation = o;
|
|
m_lastDockedOrientationSet = true;
|
|
}
|
|
|
|
if (isOutsideDock)
|
|
{
|
|
//kdDebug () << "\toutside dock, forcing orientation to last" << endl;
|
|
o = m_lastDockedOrientation;
|
|
}
|
|
|
|
if (o == Qt::Horizontal)
|
|
{
|
|
m_boxLayout->setDirection (TQBoxLayout::LeftToRight);
|
|
}
|
|
else
|
|
{
|
|
m_boxLayout->setDirection (TQBoxLayout::TopToBottom);
|
|
}
|
|
|
|
m_colorPalette->setOrientation (o);
|
|
|
|
KToolBar::setOrientation (o);
|
|
}
|
|
|
|
kpColorToolBar::~kpColorToolBar ()
|
|
{
|
|
}
|
|
|
|
kpColor kpColorToolBar::color (int which) const
|
|
{
|
|
if (which < 0 || which > 1)
|
|
{
|
|
kdWarning () << "kpColorToolBar::color (" << which
|
|
<< ") - out of range" << endl;
|
|
which = 0;
|
|
}
|
|
|
|
return m_dualColorButton->color (which);
|
|
}
|
|
|
|
void kpColorToolBar::setColor (int which, const kpColor &color)
|
|
{
|
|
if (which < 0 || which > 1)
|
|
{
|
|
kdWarning () << "kpColorToolBar::setColor (" << which
|
|
<< ") - out of range" << endl;
|
|
which = 0;
|
|
}
|
|
|
|
m_dualColorButton->setColor (which, color);
|
|
}
|
|
|
|
kpColor kpColorToolBar::foregroundColor () const
|
|
{
|
|
return m_dualColorButton->foregroundColor ();
|
|
}
|
|
|
|
void kpColorToolBar::setForegroundColor (const kpColor &color)
|
|
{
|
|
m_dualColorButton->setForegroundColor (color);
|
|
}
|
|
|
|
kpColor kpColorToolBar::backgroundColor () const
|
|
{
|
|
return m_dualColorButton->backgroundColor ();
|
|
}
|
|
|
|
void kpColorToolBar::setBackgroundColor (const kpColor &color)
|
|
{
|
|
m_dualColorButton->setBackgroundColor (color);
|
|
}
|
|
|
|
|
|
kpColor kpColorToolBar::oldForegroundColor () const
|
|
{
|
|
return m_dualColorButton->oldForegroundColor ();
|
|
}
|
|
|
|
kpColor kpColorToolBar::oldBackgroundColor () const
|
|
{
|
|
return m_dualColorButton->oldBackgroundColor ();
|
|
}
|
|
|
|
double kpColorToolBar::oldColorSimilarity () const
|
|
{
|
|
return m_colorSimilarityToolBarItem->oldColorSimilarity ();
|
|
}
|
|
|
|
|
|
double kpColorToolBar::colorSimilarity () const
|
|
{
|
|
return m_colorSimilarityToolBarItem->colorSimilarity ();
|
|
}
|
|
|
|
void kpColorToolBar::setColorSimilarity (double similarity)
|
|
{
|
|
m_colorSimilarityToolBarItem->setColorSimilarity (similarity);
|
|
}
|
|
|
|
int kpColorToolBar::processedColorSimilarity () const
|
|
{
|
|
return m_colorSimilarityToolBarItem->processedColorSimilarity ();
|
|
}
|
|
|
|
|
|
#include <kpcolortoolbar.moc>
|