QColor ImageUtilities::computeAverageColor(const QImage& image)
{
long int rtotal = 0, gtotal = 0, btotal = 0;
float total = 0.0f;
// always sample 100x100 pixels
int samplePoints = 100;
int stepX = std::max(image.width() / samplePoints, 1);
int stepY = std::max(image.height() / samplePoints, 1);
for (int y = 0; y < image.height(); y += stepY) {
for (int x = 0; x < image.width(); x += stepX) {
QColor color = QColor::fromRgba(image.pixel(x, y));
float saturation = (qMax (color.red(), qMax (color.green(), color.blue())) -
qMin (color.red(), qMin (color.green(), color.blue()))) / 255.0f;
float relevance = .1 + .9 * (color.alpha() / 255.0f) * saturation;
rtotal += (unsigned char) (color.red() * relevance);
gtotal += (unsigned char) (color.green() * relevance);
btotal += (unsigned char) (color.blue() * relevance);
total += relevance * 255;
}
}
QColor hsv = QColor::fromRgbF(rtotal / total, gtotal / total, btotal / total).toHsv();
/* Background color is the base color with 0.90f HSV value */
hsv.setHsvF(hsv.hueF(),
(hsv.saturationF() > .15f) ? 0.65f : hsv.saturationF(),
0.90f);
return hsv;
}
void NQColorWheel::drawPicker(const QColor &color)
{
QPainter painter(&pixmapWheel_);
painter.setRenderHint(QPainter::Antialiasing);
QPen pen;
// region of the widget
int w = qMin(width(), height());
// radius of outer circle
qreal r = w/2-margin_;
// radius of inner circle
qreal ir = r-wheelWidth_;
// left corner of square
qreal m = w/2.0-ir/qSqrt(2);
painter.translate(m-5, m-5);
qreal SquareWidth = 2*ir/qSqrt(2);
qreal S = (color.saturationF()-minimumS_)/(1.0-minimumS_)*SquareWidth;
qreal V = color.valueF()*SquareWidth;
if (color.saturation() > 30 || color.value() < 50){
//pen.setColor(Qt::white);
}
pen.setWidth(2);
painter.setPen(pen);
painter.drawEllipse(S, V, 8, 8);
}
QVariantMap Core::colorToHsv(const QColor &color) {
QVariantMap map;
map["h"] = color.hueF();
map["s"] = color.saturationF();
map["v"] = color.valueF();
return map;
}
void HueSlider::setColor(const QColor& color)
{
p->saturation = color.saturationF();
p->value = color.valueF();
p->updateGradient();
setColorHue(color.hueF());
}
StatesEditorWidget::StatesEditorWidget(StatesEditorView *statesEditorView, StatesEditorModel *statesEditorModel):
QWidget(),
m_declarativeView(new QDeclarativeView(this)),
m_statesEditorView(statesEditorView),
m_imageProvider(0)
{
m_imageProvider = new Internal::StatesEditorImageProvider;
m_imageProvider->setNodeInstanceView(statesEditorView->nodeInstanceView());
m_declarativeView->engine()->addImageProvider(
QLatin1String("qmldesigner_stateseditor"), m_imageProvider);
m_declarativeView->setAcceptDrops(false);
QVBoxLayout *layout = new QVBoxLayout(this);
layout->setMargin(0);
layout->setSpacing(0);
layout->addWidget(m_declarativeView.data());
m_declarativeView->setResizeMode(QDeclarativeView::SizeRootObjectToView);
m_declarativeView->rootContext()->setContextProperty(QLatin1String("statesEditorModel"), statesEditorModel);
QColor highlightColor = palette().highlight().color();
if (0.5*highlightColor.saturationF()+0.75-highlightColor.valueF() < 0)
highlightColor.setHsvF(highlightColor.hsvHueF(),0.1 + highlightColor.saturationF()*2.0, highlightColor.valueF());
m_declarativeView->rootContext()->setContextProperty(QLatin1String("highlightColor"), highlightColor);
// Work around ASSERT in the internal QGraphicsScene that happens when
// the scene is created + items set dirty in one event loop run (BAUHAUS-459)
//QApplication::processEvents();
m_declarativeView->setSource(QUrl("qrc:/stateseditor/stateslist.qml"));
if (!m_declarativeView->rootObject())
throw InvalidQmlSourceException(__LINE__, __FUNCTION__, __FILE__);
m_declarativeView->setFocusPolicy(Qt::ClickFocus);
QApplication::sendEvent(m_declarativeView->scene(), new QEvent(QEvent::WindowActivate));
connect(m_declarativeView->rootObject(), SIGNAL(currentStateInternalIdChanged()), statesEditorView, SLOT(synchonizeCurrentStateFromWidget()));
connect(m_declarativeView->rootObject(), SIGNAL(createNewState()), statesEditorView, SLOT(createNewState()));
connect(m_declarativeView->rootObject(), SIGNAL(deleteState(int)), statesEditorView, SLOT(removeState(int)));
setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred));
setWindowTitle(tr("States", "Title of Editor widget"));
}
void Color2DSlider::setColor(const QColor& c)
{
p->hue = c.hsvHueF();
p->sat = c.saturationF();
p->val = c.valueF();
p->renderSquare(size());
update();
emit colorChanged(color());
}
void QtGradientStopsControllerPrivate::slotChangeAlpha(int color)
{
QColor c = m_ui->alphaColorLine->color();
if (m_ui->hsvRadioButton->isChecked())
c.setHsvF(c.hueF(), c.saturationF(), c.valueF(), (qreal)color / 255);
else
c.setAlpha(color);
slotChangeAlpha(c);
}
void QtGradientStopsControllerPrivate::slotChangeHue(int color)
{
QColor c = m_ui->hueColorLine->color();
if (m_ui->hsvRadioButton->isChecked())
c.setHsvF((qreal)color / 360.0, c.saturationF(), c.valueF(), c.alphaF());
else
c.setRed(color);
slotChangeHue(c);
}
StatesEditorWidget::StatesEditorWidget(StatesEditorView *statesEditorView, StatesEditorModel *statesEditorModel)
: QWidget(),
m_quickView(new QQuickView()),
m_statesEditorView(statesEditorView),
m_imageProvider(0),
m_qmlSourceUpdateShortcut(0)
{
m_imageProvider = new Internal::StatesEditorImageProvider;
m_imageProvider->setNodeInstanceView(statesEditorView->nodeInstanceView());
m_quickView->engine()->addImageProvider(QLatin1String("qmldesigner_stateseditor"), m_imageProvider);
m_quickView->engine()->addImportPath(statesEditorResourcesPath());
//m_quickView->setAcceptDrops(false);
m_qmlSourceUpdateShortcut = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_F4), this);
connect(m_qmlSourceUpdateShortcut, SIGNAL(activated()), this, SLOT(reloadQmlSource()));
QVBoxLayout *layout = new QVBoxLayout(this);
setMinimumHeight(160);
layout->setMargin(0);
layout->setSpacing(0);
QWidget *container = createWindowContainer(m_quickView.data());
layout->addWidget(container);
m_quickView->setResizeMode(QQuickView::SizeRootObjectToView);
m_quickView->rootContext()->setContextProperty(QLatin1String("statesEditorModel"), statesEditorModel);
QColor highlightColor = palette().highlight().color();
if (0.5*highlightColor.saturationF()+0.75-highlightColor.valueF() < 0)
highlightColor.setHsvF(highlightColor.hsvHueF(),0.1 + highlightColor.saturationF()*2.0, highlightColor.valueF());
m_quickView->rootContext()->setContextProperty(QLatin1String("highlightColor"), highlightColor);
m_quickView->rootContext()->setContextProperty("canAddNewStates", true);
setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred));
setWindowTitle(tr("States", "Title of Editor widget"));
// init the first load of the QML UI elements
reloadQmlSource();
}
void ColorPickerItem::setColor(const QColor & color)
{
m_hue = color.hueF();
m_sat = color.saturationF();
m_val = color.valueF();
if (m_hue < 0.0)
m_hue = 0.0;
regenHueSatPixmap();
regenValPixmap();
update();
}
void drawSelectionBackground(QPainter *painter, const QStyleOption &option)
{
QWidget colorReference;
painter->save();
QLinearGradient gradient;
QColor highlightColor = colorReference.palette().highlight().color();
if (0.5*highlightColor.saturationF()+0.75-highlightColor.valueF() < 0)
highlightColor.setHsvF(highlightColor.hsvHueF(),0.1 + highlightColor.saturationF()*2.0, highlightColor.valueF());
gradient.setColorAt(0, highlightColor.lighter(130));
gradient.setColorAt(1, highlightColor.darker(130));
gradient.setStart(option.rect.topLeft());
gradient.setFinalStop(option.rect.bottomLeft());
painter->fillRect(option.rect, gradient);
painter->setPen(highlightColor.lighter());
painter->drawLine(option.rect.topLeft(),option.rect.topRight());
painter->setPen(highlightColor.darker());
painter->drawLine(option.rect.bottomLeft(),option.rect.bottomRight());
painter->restore();
}
QColor getContrastedColor(const QColor& color)
{
QColor frontColor = Qt::white;
qreal s = color.saturationF();
if(s < 0.4)
{
qreal l = color.lightnessF();
if(l >= 0.5)
frontColor = Qt::black;
}
return frontColor;
}
void Color_Wheel::setColor(QColor c)
{
qreal oldh = huem;
huem = c.hueF();
if ( huem < 0 )
huem = 0;
sat = c.saturationF();
val = c.valueF();
if ( !qFuzzyCompare(oldh+1,huem+1) )
render_rectangle();
update();
emit colorChanged(c);
}
void KnotRendererBatch::themeChangedHandler()
{
/*
* We exlude colors that are too dark (but light colors are probably OK)
* lighter() multiplies a factor to the value, so it's not good enough to deal with potential pure black
* Force the value to be at least 0.2 seems to make more sense
*/
QColor color = Plasma::Theme::defaultTheme()->color(Plasma::Theme::ViewBackgroundColor);
if (color.valueF() < 0.2)
color.setHsvF(color.hueF(), color.saturationF(), 0.2);
emit colorRequest(color);
geometryChangedHandler();
}
void QtGradientStopsControllerPrivate::slotChangeAlpha(const QColor &color)
{
QtGradientStop *stop = m_model->currentStop();
if (!stop)
return;
m_model->changeStop(stop, color);
QList<QtGradientStop *> stops = m_model->selectedStops();
QListIterator<QtGradientStop *> itStop(stops);
while (itStop.hasNext()) {
QtGradientStop *s = itStop.next();
if (s != stop) {
QColor c = s->color();
if (m_ui->hsvRadioButton->isChecked()) {
c.setHsvF(c.hueF(), c.saturationF(), c.valueF(), color.alphaF());
int hue = c.hue();
if (hue == 360 || hue == -1)
c.setHsvF(0.0, c.saturationF(), c.valueF(), c.alphaF());
} else {
c.setRgbF(c.redF(), c.greenF(), c.blueF(), color.alphaF());
}
m_model->changeStop(s, c);
}
}
}
void
Scene_c3t3_item::compute_color_map(const QColor& c)
{
typedef Indices::size_type size_type;
size_type nb_domains = indices_.size();
size_type i = 0;
for (Indices::iterator it = indices_.begin(), end = indices_.end();
it != end; ++it, ++i)
{
double hue = c.hueF() + 1. / nb_domains * i;
if (hue > 1) { hue -= 1.; }
d->colors[*it] = QColor::fromHsvF(hue, c.saturationF(), c.valueF());
}
}
QString ColorRangeBase::toString(const QColor &clr, ColorRangeBase::ColorModel clrModel)
{
QString color;
switch(clrModel){
case ColorRangeBase::cmRGBA:
color += QString("RGBA(%1 %2 %3 %4)").arg(clr.redF(),0,'f',2).arg(clr.greenF(),0,'f',2).arg(clr.blueF(),0,'f',2).arg(clr.alphaF(),0,'f',2);
break;
case ColorRangeBase::cmHSLA:
color += QString("HSLA(%1 %2 %3 %4)").arg(clr.hueF(),0,'f',2).arg(clr.saturationF(),0,'f',2).arg(clr.lightnessF(),0,'f',2).arg(clr.alphaF(),0,'f',2);
break;
case ColorRangeBase::cmCYMKA:
color += QString("CMYKA(%1 %2 %3 %4 %5)").arg(clr.cyanF(),0,'f',2).arg(clr.magentaF(),0,'f',2).arg(clr.yellowF(),0,'f',2).arg(clr.blackF(),0,'f',2).arg(clr.alphaF(),0,'f',2);
break;
case ColorRangeBase::cmGREYSCALE:
color += QString("GREY(%1)").arg(clr.redF(),0,'f',2);
break;
default:
break;
}
return color;
}
void ColorBox::setColor(const QColor& color)
{
_updating = true;
_ui->red->setFirstColor(QColor(0, color.green(), color.blue()));
_ui->red->setLastColor(QColor(255, color.green(), color.blue()));
_ui->red->setValue(color.red());
_ui->redbox->setValue(color.red());
_ui->green->setFirstColor(QColor(color.red(), 0, color.blue()));
_ui->green->setLastColor(QColor(color.red(), 255, color.blue()));
_ui->green->setValue(color.green());
_ui->greenbox->setValue(color.green());
_ui->blue->setFirstColor(QColor(color.red(), color.green(), 0));
_ui->blue->setLastColor(QColor(color.red(), color.green(), 255));
_ui->blue->setValue(color.blue());
_ui->bluebox->setValue(color.blue());
_ui->hue->setColorSaturation(color.saturationF());
_ui->hue->setColorValue(color.valueF());
_ui->hue->setValue(color.hue());
_ui->huebox->setValue(color.hue());
_ui->saturation->setFirstColor(QColor::fromHsv(color.hue(), 0, color.value()));
_ui->saturation->setLastColor(QColor::fromHsv(color.hue(), 255, color.value()));
_ui->saturation->setValue(color.saturation());
_ui->saturationbox->setValue(color.saturation());
_ui->value->setFirstColor(QColor::fromHsv(color.hue(), color.saturation(), 0));
_ui->value->setLastColor(QColor::fromHsv(color.hue(), color.saturation(), 255));
_ui->value->setValue(color.value());
_ui->valuebox->setValue(color.value());
_ui->colorwheel->setColor(color);
_updating = false;
}
void ColorWheel::drawPicker(const QColor &color)
{
QPainter painter(&m_wheelPixmap);
painter.setRenderHint(QPainter::Antialiasing);
QPoint squareTopLeft = m_squareRegion.boundingRect().topLeft();
painter.translate(squareTopLeft.x(), squareTopLeft.y());
QSize squareSize = m_squareRegion.boundingRect().size();
qreal S = color.saturationF() * squareSize.width();
qreal V = squareSize.height() - (color.valueF() * squareSize.height());
QPen pen;
pen.setWidth(3);
if (color.saturation() > 30 || color.value() < 50)
{
pen.setColor(Qt::white);
}
painter.setPen(pen);
painter.drawEllipse(S - 5, V - 5, 10, 10);
}
void KisColorSelectorSimple::setColor(const QColor &c)
{
switch (m_parameter) {
case KisColorSelector::SL:
m_lastClickPos.setX(c.hslSaturationF());
m_lastClickPos.setY(1.-c.lightnessF());
emit paramChanged(-1, -1, -1, c.hslSaturationF(), c.lightnessF());
break;
case KisColorSelector::LH:
m_lastClickPos.setX(qBound<qreal>(0., c.hueF(), 1.));
m_lastClickPos.setY(1.-c.lightnessF());
emit paramChanged(c.hueF(), -1, -1, -1, c.lightnessF());
break;
case KisColorSelector::SV:
m_lastClickPos.setX(c.saturationF());
m_lastClickPos.setY(1-c.valueF());
emit paramChanged(-1, c.saturationF(), c.valueF(), -1, -1);
break;
case KisColorSelector::SV2: {
qreal xRel = c.hsvSaturationF();
qreal yRel = 0.5;
if(xRel != 1.0)
yRel = 1.0 - qBound<qreal>(0.0, (c.valueF() - xRel) / (1.0 - xRel), 1.0);
m_lastClickPos.setX(xRel);
m_lastClickPos.setY(yRel);
emit paramChanged(-1, -1, -1, xRel, yRel);
break;
}
case KisColorSelector::VH:
m_lastClickPos.setX(qBound<qreal>(0., c.hueF(), 1.));
m_lastClickPos.setY(c.valueF());
emit paramChanged(c.hueF(), -1, c.valueF(), -1, -1);
break;
case KisColorSelector::hsvSH:
m_lastClickPos.setX(qBound<qreal>(0., c.hueF(), 1.));
m_lastClickPos.setY(1-c.saturationF());
emit paramChanged(c.hueF(), c.saturationF(), -1, -1, -1);
break;
case KisColorSelector::hslSH:
m_lastClickPos.setX(qBound<qreal>(0., c.hueF(), 1.));
m_lastClickPos.setY(1-c.hslSaturationF());
emit paramChanged(c.hueF(), -1, -1, c.hslSaturationF(), -1);
break;
case KisColorSelector::L:
m_lastClickPos.setX(c.lightnessF());
emit paramChanged(-1, -1, -1, -1, c.lightnessF());
break;
case KisColorSelector::V:
m_lastClickPos.setX(c.valueF());
emit paramChanged(-1, -1, c.valueF(), -1, -1);
break;
case KisColorSelector::hsvS:
m_lastClickPos.setX(c.saturationF());
emit paramChanged(-1, c.saturationF(), -1, -1, -1);
break;
case KisColorSelector::hslS:
m_lastClickPos.setX(c.hslSaturationF());
emit paramChanged(-1, -1, -1, c.hslSaturationF(), -1);
break;
case KisColorSelector::H:
m_lastClickPos.setX(qBound<qreal>(0., c.hueF(), 1.));
emit paramChanged(c.hueF(), -1, -1, -1, -1);
break;
default:
Q_ASSERT(false);
break;
}
emit update();
}
QString colorToString(const QColor &color, ColorFormat format)
{
QString ret;
QString prefix;
QString colorComponents;
if (format == ColorFormat::QCssRgbUCharFormat) {
prefix = QLatin1String("rgb(");
colorComponents = QString::number(color.red()) + QLatin1String(", ")
+ QString::number(color.green()) + QLatin1String(", ")
+ QString::number(color.blue());
qreal alpha = color.alphaF();
if (alpha < 1.0) {
prefix.insert(3, QLatin1Char('a'));
colorComponents += QLatin1String(", ") + colorDoubleToQString(color.alphaF());
}
}
if (format == ColorFormat::QCssRgbPercentFormat) {
int rP = qRound(color.redF() * 100);
int gP = qRound(color.greenF() * 100);
int bP = qRound(color.blueF() * 100);
prefix = QLatin1String("rgb(");
colorComponents = QString::number(rP) + QChar::fromLatin1('%') + QLatin1String(", ")
+ QString::number(gP) + QChar::fromLatin1('%') + QLatin1String(", ")
+ QString::number(bP) + QChar::fromLatin1('%');
qreal alpha = color.alphaF();
if (alpha < 1.0) {
prefix.insert(3, QLatin1Char('a'));
colorComponents += QLatin1String(", ") + colorDoubleToQString(alpha);
}
}
else if (format == ColorFormat::QssHsvFormat) {
prefix = QLatin1String("hsv(");
colorComponents = QString::number(color.hsvHue()) + QLatin1String(", ")
+ QString::number(color.hsvSaturation()) + QLatin1String(", ")
+ QString::number(color.value());
int aP = qRound(color.alphaF() * 100);
if (aP < 100) {
prefix.insert(3, QLatin1Char('a'));
colorComponents += QLatin1String(", ") + colorDoubleToQString(aP);
}
}
else if (format == ColorFormat::CssHslFormat) {
prefix = QLatin1String("hsl(");
int sP = qRound(color.hslSaturationF() * 100);
int lP = qRound(color.lightnessF() * 100);
colorComponents = QString::number(color.hslHue()) + QLatin1String(", ")
+ QString::number(sP) + QChar::fromLatin1('%') + QLatin1String(", ")
+ QString::number(lP) + QChar::fromLatin1('%');
qreal alpha = color.alphaF();
if (alpha < 1.0) {
prefix.insert(3, QLatin1Char('a'));
colorComponents += QLatin1String(", ") + colorDoubleToQString(color.alphaF());
}
}
else if (format == ColorFormat::QmlRgbaFormat) {
prefix = QLatin1String("Qt.rgba(");
colorComponents = colorDoubleToQString(color.redF()) + QLatin1String(", ")
+ colorDoubleToQString(color.greenF()) + QLatin1String(", ")
+ colorDoubleToQString(color.blueF()) + QLatin1String(", ")
+ colorDoubleToQString(color.alphaF());
}
else if (format == ColorFormat::QmlHslaFormat) {
prefix = QLatin1String("Qt.hsla(");
colorComponents = colorDoubleToQString(color.hueF()) + QLatin1String(", ")
+ colorDoubleToQString(color.saturationF()) + QLatin1String(", ")
+ colorDoubleToQString(color.lightnessF()) + QLatin1String(", ")
+ colorDoubleToQString(color.alphaF());
}
else if (format == ColorFormat::GlslFormat) {
prefix = QLatin1String("vec");
colorComponents = colorDoubleToQString(color.redF()) + QLatin1String(", ")
+ colorDoubleToQString(color.greenF()) + QLatin1String(", ")
+ colorDoubleToQString(color.blueF());
qreal alpha = color.alphaF();
if (alpha < 1.0) {
prefix.append(QLatin1Char('4'));
colorComponents += QLatin1String(", ") + colorDoubleToQString(color.alphaF());
} else {
prefix.append(QLatin1Char('3'));
}
prefix.append(QLatin1Char('('));
}
else if (format == ColorFormat::HexFormat) {
prefix = QLatin1String("#");
int alpha = color.alpha();
if (alpha < 255)
colorComponents.sprintf("%02x%02x%02x%02x", alpha, color.red(), color.green(), color.blue());
else
colorComponents.sprintf("%02x%02x%02x", color.red(), color.green(), color.blue());
colorComponents = colorComponents.toUpper();
}
Q_ASSERT(!prefix.isNull());
Q_ASSERT(!colorComponents.isNull());
ret = prefix + colorComponents;
if (format != ColorFormat::HexFormat)
ret += QChar::fromLatin1(')');
Q_ASSERT_X(!ret.isNull(), Q_FUNC_INFO, "The string version of the color is invalid");
return ret;
}
double ColorFilterStrategySaturation::pixelToZeroToOne (const QColor &pixel,
QRgb /* rgbBackground */) const
{
return pixel.saturationF();
}
ItemLibraryWidget::ItemLibraryWidget(QWidget *parent) :
QFrame(parent),
m_iconProvider(m_resIconSize),
m_itemIconSize(24, 24),
m_resIconSize(24, 24),
m_itemsView(new QDeclarativeView(this)),
m_resourcesView(new Internal::ItemLibraryTreeView(this)),
m_filterFlag(QtBasic)
{
setWindowTitle(tr("Library", "Title of library view"));
/* create Items view and its model */
m_itemsView->setAttribute(Qt::WA_OpaquePaintEvent);
m_itemsView->setAttribute(Qt::WA_NoSystemBackground);
m_itemsView->setAcceptDrops(false);
m_itemsView->setFocusPolicy(Qt::ClickFocus);
m_itemsView->setResizeMode(QDeclarativeView::SizeRootObjectToView);
m_itemLibraryModel = new Internal::ItemLibraryModel(QDeclarativeEnginePrivate::getScriptEngine(m_itemsView->engine()), this);
m_itemLibraryModel->setItemIconSize(m_itemIconSize);
QDeclarativeContext *rootContext = m_itemsView->rootContext();
rootContext->setContextProperty(QLatin1String("itemLibraryModel"), m_itemLibraryModel.data());
rootContext->setContextProperty(QLatin1String("itemLibraryIconWidth"), m_itemIconSize.width());
rootContext->setContextProperty(QLatin1String("itemLibraryIconHeight"), m_itemIconSize.height());
QColor highlightColor = palette().highlight().color();
if (0.5*highlightColor.saturationF()+0.75-highlightColor.valueF() < 0)
highlightColor.setHsvF(highlightColor.hsvHueF(),0.1 + highlightColor.saturationF()*2.0, highlightColor.valueF());
m_itemsView->rootContext()->setContextProperty(QLatin1String("highlightColor"), highlightColor);
// loading the qml has to come after all needed context properties are set
m_itemsView->setSource(QUrl("qrc:/ItemLibrary/qml/ItemsView.qml"));
QDeclarativeItem *rootItem = qobject_cast<QDeclarativeItem*>(m_itemsView->rootObject());
connect(rootItem, SIGNAL(itemSelected(int)), this, SLOT(showItemInfo(int)));
connect(rootItem, SIGNAL(itemDragged(int)), this, SLOT(startDragAndDrop(int)));
connect(this, SIGNAL(scrollItemsView(QVariant)), rootItem, SLOT(scrollView(QVariant)));
connect(this, SIGNAL(resetItemsView()), rootItem, SLOT(resetView()));
/* create Resources view and its model */
m_resourcesFileSystemModel = new QFileSystemModel(this);
m_resourcesFileSystemModel->setIconProvider(&m_iconProvider);
m_resourcesView->setModel(m_resourcesFileSystemModel.data());
m_resourcesView->setIconSize(m_resIconSize);
/* create image provider for loading item icons */
m_itemsView->engine()->addImageProvider(QLatin1String("qmldesigner_itemlibrary"), new Internal::ItemLibraryImageProvider);
/* other widgets */
QTabBar *tabBar = new QTabBar(this);
tabBar->addTab(tr("Items", "Title of library items view"));
tabBar->addTab(tr("Resources", "Title of library resources view"));
tabBar->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
m_lineEdit = new Utils::FilterLineEdit(this);
m_lineEdit->setObjectName(QLatin1String("itemLibrarySearchInput"));
m_lineEdit->setPlaceholderText(tr("<Filter>", "Library search input hint text"));
m_lineEdit->setDragEnabled(false);
m_lineEdit->setMinimumWidth(75);
m_lineEdit->setTextMargins(0, 0, 20, 0);
QWidget *lineEditFrame = new QWidget(this);
lineEditFrame->setObjectName(QLatin1String("itemLibrarySearchInputFrame"));
QGridLayout *lineEditLayout = new QGridLayout(lineEditFrame);
lineEditLayout->setMargin(2);
lineEditLayout->setSpacing(0);
lineEditLayout->addItem(new QSpacerItem(5, 3, QSizePolicy::Fixed, QSizePolicy::Fixed), 0, 0, 1, 3);
lineEditLayout->addItem(new QSpacerItem(5, 5, QSizePolicy::Fixed, QSizePolicy::Fixed), 1, 0);
lineEditLayout->addWidget(m_lineEdit.data(), 1, 1, 1, 1);
lineEditLayout->addItem(new QSpacerItem(5, 5, QSizePolicy::Fixed, QSizePolicy::Fixed), 1, 2);
connect(m_lineEdit.data(), SIGNAL(filterChanged(QString)), this, SLOT(setSearchFilter(QString)));
m_stackedWidget = new QStackedWidget(this);
m_stackedWidget->addWidget(m_itemsView.data());
m_stackedWidget->addWidget(m_resourcesView.data());
connect(tabBar, SIGNAL(currentChanged(int)),
m_stackedWidget.data(), SLOT(setCurrentIndex(int)));
connect(tabBar, SIGNAL(currentChanged(int)),
this, SLOT(updateSearch()));
QWidget *spacer = new QWidget(this);
spacer->setObjectName(QLatin1String("itemLibrarySearchInputSpacer"));
spacer->setFixedHeight(4);
QGridLayout *layout = new QGridLayout(this);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
layout->addWidget(tabBar, 0, 0, 1, 1);
layout->addWidget(spacer, 1, 0);
layout->addWidget(lineEditFrame, 2, 0, 1, 1);
layout->addWidget(m_stackedWidget.data(), 3, 0, 1, 1);
setResourcePath(QDir::currentPath());
setSearchFilter(QString());
/* style sheets */
setStyleSheet(QLatin1String(Utils::FileReader::fetchQrc(":/qmldesigner/stylesheet.css")));
m_resourcesView->setStyleSheet(
QLatin1String(Utils::FileReader::fetchQrc(":/qmldesigner/scrollbar.css")));
}
void tst_QColor::setHsv()
{
QColor color;
for (int A = 0; A <= USHRT_MAX; ++A) {
{
// 0-255
int a = A >> 8;
color.setHsv(0, 0, 0, a);
QCOMPARE(color.alpha(), a);
int h, s, v, a2;
color.getHsv(&h, &s, &v, &a2);
QCOMPARE(a2, a);
}
{
// 0.0-1.0
qreal a = A / qreal(USHRT_MAX);
color.setHsvF(0.0, 0.0, 0.0, a);
QCOMPARE(color.alphaF(), a);
qreal h, s, v, a2;
color.getHsvF(&h, &s, &v, &a2);
QCOMPARE(a2, a);
}
}
for (int H = 0; H < 36000; ++H) {
{
// 0-255
int h = H / 100;
color.setHsv(h, 0, 0, 0);
QCOMPARE(color.hue(), h);
int h2, s, v, a;
color.getHsv(&h2, &s, &v, &a);
QCOMPARE(h2, h);
}
{
// 0.0-1.0
qreal h = H / 36000.0;
color.setHsvF(h, 0.0, 0.0, 0.0);
QCOMPARE(color.hueF(), h);
qreal h2, s, v, a;
color.getHsvF(&h2, &s, &v, &a);
QCOMPARE(h2, h);
}
}
for (int S = 0; S <= USHRT_MAX; ++S) {
{
// 0-255
int s = S >> 8;
color.setHsv(0, s, 0, 0);
QCOMPARE(color.saturation(), s);
int h, s2, v, a;
color.getHsv(&h, &s2, &v, &a);
QCOMPARE(s2, s);
}
{
// 0.0-1.0
qreal s = S / qreal(USHRT_MAX);
color.setHsvF(0.0, s, 0.0, 0.0);
QCOMPARE(color.saturationF(), s);
qreal h, s2, v, a;
color.getHsvF(&h, &s2, &v, &a);
QCOMPARE(s2, s);
}
}
for (int V = 0; V <= USHRT_MAX; ++V) {
{
// 0-255
int v = V >> 8;
color.setHsv(0, 0, v, 0);
QCOMPARE(color.value(), v);
int h, s, v2, a;
color.getHsv(&h, &s, &v2, &a);
QCOMPARE(v2, v);
}
{
// 0.0-1.0
qreal v = V / qreal(USHRT_MAX);
color.setHsvF(0.0, 0.0, v, 0.0);
QCOMPARE(color.valueF(), v);
qreal h, s, v2, a;
color.getHsvF(&h, &s, &v2, &a);
QCOMPARE(v2, v);
}
}
}
/***********************************************************************
* color map helper utilities
**********************************************************************/
static QColor pastelize(const QColor &c)
{
//Pastels have high value and low to intermediate saturation:
//http://en.wikipedia.org/wiki/Pastel_%28color%29
return QColor::fromHsv(c.hue(), int(c.saturationF()*128), int(c.valueF()*64)+191);
}
QImage GradientLoader::drawGradient(const GradientList& data)
{
if (data.isEmpty())
{
return QImage();
}
QPixmap pix(MAX_THUMB_SIZE, MAX_THUMB_SIZE / 2);
pix.fill(Qt::white);
QPainter p(&pix);
p.setPen(QPen(Qt::transparent));
p.setRenderHint(QPainter::Antialiasing, true);
QLinearGradient grad(0.0, 0.0, 1.0, 0.0);
grad.setCoordinateMode(QGradient::StretchToDeviceMode);
foreach(const GradientData & gradient, data)
{
if (gradient.status != GradientData::Ok)
{
continue;
}
qreal start = gradient.startPoint + 0.01;
qreal end = gradient.endPoint;
// do some basic range checks
start = qMin(1.0, start);
start = qMax(0.0, start);
end = qMin(1.0, end);
end = qMax(0.0, end);
// check coloring mode
if (gradient.coloringMode == GradientData::HSVclockwise ||
gradient.coloringMode == GradientData::HSVcounterClockwise
)
{
const int hue_range = 360;
bool reverse = (gradient.coloringMode == GradientData::HSVcounterClockwise);
qreal stepping = qAbs(end - start) / (qreal)hue_range;
qreal pos = reverse ? start : end;
QColor col = QColor::fromRgbF(gradient.leftColorRed,
gradient.leftColorGreen,
gradient.leftColorBlue,
gradient.leftColorAlpha);
QColor hsv = col.toHsv();
qreal saturationF = hsv.saturationF();
qreal valueF = hsv.valueF();
qreal alphaF = hsv.alphaF();
for (int h = 0.0; h < hue_range; ++h)
{
grad.setColorAt(pos, QColor::fromHsvF((qreal)h / hue_range,
saturationF,
valueF,
alphaF));
if (reverse)
{
pos += stepping;
}
else
{
pos -= stepping;
}
}
}
else
{
grad.setColorAt(start, QColor::fromRgbF(gradient.leftColorRed,
gradient.leftColorGreen,
gradient.leftColorBlue,
gradient.leftColorAlpha));
grad.setColorAt(end, QColor::fromRgbF(gradient.rightColorRed,
gradient.rightColorGreen,
gradient.rightColorBlue,
gradient.rightColorAlpha));
}
}
p.fillRect(pix.rect(), QBrush(grad));
p.end();
return pix.toImage();
}
