2126 lines
54 KiB
C++
2126 lines
54 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
|
** All rights reserved.
|
|
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
**
|
|
** This file is part of the QtGui module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** GNU Lesser General Public License Usage
|
|
** This file may be used under the terms of the GNU Lesser General Public
|
|
** License version 2.1 as published by the Free Software Foundation and
|
|
** appearing in the file LICENSE.LGPL included in the packaging of this
|
|
** file. Please review the following information to ensure the GNU Lesser
|
|
** General Public License version 2.1 requirements will be met:
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
**
|
|
** In addition, as a special exception, Nokia gives you certain additional
|
|
** rights. These rights are described in the Nokia Qt LGPL Exception
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU General
|
|
** Public License version 3.0 as published by the Free Software Foundation
|
|
** and appearing in the file LICENSE.GPL included in the packaging of this
|
|
** file. Please review the following information to ensure the GNU General
|
|
** Public License version 3.0 requirements will be met:
|
|
** http://www.gnu.org/copyleft/gpl.html.
|
|
**
|
|
** Other Usage
|
|
** Alternatively, this file may be used in accordance with the terms and
|
|
** conditions contained in a signed written agreement between you and Nokia.
|
|
**
|
|
**
|
|
**
|
|
**
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "qcolordialog_p.h"
|
|
|
|
#ifndef QT_NO_COLORDIALOG
|
|
|
|
#include "qapplication.h"
|
|
#include "qdesktopwidget.h"
|
|
#include "qdrawutil.h"
|
|
#include "qevent.h"
|
|
#include "qimage.h"
|
|
#include "qdrag.h"
|
|
#include "qlabel.h"
|
|
#include "qlayout.h"
|
|
#include "qlineedit.h"
|
|
#include "qmenu.h"
|
|
#include "qpainter.h"
|
|
#include "qpixmap.h"
|
|
#include "qpushbutton.h"
|
|
#include "qsettings.h"
|
|
#include "qstyle.h"
|
|
#include "qstyleoption.h"
|
|
#include "qvalidator.h"
|
|
#include "qmimedata.h"
|
|
#include "qspinbox.h"
|
|
#include "qdialogbuttonbox.h"
|
|
#include "private/qguiplatformplugin_p.h"
|
|
|
|
#ifdef Q_WS_S60
|
|
#include "private/qt_s60_p.h"
|
|
#endif
|
|
|
|
#if defined(Q_WS_S60) || defined(Q_WS_MAEMO_5)
|
|
# define QT_SMALL_COLORDIALOG
|
|
#endif
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
//////////// QWellArray BEGIN
|
|
|
|
struct QWellArrayData;
|
|
|
|
class QWellArray : public QWidget
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(int selectedColumn READ selectedColumn)
|
|
Q_PROPERTY(int selectedRow READ selectedRow)
|
|
|
|
public:
|
|
QWellArray(int rows, int cols, QWidget* parent=0);
|
|
~QWellArray() {}
|
|
QString cellContent(int row, int col) const;
|
|
|
|
int selectedColumn() const { return selCol; }
|
|
int selectedRow() const { return selRow; }
|
|
|
|
virtual void setCurrent(int row, int col);
|
|
virtual void setSelected(int row, int col);
|
|
|
|
QSize sizeHint() const;
|
|
|
|
virtual void setCellBrush(int row, int col, const QBrush &);
|
|
QBrush cellBrush(int row, int col);
|
|
|
|
inline int cellWidth() const
|
|
{ return cellw; }
|
|
|
|
inline int cellHeight() const
|
|
{ return cellh; }
|
|
|
|
inline int rowAt(int y) const
|
|
{ return y / cellh; }
|
|
|
|
inline int columnAt(int x) const
|
|
{ if (isRightToLeft()) return ncols - (x / cellw) - 1; return x / cellw; }
|
|
|
|
inline int rowY(int row) const
|
|
{ return cellh * row; }
|
|
|
|
inline int columnX(int column) const
|
|
{ if (isRightToLeft()) return cellw * (ncols - column - 1); return cellw * column; }
|
|
|
|
inline int numRows() const
|
|
{ return nrows; }
|
|
|
|
inline int numCols() const
|
|
{return ncols; }
|
|
|
|
inline QRect cellRect() const
|
|
{ return QRect(0, 0, cellw, cellh); }
|
|
|
|
inline QSize gridSize() const
|
|
{ return QSize(ncols * cellw, nrows * cellh); }
|
|
|
|
QRect cellGeometry(int row, int column)
|
|
{
|
|
QRect r;
|
|
if (row >= 0 && row < nrows && column >= 0 && column < ncols)
|
|
r.setRect(columnX(column), rowY(row), cellw, cellh);
|
|
return r;
|
|
}
|
|
|
|
inline void updateCell(int row, int column) { update(cellGeometry(row, column)); }
|
|
|
|
signals:
|
|
void selected(int row, int col);
|
|
|
|
protected:
|
|
virtual void paintCell(QPainter *, int row, int col, const QRect&);
|
|
virtual void paintCellContents(QPainter *, int row, int col, const QRect&);
|
|
|
|
void mousePressEvent(QMouseEvent*);
|
|
void mouseReleaseEvent(QMouseEvent*);
|
|
void keyPressEvent(QKeyEvent*);
|
|
void focusInEvent(QFocusEvent*);
|
|
void focusOutEvent(QFocusEvent*);
|
|
void paintEvent(QPaintEvent *);
|
|
|
|
private:
|
|
Q_DISABLE_COPY(QWellArray)
|
|
|
|
int nrows;
|
|
int ncols;
|
|
int cellw;
|
|
int cellh;
|
|
int curRow;
|
|
int curCol;
|
|
int selRow;
|
|
int selCol;
|
|
QWellArrayData *d;
|
|
};
|
|
|
|
void QWellArray::paintEvent(QPaintEvent *e)
|
|
{
|
|
QRect r = e->rect();
|
|
int cx = r.x();
|
|
int cy = r.y();
|
|
int ch = r.height();
|
|
int cw = r.width();
|
|
int colfirst = columnAt(cx);
|
|
int collast = columnAt(cx + cw);
|
|
int rowfirst = rowAt(cy);
|
|
int rowlast = rowAt(cy + ch);
|
|
|
|
if (isRightToLeft()) {
|
|
int t = colfirst;
|
|
colfirst = collast;
|
|
collast = t;
|
|
}
|
|
|
|
QPainter painter(this);
|
|
QPainter *p = &painter;
|
|
QRect rect(0, 0, cellWidth(), cellHeight());
|
|
|
|
|
|
if (collast < 0 || collast >= ncols)
|
|
collast = ncols-1;
|
|
if (rowlast < 0 || rowlast >= nrows)
|
|
rowlast = nrows-1;
|
|
|
|
// Go through the rows
|
|
for (int r = rowfirst; r <= rowlast; ++r) {
|
|
// get row position and height
|
|
int rowp = rowY(r);
|
|
|
|
// Go through the columns in the row r
|
|
// if we know from where to where, go through [colfirst, collast],
|
|
// else go through all of them
|
|
for (int c = colfirst; c <= collast; ++c) {
|
|
// get position and width of column c
|
|
int colp = columnX(c);
|
|
// Translate painter and draw the cell
|
|
rect.translate(colp, rowp);
|
|
paintCell(p, r, c, rect);
|
|
rect.translate(-colp, -rowp);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct QWellArrayData {
|
|
QBrush *brush;
|
|
};
|
|
|
|
QWellArray::QWellArray(int rows, int cols, QWidget *parent)
|
|
: QWidget(parent)
|
|
,nrows(rows), ncols(cols)
|
|
{
|
|
d = 0;
|
|
setFocusPolicy(Qt::StrongFocus);
|
|
cellw = 28;
|
|
cellh = 24;
|
|
curCol = 0;
|
|
curRow = 0;
|
|
selCol = -1;
|
|
selRow = -1;
|
|
}
|
|
|
|
QSize QWellArray::sizeHint() const
|
|
{
|
|
ensurePolished();
|
|
return gridSize().boundedTo(QSize(640, 480));
|
|
}
|
|
|
|
|
|
void QWellArray::paintCell(QPainter* p, int row, int col, const QRect &rect)
|
|
{
|
|
int b = 3; //margin
|
|
|
|
const QPalette & g = palette();
|
|
QStyleOptionFrame opt;
|
|
int dfw = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
|
|
opt.lineWidth = dfw;
|
|
opt.midLineWidth = 1;
|
|
opt.rect = rect.adjusted(b, b, -b, -b);
|
|
opt.palette = g;
|
|
opt.state = QStyle::State_Enabled | QStyle::State_Sunken;
|
|
style()->drawPrimitive(QStyle::PE_Frame, &opt, p, this);
|
|
b += dfw;
|
|
|
|
if ((row == curRow) && (col == curCol)) {
|
|
if (hasFocus()) {
|
|
QStyleOptionFocusRect opt;
|
|
opt.palette = g;
|
|
opt.rect = rect;
|
|
opt.state = QStyle::State_None | QStyle::State_KeyboardFocusChange;
|
|
style()->drawPrimitive(QStyle::PE_FrameFocusRect, &opt, p, this);
|
|
}
|
|
}
|
|
paintCellContents(p, row, col, opt.rect.adjusted(dfw, dfw, -dfw, -dfw));
|
|
}
|
|
|
|
/*!
|
|
Reimplement this function to change the contents of the well array.
|
|
*/
|
|
void QWellArray::paintCellContents(QPainter *p, int row, int col, const QRect &r)
|
|
{
|
|
if (d) {
|
|
p->fillRect(r, d->brush[row*numCols()+col]);
|
|
} else {
|
|
p->fillRect(r, Qt::white);
|
|
p->setPen(Qt::black);
|
|
p->drawLine(r.topLeft(), r.bottomRight());
|
|
p->drawLine(r.topRight(), r.bottomLeft());
|
|
}
|
|
}
|
|
|
|
void QWellArray::mousePressEvent(QMouseEvent *e)
|
|
{
|
|
// The current cell marker is set to the cell the mouse is pressed in
|
|
QPoint pos = e->pos();
|
|
setCurrent(rowAt(pos.y()), columnAt(pos.x()));
|
|
}
|
|
|
|
void QWellArray::mouseReleaseEvent(QMouseEvent * /* event */)
|
|
{
|
|
// The current cell marker is set to the cell the mouse is clicked in
|
|
setSelected(curRow, curCol);
|
|
}
|
|
|
|
|
|
/*
|
|
Sets the cell currently having the focus. This is not necessarily
|
|
the same as the currently selected cell.
|
|
*/
|
|
|
|
void QWellArray::setCurrent(int row, int col)
|
|
{
|
|
if ((curRow == row) && (curCol == col))
|
|
return;
|
|
|
|
if (row < 0 || col < 0)
|
|
row = col = -1;
|
|
|
|
int oldRow = curRow;
|
|
int oldCol = curCol;
|
|
|
|
curRow = row;
|
|
curCol = col;
|
|
|
|
updateCell(oldRow, oldCol);
|
|
updateCell(curRow, curCol);
|
|
}
|
|
|
|
/*
|
|
Sets the currently selected cell to \a row, \a column. If \a row or
|
|
\a column are less than zero, the current cell is unselected.
|
|
|
|
Does not set the position of the focus indicator.
|
|
*/
|
|
void QWellArray::setSelected(int row, int col)
|
|
{
|
|
int oldRow = selRow;
|
|
int oldCol = selCol;
|
|
|
|
if (row < 0 || col < 0)
|
|
row = col = -1;
|
|
|
|
selCol = col;
|
|
selRow = row;
|
|
|
|
updateCell(oldRow, oldCol);
|
|
updateCell(selRow, selCol);
|
|
if (row >= 0)
|
|
emit selected(row, col);
|
|
|
|
#ifndef QT_NO_MENU
|
|
if (isVisible() && qobject_cast<QMenu*>(parentWidget()))
|
|
parentWidget()->close();
|
|
#endif
|
|
}
|
|
|
|
void QWellArray::focusInEvent(QFocusEvent*)
|
|
{
|
|
updateCell(curRow, curCol);
|
|
}
|
|
|
|
void QWellArray::setCellBrush(int row, int col, const QBrush &b)
|
|
{
|
|
if (!d) {
|
|
d = new QWellArrayData;
|
|
int i = numRows()*numCols();
|
|
d->brush = new QBrush[i];
|
|
}
|
|
if (row >= 0 && row < numRows() && col >= 0 && col < numCols())
|
|
d->brush[row*numCols()+col] = b;
|
|
}
|
|
|
|
/*
|
|
Returns the brush set for the cell at \a row, \a column. If no brush is
|
|
set, Qt::NoBrush is returned.
|
|
*/
|
|
|
|
QBrush QWellArray::cellBrush(int row, int col)
|
|
{
|
|
if (d && row >= 0 && row < numRows() && col >= 0 && col < numCols())
|
|
return d->brush[row*numCols()+col];
|
|
return Qt::NoBrush;
|
|
}
|
|
|
|
|
|
|
|
/*!\reimp
|
|
*/
|
|
|
|
void QWellArray::focusOutEvent(QFocusEvent*)
|
|
{
|
|
updateCell(curRow, curCol);
|
|
}
|
|
|
|
/*\reimp
|
|
*/
|
|
void QWellArray::keyPressEvent(QKeyEvent* e)
|
|
{
|
|
switch(e->key()) { // Look at the key code
|
|
case Qt::Key_Left: // If 'left arrow'-key,
|
|
if(curCol > 0) // and cr't not in leftmost col
|
|
setCurrent(curRow, curCol - 1); // set cr't to next left column
|
|
break;
|
|
case Qt::Key_Right: // Correspondingly...
|
|
if(curCol < numCols()-1)
|
|
setCurrent(curRow, curCol + 1);
|
|
break;
|
|
case Qt::Key_Up:
|
|
if(curRow > 0)
|
|
setCurrent(curRow - 1, curCol);
|
|
break;
|
|
case Qt::Key_Down:
|
|
if(curRow < numRows()-1)
|
|
setCurrent(curRow + 1, curCol);
|
|
break;
|
|
#if 0
|
|
// bad idea that shouldn't have been implemented; very counterintuitive
|
|
case Qt::Key_Return:
|
|
case Qt::Key_Enter:
|
|
/*
|
|
ignore the key, so that the dialog get it, but still select
|
|
the current row/col
|
|
*/
|
|
e->ignore();
|
|
// fallthrough intended
|
|
#endif
|
|
case Qt::Key_Space:
|
|
setSelected(curRow, curCol);
|
|
break;
|
|
default: // If not an interesting key,
|
|
e->ignore(); // we don't accept the event
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
//////////// QWellArray END
|
|
|
|
static bool initrgb = false;
|
|
static QRgb stdrgb[6*8];
|
|
static QRgb cusrgb[2*8];
|
|
static bool customSet = false;
|
|
|
|
|
|
static void initRGB()
|
|
{
|
|
if (initrgb)
|
|
return;
|
|
initrgb = true;
|
|
int i = 0;
|
|
for (int g = 0; g < 4; g++)
|
|
for (int r = 0; r < 4; r++)
|
|
for (int b = 0; b < 3; b++)
|
|
stdrgb[i++] = qRgb(r * 255 / 3, g * 255 / 3, b * 255 / 2);
|
|
|
|
for (i = 0; i < 2*8; i++)
|
|
cusrgb[i] = 0xffffffff;
|
|
}
|
|
|
|
/*!
|
|
Returns the number of custom colors supported by QColorDialog. All
|
|
color dialogs share the same custom colors.
|
|
*/
|
|
int QColorDialog::customCount()
|
|
{
|
|
return 2 * 8;
|
|
}
|
|
|
|
/*!
|
|
\since 4.5
|
|
|
|
Returns the custom color at the given \a index as a QRgb value.
|
|
*/
|
|
QRgb QColorDialog::customColor(int index)
|
|
{
|
|
if (uint(index) >= uint(customCount()))
|
|
return qRgb(255, 255, 255);
|
|
initRGB();
|
|
return cusrgb[index];
|
|
}
|
|
|
|
/*!
|
|
Sets the custom color at \a index to the QRgb \a color value.
|
|
|
|
\note This function does not apply to the Native Color Dialog on the Mac
|
|
OS X platform. If you still require this function, use the
|
|
QColorDialog::DontUseNativeDialog option.
|
|
*/
|
|
void QColorDialog::setCustomColor(int index, QRgb color)
|
|
{
|
|
if (uint(index) >= uint(customCount()))
|
|
return;
|
|
initRGB();
|
|
customSet = true;
|
|
cusrgb[index] = color;
|
|
}
|
|
|
|
/*!
|
|
Sets the standard color at \a index to the QRgb \a color value.
|
|
|
|
\note This function does not apply to the Native Color Dialog on the Mac
|
|
OS X platform. If you still require this function, use the
|
|
QColorDialog::DontUseNativeDialog option.
|
|
*/
|
|
|
|
void QColorDialog::setStandardColor(int index, QRgb color)
|
|
{
|
|
if (uint(index) >= uint(6 * 8))
|
|
return;
|
|
initRGB();
|
|
stdrgb[index] = color;
|
|
}
|
|
|
|
static inline void rgb2hsv(QRgb rgb, int &h, int &s, int &v)
|
|
{
|
|
QColor c;
|
|
c.setRgb(rgb);
|
|
c.getHsv(&h, &s, &v);
|
|
}
|
|
|
|
class QColorWell : public QWellArray
|
|
{
|
|
public:
|
|
QColorWell(QWidget *parent, int r, int c, QRgb *vals)
|
|
:QWellArray(r, c, parent), values(vals), mousePressed(false), oldCurrent(-1, -1)
|
|
{ setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum)); }
|
|
|
|
protected:
|
|
void paintCellContents(QPainter *, int row, int col, const QRect&);
|
|
void mousePressEvent(QMouseEvent *e);
|
|
void mouseMoveEvent(QMouseEvent *e);
|
|
void mouseReleaseEvent(QMouseEvent *e);
|
|
#ifndef QT_NO_DRAGANDDROP
|
|
void dragEnterEvent(QDragEnterEvent *e);
|
|
void dragLeaveEvent(QDragLeaveEvent *e);
|
|
void dragMoveEvent(QDragMoveEvent *e);
|
|
void dropEvent(QDropEvent *e);
|
|
#endif
|
|
|
|
private:
|
|
QRgb *values;
|
|
bool mousePressed;
|
|
QPoint pressPos;
|
|
QPoint oldCurrent;
|
|
|
|
};
|
|
|
|
void QColorWell::paintCellContents(QPainter *p, int row, int col, const QRect &r)
|
|
{
|
|
int i = row + col*numRows();
|
|
p->fillRect(r, QColor(values[i]));
|
|
}
|
|
|
|
void QColorWell::mousePressEvent(QMouseEvent *e)
|
|
{
|
|
oldCurrent = QPoint(selectedRow(), selectedColumn());
|
|
QWellArray::mousePressEvent(e);
|
|
mousePressed = true;
|
|
pressPos = e->pos();
|
|
}
|
|
|
|
void QColorWell::mouseMoveEvent(QMouseEvent *e)
|
|
{
|
|
QWellArray::mouseMoveEvent(e);
|
|
#ifndef QT_NO_DRAGANDDROP
|
|
if (!mousePressed)
|
|
return;
|
|
if ((pressPos - e->pos()).manhattanLength() > QApplication::startDragDistance()) {
|
|
setCurrent(oldCurrent.x(), oldCurrent.y());
|
|
int i = rowAt(pressPos.y()) + columnAt(pressPos.x()) * numRows();
|
|
QColor col(values[i]);
|
|
QMimeData *mime = new QMimeData;
|
|
mime->setColorData(col);
|
|
QPixmap pix(cellWidth(), cellHeight());
|
|
pix.fill(col);
|
|
QPainter p(&pix);
|
|
p.drawRect(0, 0, pix.width() - 1, pix.height() - 1);
|
|
p.end();
|
|
QDrag *drg = new QDrag(this);
|
|
drg->setMimeData(mime);
|
|
drg->setPixmap(pix);
|
|
mousePressed = false;
|
|
drg->start();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifndef QT_NO_DRAGANDDROP
|
|
void QColorWell::dragEnterEvent(QDragEnterEvent *e)
|
|
{
|
|
if (qvariant_cast<QColor>(e->mimeData()->colorData()).isValid())
|
|
e->accept();
|
|
else
|
|
e->ignore();
|
|
}
|
|
|
|
void QColorWell::dragLeaveEvent(QDragLeaveEvent *)
|
|
{
|
|
if (hasFocus())
|
|
parentWidget()->setFocus();
|
|
}
|
|
|
|
void QColorWell::dragMoveEvent(QDragMoveEvent *e)
|
|
{
|
|
if (qvariant_cast<QColor>(e->mimeData()->colorData()).isValid()) {
|
|
setCurrent(rowAt(e->pos().y()), columnAt(e->pos().x()));
|
|
e->accept();
|
|
} else {
|
|
e->ignore();
|
|
}
|
|
}
|
|
|
|
void QColorWell::dropEvent(QDropEvent *e)
|
|
{
|
|
QColor col = qvariant_cast<QColor>(e->mimeData()->colorData());
|
|
if (col.isValid()) {
|
|
int i = rowAt(e->pos().y()) + columnAt(e->pos().x()) * numRows();
|
|
values[i] = col.rgb();
|
|
update();
|
|
e->accept();
|
|
} else {
|
|
e->ignore();
|
|
}
|
|
}
|
|
|
|
#endif // QT_NO_DRAGANDDROP
|
|
|
|
void QColorWell::mouseReleaseEvent(QMouseEvent *e)
|
|
{
|
|
if (!mousePressed)
|
|
return;
|
|
QWellArray::mouseReleaseEvent(e);
|
|
mousePressed = false;
|
|
}
|
|
|
|
class QColorPicker : public QFrame
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
QColorPicker(QWidget* parent);
|
|
~QColorPicker();
|
|
|
|
public slots:
|
|
void setCol(int h, int s);
|
|
|
|
signals:
|
|
void newCol(int h, int s);
|
|
|
|
protected:
|
|
QSize sizeHint() const;
|
|
void paintEvent(QPaintEvent*);
|
|
void mouseMoveEvent(QMouseEvent *);
|
|
void mousePressEvent(QMouseEvent *);
|
|
void resizeEvent(QResizeEvent *);
|
|
|
|
private:
|
|
int hue;
|
|
int sat;
|
|
|
|
QPoint colPt();
|
|
int huePt(const QPoint &pt);
|
|
int satPt(const QPoint &pt);
|
|
void setCol(const QPoint &pt);
|
|
|
|
QPixmap pix;
|
|
};
|
|
|
|
static int pWidth = 220;
|
|
static int pHeight = 200;
|
|
|
|
class QColorLuminancePicker : public QWidget
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
QColorLuminancePicker(QWidget* parent=0);
|
|
~QColorLuminancePicker();
|
|
|
|
public slots:
|
|
void setCol(int h, int s, int v);
|
|
void setCol(int h, int s);
|
|
|
|
signals:
|
|
void newHsv(int h, int s, int v);
|
|
|
|
protected:
|
|
void paintEvent(QPaintEvent*);
|
|
void mouseMoveEvent(QMouseEvent *);
|
|
void mousePressEvent(QMouseEvent *);
|
|
|
|
private:
|
|
enum { foff = 3, coff = 4 }; //frame and contents offset
|
|
int val;
|
|
int hue;
|
|
int sat;
|
|
|
|
int y2val(int y);
|
|
int val2y(int val);
|
|
void setVal(int v);
|
|
|
|
QPixmap *pix;
|
|
};
|
|
|
|
|
|
int QColorLuminancePicker::y2val(int y)
|
|
{
|
|
int d = height() - 2*coff - 1;
|
|
return 255 - (y - coff)*255/d;
|
|
}
|
|
|
|
int QColorLuminancePicker::val2y(int v)
|
|
{
|
|
int d = height() - 2*coff - 1;
|
|
return coff + (255-v)*d/255;
|
|
}
|
|
|
|
QColorLuminancePicker::QColorLuminancePicker(QWidget* parent)
|
|
:QWidget(parent)
|
|
{
|
|
hue = 100; val = 100; sat = 100;
|
|
pix = 0;
|
|
// setAttribute(WA_NoErase, true);
|
|
}
|
|
|
|
QColorLuminancePicker::~QColorLuminancePicker()
|
|
{
|
|
delete pix;
|
|
}
|
|
|
|
void QColorLuminancePicker::mouseMoveEvent(QMouseEvent *m)
|
|
{
|
|
setVal(y2val(m->y()));
|
|
}
|
|
void QColorLuminancePicker::mousePressEvent(QMouseEvent *m)
|
|
{
|
|
setVal(y2val(m->y()));
|
|
}
|
|
|
|
void QColorLuminancePicker::setVal(int v)
|
|
{
|
|
if (val == v)
|
|
return;
|
|
val = qMax(0, qMin(v,255));
|
|
delete pix; pix=0;
|
|
repaint();
|
|
emit newHsv(hue, sat, val);
|
|
}
|
|
|
|
//receives from a hue,sat chooser and relays.
|
|
void QColorLuminancePicker::setCol(int h, int s)
|
|
{
|
|
setCol(h, s, val);
|
|
emit newHsv(h, s, val);
|
|
}
|
|
|
|
void QColorLuminancePicker::paintEvent(QPaintEvent *)
|
|
{
|
|
int w = width() - 5;
|
|
|
|
QRect r(0, foff, w, height() - 2*foff);
|
|
int wi = r.width() - 2;
|
|
int hi = r.height() - 2;
|
|
if (!pix || pix->height() != hi || pix->width() != wi) {
|
|
delete pix;
|
|
QImage img(wi, hi, QImage::Format_RGB32);
|
|
int y;
|
|
uint *pixel = (uint *) img.scanLine(0);
|
|
for (y = 0; y < hi; y++) {
|
|
const uint *end = pixel + wi;
|
|
while (pixel < end) {
|
|
QColor c;
|
|
c.setHsv(hue, sat, y2val(y+coff));
|
|
*pixel = c.rgb();
|
|
++pixel;
|
|
}
|
|
}
|
|
pix = new QPixmap(QPixmap::fromImage(img));
|
|
}
|
|
QPainter p(this);
|
|
p.drawPixmap(1, coff, *pix);
|
|
const QPalette &g = palette();
|
|
qDrawShadePanel(&p, r, g, true);
|
|
p.setPen(g.foreground().color());
|
|
p.setBrush(g.foreground());
|
|
QPolygon a;
|
|
int y = val2y(val);
|
|
a.setPoints(3, w, y, w+5, y+5, w+5, y-5);
|
|
p.eraseRect(w, 0, 5, height());
|
|
p.drawPolygon(a);
|
|
}
|
|
|
|
void QColorLuminancePicker::setCol(int h, int s , int v)
|
|
{
|
|
val = v;
|
|
hue = h;
|
|
sat = s;
|
|
delete pix; pix=0;
|
|
repaint();
|
|
}
|
|
|
|
QPoint QColorPicker::colPt()
|
|
{
|
|
QRect r = contentsRect();
|
|
return QPoint((360 - hue) * (r.width() - 1) / 360, (255 - sat) * (r.height() - 1) / 255);
|
|
}
|
|
|
|
int QColorPicker::huePt(const QPoint &pt)
|
|
{
|
|
QRect r = contentsRect();
|
|
return 360 - pt.x() * 360 / (r.width() - 1);
|
|
}
|
|
|
|
int QColorPicker::satPt(const QPoint &pt)
|
|
{
|
|
QRect r = contentsRect();
|
|
return 255 - pt.y() * 255 / (r.height() - 1);
|
|
}
|
|
|
|
void QColorPicker::setCol(const QPoint &pt)
|
|
{
|
|
setCol(huePt(pt), satPt(pt));
|
|
}
|
|
|
|
QColorPicker::QColorPicker(QWidget* parent)
|
|
: QFrame(parent)
|
|
{
|
|
hue = 0; sat = 0;
|
|
setCol(150, 255);
|
|
|
|
setAttribute(Qt::WA_NoSystemBackground);
|
|
setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed) );
|
|
}
|
|
|
|
QColorPicker::~QColorPicker()
|
|
{
|
|
}
|
|
|
|
QSize QColorPicker::sizeHint() const
|
|
{
|
|
return QSize(pWidth + 2*frameWidth(), pHeight + 2*frameWidth());
|
|
}
|
|
|
|
void QColorPicker::setCol(int h, int s)
|
|
{
|
|
int nhue = qMin(qMax(0,h), 359);
|
|
int nsat = qMin(qMax(0,s), 255);
|
|
if (nhue == hue && nsat == sat)
|
|
return;
|
|
|
|
QRect r(colPt(), QSize(20,20));
|
|
hue = nhue; sat = nsat;
|
|
r = r.united(QRect(colPt(), QSize(20,20)));
|
|
r.translate(contentsRect().x()-9, contentsRect().y()-9);
|
|
// update(r);
|
|
repaint(r);
|
|
}
|
|
|
|
void QColorPicker::mouseMoveEvent(QMouseEvent *m)
|
|
{
|
|
QPoint p = m->pos() - contentsRect().topLeft();
|
|
setCol(p);
|
|
emit newCol(hue, sat);
|
|
}
|
|
|
|
void QColorPicker::mousePressEvent(QMouseEvent *m)
|
|
{
|
|
QPoint p = m->pos() - contentsRect().topLeft();
|
|
setCol(p);
|
|
emit newCol(hue, sat);
|
|
}
|
|
|
|
void QColorPicker::paintEvent(QPaintEvent* )
|
|
{
|
|
QPainter p(this);
|
|
drawFrame(&p);
|
|
QRect r = contentsRect();
|
|
|
|
p.drawPixmap(r.topLeft(), pix);
|
|
QPoint pt = colPt() + r.topLeft();
|
|
p.setPen(Qt::black);
|
|
|
|
p.fillRect(pt.x()-9, pt.y(), 20, 2, Qt::black);
|
|
p.fillRect(pt.x(), pt.y()-9, 2, 20, Qt::black);
|
|
|
|
}
|
|
|
|
void QColorPicker::resizeEvent(QResizeEvent *ev)
|
|
{
|
|
QFrame::resizeEvent(ev);
|
|
|
|
int w = width() - frameWidth() * 2;
|
|
int h = height() - frameWidth() * 2;
|
|
QImage img(w, h, QImage::Format_RGB32);
|
|
int x, y;
|
|
uint *pixel = (uint *) img.scanLine(0);
|
|
for (y = 0; y < h; y++) {
|
|
const uint *end = pixel + w;
|
|
x = 0;
|
|
while (pixel < end) {
|
|
QPoint p(x, y);
|
|
QColor c;
|
|
c.setHsv(huePt(p), satPt(p), 200);
|
|
*pixel = c.rgb();
|
|
++pixel;
|
|
++x;
|
|
}
|
|
}
|
|
pix = QPixmap::fromImage(img);
|
|
}
|
|
|
|
|
|
class QColSpinBox : public QSpinBox
|
|
{
|
|
public:
|
|
QColSpinBox(QWidget *parent)
|
|
: QSpinBox(parent) { setRange(0, 255); }
|
|
void setValue(int i) {
|
|
bool block = signalsBlocked();
|
|
blockSignals(true);
|
|
QSpinBox::setValue(i);
|
|
blockSignals(block);
|
|
}
|
|
};
|
|
|
|
class QColorShowLabel;
|
|
|
|
class QColorShower : public QWidget
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
QColorShower(QColorDialog *parent);
|
|
|
|
//things that don't emit signals
|
|
void setHsv(int h, int s, int v);
|
|
|
|
int currentAlpha() const
|
|
{ return (colorDialog->options() & QColorDialog::ShowAlphaChannel) ? alphaEd->value() : 255; }
|
|
void setCurrentAlpha(int a) { alphaEd->setValue(a); rgbEd(); }
|
|
void showAlpha(bool b);
|
|
bool isAlphaVisible() const;
|
|
|
|
QRgb currentColor() const { return curCol; }
|
|
QColor currentQColor() const { return curQColor; }
|
|
void retranslateStrings();
|
|
void updateQColor();
|
|
|
|
public slots:
|
|
void setRgb(QRgb rgb);
|
|
|
|
signals:
|
|
void newCol(QRgb rgb);
|
|
void currentColorChanged(const QColor &color);
|
|
|
|
private slots:
|
|
void rgbEd();
|
|
void hsvEd();
|
|
private:
|
|
void showCurrentColor();
|
|
int hue, sat, val;
|
|
QRgb curCol;
|
|
QColor curQColor;
|
|
QLabel *lblHue;
|
|
QLabel *lblSat;
|
|
QLabel *lblVal;
|
|
QLabel *lblRed;
|
|
QLabel *lblGreen;
|
|
QLabel *lblBlue;
|
|
QColSpinBox *hEd;
|
|
QColSpinBox *sEd;
|
|
QColSpinBox *vEd;
|
|
QColSpinBox *rEd;
|
|
QColSpinBox *gEd;
|
|
QColSpinBox *bEd;
|
|
QColSpinBox *alphaEd;
|
|
QLabel *alphaLab;
|
|
QColorShowLabel *lab;
|
|
bool rgbOriginal;
|
|
QColorDialog *colorDialog;
|
|
|
|
friend class QColorDialog;
|
|
friend class QColorDialogPrivate;
|
|
};
|
|
|
|
class QColorShowLabel : public QFrame
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
QColorShowLabel(QWidget *parent) : QFrame(parent) {
|
|
setFrameStyle(QFrame::Panel|QFrame::Sunken);
|
|
setAcceptDrops(true);
|
|
mousePressed = false;
|
|
}
|
|
void setColor(QColor c) { col = c; }
|
|
|
|
signals:
|
|
void colorDropped(QRgb);
|
|
|
|
protected:
|
|
void paintEvent(QPaintEvent *);
|
|
void mousePressEvent(QMouseEvent *e);
|
|
void mouseMoveEvent(QMouseEvent *e);
|
|
void mouseReleaseEvent(QMouseEvent *e);
|
|
#ifndef QT_NO_DRAGANDDROP
|
|
void dragEnterEvent(QDragEnterEvent *e);
|
|
void dragLeaveEvent(QDragLeaveEvent *e);
|
|
void dropEvent(QDropEvent *e);
|
|
#endif
|
|
|
|
private:
|
|
QColor col;
|
|
bool mousePressed;
|
|
QPoint pressPos;
|
|
};
|
|
|
|
void QColorShowLabel::paintEvent(QPaintEvent *e)
|
|
{
|
|
QPainter p(this);
|
|
drawFrame(&p);
|
|
p.fillRect(contentsRect()&e->rect(), col);
|
|
}
|
|
|
|
void QColorShower::showAlpha(bool b)
|
|
{
|
|
alphaLab->setVisible(b);
|
|
alphaEd->setVisible(b);
|
|
}
|
|
|
|
inline bool QColorShower::isAlphaVisible() const
|
|
{
|
|
return alphaLab->isVisible();
|
|
}
|
|
|
|
void QColorShowLabel::mousePressEvent(QMouseEvent *e)
|
|
{
|
|
mousePressed = true;
|
|
pressPos = e->pos();
|
|
}
|
|
|
|
void QColorShowLabel::mouseMoveEvent(QMouseEvent *e)
|
|
{
|
|
#ifdef QT_NO_DRAGANDDROP
|
|
Q_UNUSED(e);
|
|
#else
|
|
if (!mousePressed)
|
|
return;
|
|
if ((pressPos - e->pos()).manhattanLength() > QApplication::startDragDistance()) {
|
|
QMimeData *mime = new QMimeData;
|
|
mime->setColorData(col);
|
|
QPixmap pix(30, 20);
|
|
pix.fill(col);
|
|
QPainter p(&pix);
|
|
p.drawRect(0, 0, pix.width() - 1, pix.height() - 1);
|
|
p.end();
|
|
QDrag *drg = new QDrag(this);
|
|
drg->setMimeData(mime);
|
|
drg->setPixmap(pix);
|
|
mousePressed = false;
|
|
drg->start();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifndef QT_NO_DRAGANDDROP
|
|
void QColorShowLabel::dragEnterEvent(QDragEnterEvent *e)
|
|
{
|
|
if (qvariant_cast<QColor>(e->mimeData()->colorData()).isValid())
|
|
e->accept();
|
|
else
|
|
e->ignore();
|
|
}
|
|
|
|
void QColorShowLabel::dragLeaveEvent(QDragLeaveEvent *)
|
|
{
|
|
}
|
|
|
|
void QColorShowLabel::dropEvent(QDropEvent *e)
|
|
{
|
|
QColor color = qvariant_cast<QColor>(e->mimeData()->colorData());
|
|
if (color.isValid()) {
|
|
col = color;
|
|
repaint();
|
|
emit colorDropped(col.rgb());
|
|
e->accept();
|
|
} else {
|
|
e->ignore();
|
|
}
|
|
}
|
|
#endif // QT_NO_DRAGANDDROP
|
|
|
|
void QColorShowLabel::mouseReleaseEvent(QMouseEvent *)
|
|
{
|
|
if (!mousePressed)
|
|
return;
|
|
mousePressed = false;
|
|
}
|
|
|
|
QColorShower::QColorShower(QColorDialog *parent)
|
|
: QWidget(parent)
|
|
{
|
|
colorDialog = parent;
|
|
|
|
curCol = qRgb(255, 255, 255);
|
|
curQColor = Qt::white;
|
|
|
|
QGridLayout *gl = new QGridLayout(this);
|
|
gl->setMargin(gl->spacing());
|
|
lab = new QColorShowLabel(this);
|
|
|
|
#ifdef QT_SMALL_COLORDIALOG
|
|
# ifdef Q_WS_S60
|
|
const bool nonTouchUI = !S60->hasTouchscreen;
|
|
# elif defined Q_WS_MAEMO_5
|
|
const bool nonTouchUI = false;
|
|
# endif
|
|
#endif
|
|
|
|
#ifndef Q_WS_WINCE
|
|
#ifdef QT_SMALL_COLORDIALOG
|
|
lab->setMinimumHeight(60);
|
|
#endif
|
|
lab->setMinimumWidth(60);
|
|
#else
|
|
lab->setMinimumWidth(20);
|
|
#endif
|
|
|
|
// In S60, due to small screen and different screen layouts need to re-arrange the widgets.
|
|
// For QVGA screens only the comboboxes and color label are visible.
|
|
// For nHD screens only color and luminence pickers and color label are visible.
|
|
#if !defined(QT_SMALL_COLORDIALOG)
|
|
gl->addWidget(lab, 0, 0, -1, 1);
|
|
#else
|
|
if (nonTouchUI)
|
|
gl->addWidget(lab, 0, 0, 1, -1);
|
|
else
|
|
gl->addWidget(lab, 0, 0, -1, 1);
|
|
#endif
|
|
connect(lab, SIGNAL(colorDropped(QRgb)), this, SIGNAL(newCol(QRgb)));
|
|
connect(lab, SIGNAL(colorDropped(QRgb)), this, SLOT(setRgb(QRgb)));
|
|
|
|
hEd = new QColSpinBox(this);
|
|
hEd->setRange(0, 359);
|
|
lblHue = new QLabel(this);
|
|
#ifndef QT_NO_SHORTCUT
|
|
lblHue->setBuddy(hEd);
|
|
#endif
|
|
lblHue->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
|
|
#if !defined(QT_SMALL_COLORDIALOG)
|
|
gl->addWidget(lblHue, 0, 1);
|
|
gl->addWidget(hEd, 0, 2);
|
|
#else
|
|
if (nonTouchUI) {
|
|
gl->addWidget(lblHue, 1, 0);
|
|
gl->addWidget(hEd, 2, 0);
|
|
} else {
|
|
lblHue->hide();
|
|
hEd->hide();
|
|
}
|
|
#endif
|
|
|
|
sEd = new QColSpinBox(this);
|
|
lblSat = new QLabel(this);
|
|
#ifndef QT_NO_SHORTCUT
|
|
lblSat->setBuddy(sEd);
|
|
#endif
|
|
lblSat->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
|
|
#if !defined(QT_SMALL_COLORDIALOG)
|
|
gl->addWidget(lblSat, 1, 1);
|
|
gl->addWidget(sEd, 1, 2);
|
|
#else
|
|
if (nonTouchUI) {
|
|
gl->addWidget(lblSat, 1, 1);
|
|
gl->addWidget(sEd, 2, 1);
|
|
} else {
|
|
lblSat->hide();
|
|
sEd->hide();
|
|
}
|
|
#endif
|
|
|
|
vEd = new QColSpinBox(this);
|
|
lblVal = new QLabel(this);
|
|
#ifndef QT_NO_SHORTCUT
|
|
lblVal->setBuddy(vEd);
|
|
#endif
|
|
lblVal->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
|
|
#if !defined(QT_SMALL_COLORDIALOG)
|
|
gl->addWidget(lblVal, 2, 1);
|
|
gl->addWidget(vEd, 2, 2);
|
|
#else
|
|
if (nonTouchUI) {
|
|
gl->addWidget(lblVal, 1, 2);
|
|
gl->addWidget(vEd, 2, 2);
|
|
} else {
|
|
lblVal->hide();
|
|
vEd->hide();
|
|
}
|
|
#endif
|
|
|
|
rEd = new QColSpinBox(this);
|
|
lblRed = new QLabel(this);
|
|
#ifndef QT_NO_SHORTCUT
|
|
lblRed->setBuddy(rEd);
|
|
#endif
|
|
lblRed->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
|
|
#if !defined(QT_SMALL_COLORDIALOG)
|
|
gl->addWidget(lblRed, 0, 3);
|
|
gl->addWidget(rEd, 0, 4);
|
|
#else
|
|
if (nonTouchUI) {
|
|
gl->addWidget(lblRed, 3, 0);
|
|
gl->addWidget(rEd, 4, 0);
|
|
} else {
|
|
lblRed->hide();
|
|
rEd->hide();
|
|
}
|
|
#endif
|
|
|
|
gEd = new QColSpinBox(this);
|
|
lblGreen = new QLabel(this);
|
|
#ifndef QT_NO_SHORTCUT
|
|
lblGreen->setBuddy(gEd);
|
|
#endif
|
|
lblGreen->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
|
|
#if !defined(QT_SMALL_COLORDIALOG)
|
|
gl->addWidget(lblGreen, 1, 3);
|
|
gl->addWidget(gEd, 1, 4);
|
|
#else
|
|
if (nonTouchUI) {
|
|
gl->addWidget(lblGreen, 3, 1);
|
|
gl->addWidget(gEd, 4, 1);
|
|
} else {
|
|
lblGreen->hide();
|
|
gEd->hide();
|
|
}
|
|
#endif
|
|
|
|
bEd = new QColSpinBox(this);
|
|
lblBlue = new QLabel(this);
|
|
#ifndef QT_NO_SHORTCUT
|
|
lblBlue->setBuddy(bEd);
|
|
#endif
|
|
lblBlue->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
|
|
#if !defined(QT_SMALL_COLORDIALOG)
|
|
gl->addWidget(lblBlue, 2, 3);
|
|
gl->addWidget(bEd, 2, 4);
|
|
#else
|
|
if (nonTouchUI) {
|
|
gl->addWidget(lblBlue, 3, 2);
|
|
gl->addWidget(bEd, 4, 2);
|
|
} else {
|
|
lblBlue->hide();
|
|
bEd->hide();
|
|
}
|
|
#endif
|
|
|
|
alphaEd = new QColSpinBox(this);
|
|
alphaLab = new QLabel(this);
|
|
#ifndef QT_NO_SHORTCUT
|
|
alphaLab->setBuddy(alphaEd);
|
|
#endif
|
|
alphaLab->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
|
|
#if !defined(QT_SMALL_COLORDIALOG)
|
|
gl->addWidget(alphaLab, 3, 1, 1, 3);
|
|
gl->addWidget(alphaEd, 3, 4);
|
|
#else
|
|
if (nonTouchUI) {
|
|
gl->addWidget(alphaLab, 1, 3, 3, 1);
|
|
gl->addWidget(alphaEd, 4, 3);
|
|
} else {
|
|
alphaLab->hide();
|
|
alphaEd->hide();
|
|
}
|
|
#endif
|
|
alphaEd->hide();
|
|
alphaLab->hide();
|
|
|
|
connect(hEd, SIGNAL(valueChanged(int)), this, SLOT(hsvEd()));
|
|
connect(sEd, SIGNAL(valueChanged(int)), this, SLOT(hsvEd()));
|
|
connect(vEd, SIGNAL(valueChanged(int)), this, SLOT(hsvEd()));
|
|
|
|
connect(rEd, SIGNAL(valueChanged(int)), this, SLOT(rgbEd()));
|
|
connect(gEd, SIGNAL(valueChanged(int)), this, SLOT(rgbEd()));
|
|
connect(bEd, SIGNAL(valueChanged(int)), this, SLOT(rgbEd()));
|
|
connect(alphaEd, SIGNAL(valueChanged(int)), this, SLOT(rgbEd()));
|
|
|
|
retranslateStrings();
|
|
}
|
|
|
|
inline QRgb QColorDialogPrivate::currentColor() const { return cs->currentColor(); }
|
|
inline int QColorDialogPrivate::currentAlpha() const { return cs->currentAlpha(); }
|
|
inline void QColorDialogPrivate::setCurrentAlpha(int a) { cs->setCurrentAlpha(a); }
|
|
inline void QColorDialogPrivate::showAlpha(bool b) { cs->showAlpha(b); }
|
|
inline bool QColorDialogPrivate::isAlphaVisible() const { return cs->isAlphaVisible(); }
|
|
|
|
QColor QColorDialogPrivate::currentQColor() const
|
|
{
|
|
return cs->currentQColor();
|
|
}
|
|
|
|
void QColorShower::showCurrentColor()
|
|
{
|
|
lab->setColor(currentColor());
|
|
lab->repaint();
|
|
}
|
|
|
|
void QColorShower::rgbEd()
|
|
{
|
|
rgbOriginal = true;
|
|
curCol = qRgba(rEd->value(), gEd->value(), bEd->value(), currentAlpha());
|
|
|
|
rgb2hsv(currentColor(), hue, sat, val);
|
|
|
|
hEd->setValue(hue);
|
|
sEd->setValue(sat);
|
|
vEd->setValue(val);
|
|
|
|
showCurrentColor();
|
|
emit newCol(currentColor());
|
|
updateQColor();
|
|
}
|
|
|
|
void QColorShower::hsvEd()
|
|
{
|
|
rgbOriginal = false;
|
|
hue = hEd->value();
|
|
sat = sEd->value();
|
|
val = vEd->value();
|
|
|
|
QColor c;
|
|
c.setHsv(hue, sat, val);
|
|
curCol = c.rgb();
|
|
|
|
rEd->setValue(qRed(currentColor()));
|
|
gEd->setValue(qGreen(currentColor()));
|
|
bEd->setValue(qBlue(currentColor()));
|
|
|
|
showCurrentColor();
|
|
emit newCol(currentColor());
|
|
updateQColor();
|
|
}
|
|
|
|
void QColorShower::setRgb(QRgb rgb)
|
|
{
|
|
rgbOriginal = true;
|
|
curCol = rgb;
|
|
|
|
rgb2hsv(currentColor(), hue, sat, val);
|
|
|
|
hEd->setValue(hue);
|
|
sEd->setValue(sat);
|
|
vEd->setValue(val);
|
|
|
|
rEd->setValue(qRed(currentColor()));
|
|
gEd->setValue(qGreen(currentColor()));
|
|
bEd->setValue(qBlue(currentColor()));
|
|
|
|
showCurrentColor();
|
|
updateQColor();
|
|
}
|
|
|
|
void QColorShower::setHsv(int h, int s, int v)
|
|
{
|
|
if (h < -1 || (uint)s > 255 || (uint)v > 255)
|
|
return;
|
|
|
|
rgbOriginal = false;
|
|
hue = h; val = v; sat = s;
|
|
QColor c;
|
|
c.setHsv(hue, sat, val);
|
|
curCol = c.rgb();
|
|
|
|
hEd->setValue(hue);
|
|
sEd->setValue(sat);
|
|
vEd->setValue(val);
|
|
|
|
rEd->setValue(qRed(currentColor()));
|
|
gEd->setValue(qGreen(currentColor()));
|
|
bEd->setValue(qBlue(currentColor()));
|
|
|
|
showCurrentColor();
|
|
updateQColor();
|
|
}
|
|
|
|
void QColorShower::retranslateStrings()
|
|
{
|
|
lblHue->setText(QColorDialog::tr("Hu&e:"));
|
|
lblSat->setText(QColorDialog::tr("&Sat:"));
|
|
lblVal->setText(QColorDialog::tr("&Val:"));
|
|
lblRed->setText(QColorDialog::tr("&Red:"));
|
|
lblGreen->setText(QColorDialog::tr("&Green:"));
|
|
lblBlue->setText(QColorDialog::tr("Bl&ue:"));
|
|
alphaLab->setText(QColorDialog::tr("A&lpha channel:"));
|
|
}
|
|
|
|
void QColorShower::updateQColor()
|
|
{
|
|
QColor oldQColor(curQColor);
|
|
curQColor.setRgba(qRgba(qRed(curCol), qGreen(curCol), qBlue(curCol), currentAlpha()));
|
|
if (curQColor != oldQColor)
|
|
emit currentColorChanged(curQColor);
|
|
}
|
|
|
|
//sets all widgets to display h,s,v
|
|
void QColorDialogPrivate::_q_newHsv(int h, int s, int v)
|
|
{
|
|
cs->setHsv(h, s, v);
|
|
cp->setCol(h, s);
|
|
lp->setCol(h, s, v);
|
|
}
|
|
|
|
//sets all widgets to display rgb
|
|
void QColorDialogPrivate::setCurrentColor(QRgb rgb)
|
|
{
|
|
cs->setRgb(rgb);
|
|
_q_newColorTypedIn(rgb);
|
|
}
|
|
|
|
// hack; doesn't keep curCol in sync, so use with care
|
|
void QColorDialogPrivate::setCurrentQColor(const QColor &color)
|
|
{
|
|
Q_Q(QColorDialog);
|
|
if (cs->curQColor != color) {
|
|
cs->curQColor = color;
|
|
emit q->currentColorChanged(color);
|
|
}
|
|
}
|
|
|
|
bool QColorDialogPrivate::selectColor(const QColor &col)
|
|
{
|
|
QRgb color = col.rgb();
|
|
int i = 0, j = 0;
|
|
// Check standard colors
|
|
if (standard) {
|
|
for (i = 0; i < 6; i++) {
|
|
for (j = 0; j < 8; j++) {
|
|
if (color == stdrgb[i + j*6]) {
|
|
_q_newStandard(i, j);
|
|
standard->setCurrent(i, j);
|
|
standard->setSelected(i, j);
|
|
standard->setFocus();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Check custom colors
|
|
if (custom) {
|
|
for (i = 0; i < 2; i++) {
|
|
for (j = 0; j < 8; j++) {
|
|
if (color == cusrgb[i + j*2]) {
|
|
_q_newCustom(i, j);
|
|
custom->setCurrent(i, j);
|
|
custom->setSelected(i, j);
|
|
custom->setFocus();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//sets all widgets except cs to display rgb
|
|
void QColorDialogPrivate::_q_newColorTypedIn(QRgb rgb)
|
|
{
|
|
int h, s, v;
|
|
rgb2hsv(rgb, h, s, v);
|
|
cp->setCol(h, s);
|
|
lp->setCol(h, s, v);
|
|
}
|
|
|
|
void QColorDialogPrivate::_q_newCustom(int r, int c)
|
|
{
|
|
int i = r+2*c;
|
|
setCurrentColor(cusrgb[i]);
|
|
nextCust = i;
|
|
if (standard)
|
|
standard->setSelected(-1,-1);
|
|
}
|
|
|
|
void QColorDialogPrivate::_q_newStandard(int r, int c)
|
|
{
|
|
setCurrentColor(stdrgb[r+c*6]);
|
|
if (custom)
|
|
custom->setSelected(-1,-1);
|
|
}
|
|
|
|
void QColorDialogPrivate::init(const QColor &initial)
|
|
{
|
|
Q_Q(QColorDialog);
|
|
|
|
q->setSizeGripEnabled(false);
|
|
q->setWindowTitle(QColorDialog::tr("Select Color"));
|
|
|
|
nativeDialogInUse = false;
|
|
|
|
nextCust = 0;
|
|
QVBoxLayout *mainLay = new QVBoxLayout(q);
|
|
// there's nothing in this dialog that benefits from sizing up
|
|
mainLay->setSizeConstraint(QLayout::SetFixedSize);
|
|
|
|
QHBoxLayout *topLay = new QHBoxLayout();
|
|
mainLay->addLayout(topLay);
|
|
|
|
leftLay = 0;
|
|
|
|
#if defined(Q_WS_WINCE) || defined(QT_SMALL_COLORDIALOG)
|
|
smallDisplay = true;
|
|
const int lumSpace = 20;
|
|
#else
|
|
// small displays (e.g. PDAs) cannot fit the full color dialog,
|
|
// so just use the color picker.
|
|
smallDisplay = (QApplication::desktop()->width() < 480 || QApplication::desktop()->height() < 350);
|
|
const int lumSpace = topLay->spacing() / 2;
|
|
#endif
|
|
|
|
if (!smallDisplay) {
|
|
leftLay = new QVBoxLayout;
|
|
topLay->addLayout(leftLay);
|
|
}
|
|
|
|
initRGB();
|
|
|
|
#ifndef QT_NO_SETTINGS
|
|
if (!customSet) {
|
|
QSettings settings(QSettings::UserScope, QLatin1String("Trolltech"));
|
|
for (int i = 0; i < 2*8; ++i) {
|
|
QVariant v = settings.value(QLatin1String("Qt/customColors/") + QString::number(i));
|
|
if (v.isValid()) {
|
|
QRgb rgb = v.toUInt();
|
|
cusrgb[i] = rgb;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if defined(QT_SMALL_COLORDIALOG)
|
|
# if defined(Q_WS_S60)
|
|
const bool nonTouchUI = !S60->hasTouchscreen;
|
|
# elif defined(Q_WS_MAEMO_5)
|
|
const bool nonTouchUI = false;
|
|
# endif
|
|
#endif
|
|
|
|
if (!smallDisplay) {
|
|
standard = new QColorWell(q, 6, 8, stdrgb);
|
|
lblBasicColors = new QLabel(q);
|
|
#ifndef QT_NO_SHORTCUT
|
|
lblBasicColors->setBuddy(standard);
|
|
#endif
|
|
q->connect(standard, SIGNAL(selected(int,int)), SLOT(_q_newStandard(int,int)));
|
|
leftLay->addWidget(lblBasicColors);
|
|
leftLay->addWidget(standard);
|
|
|
|
#if !defined(Q_WS_WINCE)
|
|
leftLay->addStretch();
|
|
#endif
|
|
|
|
custom = new QColorWell(q, 2, 8, cusrgb);
|
|
custom->setAcceptDrops(true);
|
|
|
|
q->connect(custom, SIGNAL(selected(int,int)), SLOT(_q_newCustom(int,int)));
|
|
lblCustomColors = new QLabel(q);
|
|
#ifndef QT_NO_SHORTCUT
|
|
lblCustomColors->setBuddy(custom);
|
|
#endif
|
|
leftLay->addWidget(lblCustomColors);
|
|
leftLay->addWidget(custom);
|
|
|
|
addCusBt = new QPushButton(q);
|
|
QObject::connect(addCusBt, SIGNAL(clicked()), q, SLOT(_q_addCustom()));
|
|
leftLay->addWidget(addCusBt);
|
|
} else {
|
|
// better color picker size for small displays
|
|
#if defined(QT_SMALL_COLORDIALOG)
|
|
QSize screenSize = QApplication::desktop()->availableGeometry(QCursor::pos()).size();
|
|
pWidth = pHeight = qMin(screenSize.width(), screenSize.height());
|
|
pHeight -= 20;
|
|
if(screenSize.height() > screenSize.width())
|
|
pWidth -= 20;
|
|
#else
|
|
pWidth = 150;
|
|
pHeight = 100;
|
|
#endif
|
|
custom = 0;
|
|
standard = 0;
|
|
}
|
|
|
|
QVBoxLayout *rightLay = new QVBoxLayout;
|
|
topLay->addLayout(rightLay);
|
|
|
|
QHBoxLayout *pickLay = new QHBoxLayout;
|
|
rightLay->addLayout(pickLay);
|
|
|
|
QVBoxLayout *cLay = new QVBoxLayout;
|
|
pickLay->addLayout(cLay);
|
|
cp = new QColorPicker(q);
|
|
|
|
cp->setFrameStyle(QFrame::Panel + QFrame::Sunken);
|
|
|
|
#if defined(QT_SMALL_COLORDIALOG)
|
|
if (!nonTouchUI) {
|
|
pickLay->addWidget(cp);
|
|
cLay->addSpacing(lumSpace);
|
|
} else {
|
|
cp->hide();
|
|
}
|
|
#else
|
|
cLay->addSpacing(lumSpace);
|
|
cLay->addWidget(cp);
|
|
#endif
|
|
cLay->addSpacing(lumSpace);
|
|
|
|
lp = new QColorLuminancePicker(q);
|
|
#if defined(QT_SMALL_COLORDIALOG)
|
|
QSize screenSize = QApplication::desktop()->availableGeometry(QCursor::pos()).size();
|
|
const int minDimension = qMin(screenSize.height(), screenSize.width());
|
|
//set picker to be finger-usable
|
|
int pickerWidth = !nonTouchUI ? minDimension/9 : minDimension/12;
|
|
lp->setFixedWidth(pickerWidth);
|
|
if (!nonTouchUI)
|
|
pickLay->addWidget(lp);
|
|
else
|
|
lp->hide();
|
|
#else
|
|
lp->setFixedWidth(20);
|
|
pickLay->addWidget(lp);
|
|
#endif
|
|
|
|
QObject::connect(cp, SIGNAL(newCol(int,int)), lp, SLOT(setCol(int,int)));
|
|
QObject::connect(lp, SIGNAL(newHsv(int,int,int)), q, SLOT(_q_newHsv(int,int,int)));
|
|
|
|
rightLay->addStretch();
|
|
|
|
cs = new QColorShower(q);
|
|
QObject::connect(cs, SIGNAL(newCol(QRgb)), q, SLOT(_q_newColorTypedIn(QRgb)));
|
|
QObject::connect(cs, SIGNAL(currentColorChanged(QColor)),
|
|
q, SIGNAL(currentColorChanged(QColor)));
|
|
#if defined(QT_SMALL_COLORDIALOG)
|
|
if (!nonTouchUI)
|
|
pWidth -= cp->size().width();
|
|
topLay->addWidget(cs);
|
|
#else
|
|
rightLay->addWidget(cs);
|
|
#endif
|
|
|
|
buttons = new QDialogButtonBox(q);
|
|
mainLay->addWidget(buttons);
|
|
|
|
ok = buttons->addButton(QDialogButtonBox::Ok);
|
|
QObject::connect(ok, SIGNAL(clicked()), q, SLOT(accept()));
|
|
ok->setDefault(true);
|
|
cancel = buttons->addButton(QDialogButtonBox::Cancel);
|
|
QObject::connect(cancel, SIGNAL(clicked()), q, SLOT(reject()));
|
|
|
|
retranslateStrings();
|
|
|
|
#ifdef Q_WS_MAC
|
|
delegate = 0;
|
|
#endif
|
|
|
|
q->setCurrentColor(initial);
|
|
}
|
|
|
|
void QColorDialogPrivate::_q_addCustom()
|
|
{
|
|
cusrgb[nextCust] = cs->currentColor();
|
|
if (custom)
|
|
custom->update();
|
|
nextCust = (nextCust+1) % 16;
|
|
}
|
|
|
|
void QColorDialogPrivate::_q_platformRunNativeAppModalPanel()
|
|
{
|
|
if (nativeDialogInUse)
|
|
platformHelper()->_q_platformRunNativeAppModalPanel();
|
|
}
|
|
|
|
void QColorDialogPrivate::retranslateStrings()
|
|
{
|
|
if (!smallDisplay) {
|
|
lblBasicColors->setText(QColorDialog::tr("&Basic colors"));
|
|
lblCustomColors->setText(QColorDialog::tr("&Custom colors"));
|
|
addCusBt->setText(QColorDialog::tr("&Add to Custom Colors"));
|
|
}
|
|
|
|
cs->retranslateStrings();
|
|
}
|
|
|
|
static const Qt::WindowFlags DefaultWindowFlags =
|
|
Qt::Dialog | Qt::WindowTitleHint | Qt::MSWindowsFixedSizeDialogHint
|
|
| Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint;
|
|
|
|
/*!
|
|
\class QColorDialog
|
|
\brief The QColorDialog class provides a dialog widget for specifying colors.
|
|
|
|
\ingroup standard-dialogs
|
|
\inmodule QtWidgets
|
|
|
|
The color dialog's function is to allow users to choose colors.
|
|
For example, you might use this in a drawing program to allow the
|
|
user to set the brush color.
|
|
|
|
The static functions provide modal color dialogs.
|
|
\omit
|
|
If you require a modeless dialog, use the QColorDialog constructor.
|
|
\endomit
|
|
|
|
The static getColor() function shows the dialog, and allows the user to
|
|
specify a color. This function can also be used to let users choose a
|
|
color with a level of transparency: pass the ShowAlphaChannel option as
|
|
an additional argument.
|
|
|
|
The user can store customCount() different custom colors. The
|
|
custom colors are shared by all color dialogs, and remembered
|
|
during the execution of the program. Use setCustomColor() to set
|
|
the custom colors, and use customColor() to get them.
|
|
|
|
Additional widgets that allow users to pick colors are available
|
|
as \l{Qt Solutions}.
|
|
|
|
The \l{dialogs/standarddialogs}{Standard Dialogs} example shows
|
|
how to use QColorDialog as well as other built-in Qt dialogs.
|
|
|
|
\image plastique-colordialog.png A color dialog in the Plastique widget style.
|
|
|
|
\sa QColor, QFileDialog, QPrintDialog, QFontDialog, {Standard Dialogs Example}
|
|
*/
|
|
|
|
/*!
|
|
\since 4.5
|
|
|
|
Constructs a color dialog with the given \a parent.
|
|
*/
|
|
QColorDialog::QColorDialog(QWidget *parent)
|
|
: QDialog(*new QColorDialogPrivate, parent, DefaultWindowFlags)
|
|
{
|
|
Q_D(QColorDialog);
|
|
d->init(Qt::white);
|
|
}
|
|
|
|
/*!
|
|
\since 4.5
|
|
|
|
Constructs a color dialog with the given \a parent and specified
|
|
\a initial color.
|
|
*/
|
|
QColorDialog::QColorDialog(const QColor &initial, QWidget *parent)
|
|
: QDialog(*new QColorDialogPrivate, parent, DefaultWindowFlags)
|
|
{
|
|
Q_D(QColorDialog);
|
|
d->init(initial);
|
|
}
|
|
|
|
/*!
|
|
\property QColorDialog::currentColor
|
|
\brief the currently selected color in the dialog
|
|
*/
|
|
|
|
void QColorDialog::setCurrentColor(const QColor &color)
|
|
{
|
|
Q_D(QColorDialog);
|
|
d->setCurrentColor(color.rgb());
|
|
d->selectColor(color);
|
|
d->setCurrentAlpha(color.alpha());
|
|
|
|
#ifdef Q_WS_MAC
|
|
d->setCurrentQColor(color);
|
|
d->setCocoaPanelColor(color);
|
|
#endif
|
|
if (d->nativeDialogInUse)
|
|
qt_guiPlatformPlugin()->colorDialogSetCurrentColor(this, color);
|
|
}
|
|
|
|
QColor QColorDialog::currentColor() const
|
|
{
|
|
Q_D(const QColorDialog);
|
|
return d->currentQColor();
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns the color that the user selected by clicking the \gui{OK}
|
|
or equivalent button.
|
|
|
|
\note This color is not always the same as the color held by the
|
|
\l currentColor property since the user can choose different colors
|
|
before finally selecting the one to use.
|
|
*/
|
|
QColor QColorDialog::selectedColor() const
|
|
{
|
|
Q_D(const QColorDialog);
|
|
return d->selectedQColor;
|
|
}
|
|
|
|
/*!
|
|
Sets the given \a option to be enabled if \a on is true;
|
|
otherwise, clears the given \a option.
|
|
|
|
\sa options, testOption()
|
|
*/
|
|
void QColorDialog::setOption(ColorDialogOption option, bool on)
|
|
{
|
|
Q_D(QColorDialog);
|
|
if (!(d->opts & option) != !on)
|
|
setOptions(d->opts ^ option);
|
|
}
|
|
|
|
/*!
|
|
\since 4.5
|
|
|
|
Returns true if the given \a option is enabled; otherwise, returns
|
|
false.
|
|
|
|
\sa options, setOption()
|
|
*/
|
|
bool QColorDialog::testOption(ColorDialogOption option) const
|
|
{
|
|
Q_D(const QColorDialog);
|
|
return (d->opts & option) != 0;
|
|
}
|
|
|
|
/*!
|
|
\property QColorDialog::options
|
|
\brief the various options that affect the look and feel of the dialog
|
|
|
|
By default, all options are disabled.
|
|
|
|
Options should be set before showing the dialog. Setting them while the
|
|
dialog is visible is not guaranteed to have an immediate effect on the
|
|
dialog (depending on the option and on the platform).
|
|
|
|
\sa setOption(), testOption()
|
|
*/
|
|
void QColorDialog::setOptions(ColorDialogOptions options)
|
|
{
|
|
Q_D(QColorDialog);
|
|
|
|
ColorDialogOptions changed = (options ^ d->opts);
|
|
if (!changed)
|
|
return;
|
|
|
|
d->opts = options;
|
|
d->buttons->setVisible(!(options & NoButtons));
|
|
d->showAlpha(options & ShowAlphaChannel);
|
|
}
|
|
|
|
QColorDialog::ColorDialogOptions QColorDialog::options() const
|
|
{
|
|
Q_D(const QColorDialog);
|
|
return d->opts;
|
|
}
|
|
|
|
/*!
|
|
\enum QColorDialog::ColorDialogOption
|
|
|
|
\since 4.5
|
|
|
|
This enum specifies various options that affect the look and feel
|
|
of a color dialog.
|
|
|
|
\value ShowAlphaChannel Allow the user to select the alpha component of a color.
|
|
\value NoButtons Don't display \gui{OK} and \gui{Cancel} buttons. (Useful for "live dialogs".)
|
|
\value DontUseNativeDialog Use Qt's standard color dialog on the Mac instead of Apple's
|
|
native color panel.
|
|
|
|
\sa options, setOption(), testOption(), windowModality()
|
|
*/
|
|
|
|
/*!
|
|
\fn void QColorDialog::currentColorChanged(const QColor &color)
|
|
|
|
This signal is emitted whenever the current color changes in the dialog.
|
|
The current color is specified by \a color.
|
|
|
|
\sa color, colorSelected()
|
|
*/
|
|
|
|
#ifdef Q_WS_MAC
|
|
// can only have one Cocoa color panel active
|
|
bool QColorDialogPrivate::sharedColorPanelAvailable = true;
|
|
#endif
|
|
|
|
/*!
|
|
\fn void QColorDialog::colorSelected(const QColor &color);
|
|
|
|
This signal is emitted just after the user has clicked \gui{OK} to
|
|
select a color to use. The chosen color is specified by \a color.
|
|
|
|
\sa color, currentColorChanged()
|
|
*/
|
|
|
|
/*!
|
|
Changes the visibility of the dialog. If \a visible is true, the dialog
|
|
is shown; otherwise, it is hidden.
|
|
*/
|
|
void QColorDialog::setVisible(bool visible)
|
|
{
|
|
Q_D(QColorDialog);
|
|
|
|
if (visible){
|
|
if (testAttribute(Qt::WA_WState_ExplicitShowHide) && !testAttribute(Qt::WA_WState_Hidden))
|
|
return;
|
|
} else if (testAttribute(Qt::WA_WState_ExplicitShowHide) && testAttribute(Qt::WA_WState_Hidden))
|
|
return;
|
|
|
|
if (visible)
|
|
d->selectedQColor = QColor();
|
|
|
|
#if defined(Q_WS_MAC)
|
|
if (visible) {
|
|
if (d->delegate || (QColorDialogPrivate::sharedColorPanelAvailable &&
|
|
!(testAttribute(Qt::WA_DontShowOnScreen) || (d->opts & DontUseNativeDialog)))){
|
|
d->openCocoaColorPanel(currentColor(), parentWidget(), windowTitle(), options());
|
|
QColorDialogPrivate::sharedColorPanelAvailable = false;
|
|
setAttribute(Qt::WA_DontShowOnScreen);
|
|
}
|
|
setWindowFlags(windowModality() == Qt::WindowModal ? Qt::Sheet : DefaultWindowFlags);
|
|
} else {
|
|
if (d->delegate) {
|
|
d->closeCocoaColorPanel();
|
|
setAttribute(Qt::WA_DontShowOnScreen, false);
|
|
}
|
|
}
|
|
#else
|
|
|
|
if (!(d->opts & DontUseNativeDialog))
|
|
if (QPlatformDialogHelper *helper = d->platformHelper())
|
|
d->nativeDialogInUse = helper->setVisible_sys(visible);
|
|
|
|
if (d->nativeDialogInUse) {
|
|
// Set WA_DontShowOnScreen so that QDialog::setVisible(visible) below
|
|
// updates the state correctly, but skips showing the non-native version:
|
|
setAttribute(Qt::WA_DontShowOnScreen);
|
|
} else {
|
|
d->nativeDialogInUse = false;
|
|
setAttribute(Qt::WA_DontShowOnScreen, false);
|
|
}
|
|
#endif
|
|
|
|
QDialog::setVisible(visible);
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
\since 4.5
|
|
|
|
Opens the dialog and connects its colorSelected() signal to the slot specified
|
|
by \a receiver and \a member.
|
|
|
|
The signal will be disconnected from the slot when the dialog is closed.
|
|
*/
|
|
void QColorDialog::open(QObject *receiver, const char *member)
|
|
{
|
|
Q_D(QColorDialog);
|
|
connect(this, SIGNAL(colorSelected(QColor)), receiver, member);
|
|
d->receiverToDisconnectOnClose = receiver;
|
|
d->memberToDisconnectOnClose = member;
|
|
QDialog::open();
|
|
}
|
|
|
|
/*!
|
|
\fn QColorDialog::open()
|
|
|
|
\since 4.5
|
|
Shows the dialog as a \l{QDialog#Modal Dialogs}{window modal dialog},
|
|
returning immediately.
|
|
|
|
\sa QDialog::open()
|
|
*/
|
|
|
|
/*
|
|
For Symbian color dialogs
|
|
*/
|
|
#ifdef Q_WS_S60
|
|
extern QColor qtSymbianGetColor(const QColor &initial);
|
|
#endif
|
|
/*!
|
|
\since 4.5
|
|
|
|
Pops up a modal color dialog with the given window \a title (or "Select Color" if none is
|
|
specified), lets the user choose a color, and returns that color. The color is initially set
|
|
to \a initial. The dialog is a child of \a parent. It returns an invalid (see
|
|
QColor::isValid()) color if the user cancels the dialog.
|
|
|
|
The \a options argument allows you to customize the dialog.
|
|
|
|
On Symbian, this static function will use the native color dialog and not a QColorDialog.
|
|
On Symbian the parameters \a title and \a parent has no relevance and the
|
|
\a options parameter is only used to define if the native color dialog is
|
|
used or not.
|
|
*/
|
|
QColor QColorDialog::getColor(const QColor &initial, QWidget *parent, const QString &title,
|
|
ColorDialogOptions options)
|
|
{
|
|
#ifdef Q_WS_S60
|
|
if (!(options & DontUseNativeDialog))
|
|
return qtSymbianGetColor(initial);
|
|
#endif
|
|
QColorDialog dlg(parent);
|
|
if (!title.isEmpty())
|
|
dlg.setWindowTitle(title);
|
|
dlg.setOptions(options);
|
|
dlg.setCurrentColor(initial);
|
|
dlg.exec();
|
|
return dlg.selectedColor();
|
|
}
|
|
|
|
/*!
|
|
Pops up a modal color dialog, lets the user choose a color, and
|
|
returns that color. The color is initially set to \a initial. The
|
|
dialog is a child of \a parent. It returns an invalid (see
|
|
QColor::isValid()) color if the user cancels the dialog.
|
|
|
|
On Symbian, this static function will use the native
|
|
color dialog and not a QColorDialog.
|
|
*/
|
|
|
|
QColor QColorDialog::getColor(const QColor &initial, QWidget *parent)
|
|
{
|
|
#ifdef Q_WS_S60
|
|
return qtSymbianGetColor(initial);
|
|
#endif
|
|
return getColor(initial, parent, QString(), ColorDialogOptions(0));
|
|
}
|
|
|
|
|
|
/*!
|
|
\obsolete
|
|
|
|
Pops up a modal color dialog to allow the user to choose a color
|
|
and an alpha channel (transparency) value. The color+alpha is
|
|
initially set to \a initial. The dialog is a child of \a parent.
|
|
|
|
If \a ok is non-null, \e *\a ok is set to true if the user clicked
|
|
\gui{OK}, and to false if the user clicked Cancel.
|
|
|
|
If the user clicks Cancel, the \a initial value is returned.
|
|
|
|
Use QColorDialog::getColor() instead, passing the
|
|
QColorDialog::ShowAlphaChannel option.
|
|
*/
|
|
|
|
QRgb QColorDialog::getRgba(QRgb initial, bool *ok, QWidget *parent)
|
|
{
|
|
QColor color(getColor(QColor(initial), parent, QString(), ShowAlphaChannel));
|
|
QRgb result = color.isValid() ? color.rgba() : initial;
|
|
if (ok)
|
|
*ok = color.isValid();
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
Destroys the color dialog.
|
|
*/
|
|
|
|
QColorDialog::~QColorDialog()
|
|
{
|
|
Q_D(QColorDialog);
|
|
#if defined(Q_WS_MAC)
|
|
if (d->delegate) {
|
|
d->releaseCocoaColorPanelDelegate();
|
|
QColorDialogPrivate::sharedColorPanelAvailable = true;
|
|
}
|
|
#endif
|
|
|
|
#ifndef QT_NO_SETTINGS
|
|
if (!customSet) {
|
|
QSettings settings(QSettings::UserScope, QLatin1String("Trolltech"));
|
|
for (int i = 0; i < 2*8; ++i)
|
|
settings.setValue(QLatin1String("Qt/customColors/") + QString::number(i), cusrgb[i]);
|
|
}
|
|
#endif
|
|
if (d->nativeDialogInUse)
|
|
qt_guiPlatformPlugin()->colorDialogDelete(this);
|
|
|
|
}
|
|
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
void QColorDialog::changeEvent(QEvent *e)
|
|
{
|
|
Q_D(QColorDialog);
|
|
if (e->type() == QEvent::LanguageChange)
|
|
d->retranslateStrings();
|
|
QDialog::changeEvent(e);
|
|
}
|
|
|
|
/*!
|
|
Closes the dialog and sets its result code to \a result. If this dialog
|
|
is shown with exec(), done() causes the local event loop to finish,
|
|
and exec() to return \a result.
|
|
|
|
\sa QDialog::done()
|
|
*/
|
|
void QColorDialog::done(int result)
|
|
{
|
|
Q_D(QColorDialog);
|
|
QDialog::done(result);
|
|
if (result == Accepted) {
|
|
d->selectedQColor = d->currentQColor();
|
|
emit colorSelected(d->selectedQColor);
|
|
} else {
|
|
d->selectedQColor = QColor();
|
|
}
|
|
if (d->receiverToDisconnectOnClose) {
|
|
disconnect(this, SIGNAL(colorSelected(QColor)),
|
|
d->receiverToDisconnectOnClose, d->memberToDisconnectOnClose);
|
|
d->receiverToDisconnectOnClose = 0;
|
|
}
|
|
d->memberToDisconnectOnClose.clear();
|
|
}
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
#include "qcolordialog.moc"
|
|
#include "moc_qcolordialog.cpp"
|
|
|
|
#endif // QT_NO_COLORDIALOG
|
|
|
|
/*!
|
|
\fn QColor QColorDialog::getColor(const QColor &init, QWidget *parent, const char *name)
|
|
\compat
|
|
*/
|
|
|
|
/*!
|
|
\fn QRgb QColorDialog::getRgba(QRgb rgba, bool *ok, QWidget *parent, const char *name)
|
|
\compat
|
|
*/
|