├── icon.ico
├── files
    ├── mockup.png
    ├── qtcolorpicker-1.png
    ├── qtcolorpicker-2.png
    └── mockup.bmml
├── Service
    ├── vars.cpp
    ├── vars.h
    ├── services.h
    ├── validator.h
    ├── services.cpp
    └── validator.cpp
├── changelog.txt
├── Views
    ├── pickerview.cpp
    ├── testdialog.h
    ├── testdialog.ui
    ├── pickerview.h
    ├── testwidget.h
    ├── testwidget.ui
    ├── testdialog.cpp
    ├── test_form.ui
    ├── sliderswindow.h
    ├── testwidget.cpp
    ├── mainwindow.h
    ├── sliderswindow.cpp
    ├── mainwindow.cpp
    └── mainwindow.ui
├── Test
    ├── dialog.h
    ├── testpaint.h
    ├── dialog.cpp
    ├── dialog.ui
    └── testpaint.cpp
├── tasks.txt
├── Widgets
    ├── ColorWidgets
    │   ├── colorsample.h
    │   ├── hselector.h
    │   ├── svselector.h
    │   ├── colorwidget.h
    │   ├── colorwidget.cpp
    │   ├── colorsample.cpp
    │   ├── hselector.cpp
    │   └── svselector.cpp
    ├── colortext.h
    ├── Sliders
    │   ├── RGB
    │   │   ├── rgbslider.h
    │   │   └── rgbslider.cpp
    │   ├── HSV
    │   │   ├── hsvslider.h
    │   │   └── hsvslider.cpp
    │   ├── CMYK
    │   │   ├── cmykslider.h
    │   │   └── cmykslider.cpp
    │   ├── colorslider.h
    │   └── colorslider.cpp
    └── colortext.cpp
├── Models
    ├── colorprocessor.h
    └── colorprocessor.cpp
├── main.cpp
├── Controllers
    ├── maincontroller.h
    ├── sliderscontroller.h
    ├── maincontroller.cpp
    └── sliderscontroller.cpp
├── QtColorPicker.pro
└── README.md


/icon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mortalis13/Qt-Color-Picker-Qt/HEAD/icon.ico


--------------------------------------------------------------------------------
/files/mockup.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mortalis13/Qt-Color-Picker-Qt/HEAD/files/mockup.png


--------------------------------------------------------------------------------
/Service/vars.cpp:
--------------------------------------------------------------------------------
1 | #include "vars.h"
2 | 
3 | Vars::Vars(QObject *parent) :
4 |   QObject(parent)
5 | {
6 | }
7 | 


--------------------------------------------------------------------------------
/files/qtcolorpicker-1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mortalis13/Qt-Color-Picker-Qt/HEAD/files/qtcolorpicker-1.png


--------------------------------------------------------------------------------
/files/qtcolorpicker-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mortalis13/Qt-Color-Picker-Qt/HEAD/files/qtcolorpicker-2.png


--------------------------------------------------------------------------------
/changelog.txt:
--------------------------------------------------------------------------------
1 | 1.0.2
2 | 
3 | -F1-F6 - copy buttons
4 | -F1-F4 - focus text fields
5 | -copied text has ','
6 | -sliders layout
7 | -paste text in various formats ('1 2 3', '1,2,3', '1, 2, 3')
8 | -inc/dec color components by scrolling
9 | 


--------------------------------------------------------------------------------
/Views/pickerview.cpp:
--------------------------------------------------------------------------------
 1 | #include "pickerview.h"
 2 | 
 3 | #include <QDebug>
 4 | #include <QShortcut>
 5 | 
 6 | 
 7 | PickerView::PickerView(QWidget *parent) :
 8 |   QWidget(parent)
 9 | {
10 |   init();
11 | }
12 | 
13 | PickerView::~PickerView() {
14 | }
15 | 
16 | void PickerView::init() {
17 |   
18 | }
19 | 


--------------------------------------------------------------------------------
/Test/dialog.h:
--------------------------------------------------------------------------------
 1 | #ifndef DIALOG_H
 2 | #define DIALOG_H
 3 | 
 4 | #include <QDialog>
 5 | 
 6 | namespace Ui {
 7 | class Dialog;
 8 | }
 9 | 
10 | class Dialog : public QDialog
11 | {
12 |   Q_OBJECT
13 | 
14 | public:
15 |   explicit Dialog(QWidget *parent = 0);
16 |   ~Dialog();
17 | 
18 | private:
19 |   Ui::Dialog *ui;
20 | };
21 | 
22 | #endif // DIALOG_H
23 | 


--------------------------------------------------------------------------------
/Service/vars.h:
--------------------------------------------------------------------------------
 1 | #ifndef VARS_H
 2 | #define VARS_H
 3 | 
 4 | #include <QObject>
 5 | 
 6 | class Vars : public QObject
 7 | {
 8 |   Q_OBJECT
 9 | 
10 | public:
11 |   enum ColorType{
12 |     HSV, RGB, CMYK, Hex
13 |   };
14 | 
15 | public:
16 |   explicit Vars(QObject *parent = 0);
17 | 
18 | signals:
19 | 
20 | public slots:
21 | 
22 | };
23 | 
24 | #endif // VARS_H
25 | 


--------------------------------------------------------------------------------
/Test/testpaint.h:
--------------------------------------------------------------------------------
 1 | #ifndef TESTPAINT_H
 2 | #define TESTPAINT_H
 3 | 
 4 | #include <QWidget>
 5 | 
 6 | class TestPaint : public QWidget
 7 | {
 8 |   Q_OBJECT
 9 |   void smallLines(QPainter &p);
10 |   void largeLines(QPainter &p);
11 | public:
12 |   explicit TestPaint(QWidget *parent = 0);
13 | 
14 | signals:
15 | 
16 | public slots:
17 | 
18 | protected:
19 |   void paintEvent(QPaintEvent *event);
20 | };
21 | 
22 | #endif // TESTPAINT_H
23 | 


--------------------------------------------------------------------------------
/Test/dialog.cpp:
--------------------------------------------------------------------------------
 1 | #include "dialog.h"
 2 | #include "ui_dialog.h"
 3 | 
 4 | #include <QStyleFactory>
 5 | #include "norwegianwoodstyle.h"
 6 | 
 7 | Dialog::Dialog(QWidget *parent) :
 8 |   QDialog(parent),
 9 |   ui(new Ui::Dialog)
10 | {
11 |   ui->setupUi(this);
12 | 
13 | //  QApplication::setStyle(QStyleFactory::create("fusion"));
14 | //    ui->horizontalSlider->setStyle(new NorwegianWoodStyle);
15 | }
16 | 
17 | Dialog::~Dialog()
18 | {
19 |   delete ui;
20 | }
21 | 


--------------------------------------------------------------------------------
/Views/testdialog.h:
--------------------------------------------------------------------------------
 1 | #ifndef TESTDIALOG_H
 2 | #define TESTDIALOG_H
 3 | 
 4 | #include <QDialog>
 5 | 
 6 | namespace Ui {
 7 | class TestDialog;
 8 | }
 9 | 
10 | class TestDialog : public QDialog
11 | {
12 |   Q_OBJECT
13 | 
14 | public:
15 |   explicit TestDialog(QWidget *parent = 0);
16 |   ~TestDialog();
17 | 
18 | private:
19 |   Ui::TestDialog *ui;
20 |   
21 |   
22 | protected:
23 |   void paintEvent(QPaintEvent* e); 
24 | 
25 | };
26 | 
27 | #endif // TESTDIALOG_H
28 | 


--------------------------------------------------------------------------------
/Views/testdialog.ui:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <ui version="4.0">
 3 |  <class>TestDialog</class>
 4 |  <widget class="QDialog" name="TestDialog">
 5 |   <property name="geometry">
 6 |    <rect>
 7 |     <x>0</x>
 8 |     <y>0</y>
 9 |     <width>50</width>
10 |     <height>50</height>
11 |    </rect>
12 |   </property>
13 |   <property name="windowTitle">
14 |    <string>Dialog</string>
15 |   </property>
16 |  </widget>
17 |  <resources/>
18 |  <connections/>
19 | </ui>
20 | 


--------------------------------------------------------------------------------
/Views/pickerview.h:
--------------------------------------------------------------------------------
 1 | #ifndef PICKERVIEW_H
 2 | #define PICKERVIEW_H
 3 | 
 4 | #include <QWidget>
 5 | #include <QMainWindow>
 6 | #include <QMouseEvent>
 7 | 
 8 | 
 9 | class PickerView : public QWidget
10 | {
11 |   Q_OBJECT
12 | 
13 | public:
14 |   
15 | private:
16 |   
17 | public:
18 |   explicit PickerView(QWidget *parent = 0);
19 |   ~PickerView();
20 | 
21 |   
22 | protected:
23 |   
24 | 
25 | private:
26 |   
27 |   void init();
28 |   
29 |   
30 | signals:
31 | 
32 | private slots:
33 |   
34 | };
35 | 
36 | #endif // PICKERVIEW_H
37 | 


--------------------------------------------------------------------------------
/Service/services.h:
--------------------------------------------------------------------------------
 1 | #ifndef SERVICES_H
 2 | #define SERVICES_H
 3 | 
 4 | #include <QObject>
 5 | #include <QPainter>
 6 | 
 7 | class Services : public QObject
 8 | {
 9 |   Q_OBJECT
10 | public:
11 |   explicit Services(QObject *parent = 0);
12 | 
13 |   static void drawRoundRect(QPainter& p, QRectF sizeRect, int borderSize, int borderRadius, QColor borderColor);
14 |   static void drawInnerRoundRect(QPainter& p, QRectF sizeRect, int borderSize, int borderRadius, QColor borderColor);
15 | 
16 | signals:
17 | 
18 | public slots:
19 | 
20 | };
21 | 
22 | #endif // SERVICES_H
23 | 


--------------------------------------------------------------------------------
/Views/testwidget.h:
--------------------------------------------------------------------------------
 1 | #ifndef TESTWIDGET_H
 2 | #define TESTWIDGET_H
 3 | 
 4 | #include <QWidget>
 5 | 
 6 | namespace Ui {
 7 | class TestWidget;
 8 | }
 9 | 
10 | class TestWidget : public QWidget
11 | {
12 |   Q_OBJECT
13 | 
14 | public:
15 |   explicit TestWidget(QWidget *parent = 0);
16 |   ~TestWidget();
17 | 
18 | private:
19 |   Ui::TestWidget *ui;
20 |   
21 |   int mx, my;
22 |   
23 | 
24 | protected:
25 |   void paintEvent(QPaintEvent* e);
26 |   void mousePressEvent(QMouseEvent* e);
27 |   void mouseMoveEvent(QMouseEvent* e);
28 |   // void mouseReleaseEvent(QMouseEvent *e);
29 | 
30 | };
31 | 
32 | #endif // TESTWIDGET_H
33 | 


--------------------------------------------------------------------------------
/Views/testwidget.ui:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <ui version="4.0">
 3 |  <class>TestWidget</class>
 4 |  <widget class="QWidget" name="TestWidget">
 5 |   <property name="windowModality">
 6 |    <enum>Qt::NonModal</enum>
 7 |   </property>
 8 |   <property name="geometry">
 9 |    <rect>
10 |     <x>0</x>
11 |     <y>0</y>
12 |     <width>204</width>
13 |     <height>204</height>
14 |    </rect>
15 |   </property>
16 |   <property name="windowTitle">
17 |    <string>Form</string>
18 |   </property>
19 |   <property name="autoFillBackground">
20 |    <bool>false</bool>
21 |   </property>
22 |  </widget>
23 |  <resources/>
24 |  <connections/>
25 | </ui>
26 | 


--------------------------------------------------------------------------------
/Test/dialog.ui:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <ui version="4.0">
 3 |  <class>Dialog</class>
 4 |  <widget class="QDialog" name="Dialog">
 5 |   <property name="geometry">
 6 |    <rect>
 7 |     <x>0</x>
 8 |     <y>0</y>
 9 |     <width>521</width>
10 |     <height>320</height>
11 |    </rect>
12 |   </property>
13 |   <property name="windowTitle">
14 |    <string>Dialog</string>
15 |   </property>
16 |   <widget class="QSpinBox" name="spinBox">
17 |    <property name="geometry">
18 |     <rect>
19 |      <x>40</x>
20 |      <y>40</y>
21 |      <width>42</width>
22 |      <height>22</height>
23 |     </rect>
24 |    </property>
25 |   </widget>
26 |  </widget>
27 |  <resources/>
28 |  <connections/>
29 | </ui>
30 | 


--------------------------------------------------------------------------------
/Views/testdialog.cpp:
--------------------------------------------------------------------------------
 1 | #include "testdialog.h"
 2 | #include "ui_testdialog.h"
 3 | 
 4 | #include <QPainter>
 5 | #include <QMouseEvent>
 6 | 
 7 | TestDialog::TestDialog(QWidget *parent) :
 8 |   QDialog(parent),
 9 |   ui(new Ui::TestDialog)
10 | {
11 |   ui->setupUi(this);
12 | }
13 | 
14 | TestDialog::~TestDialog()
15 | {
16 |   delete ui;
17 | }
18 | 
19 | 
20 | void TestDialog::paintEvent(QPaintEvent *event)
21 | {
22 |   int w = width();
23 |   int h = height();
24 |   
25 |   QPainter p(this);
26 |   p.setRenderHint(QPainter::Antialiasing);
27 |   
28 |   QPen pen;
29 |   pen.setWidth(2);
30 |   pen.setColor(QColor(40,40,40,255));
31 |   
32 |   p.setPen(pen);
33 |   p.setBrush(QBrush(QColor(0,0,0)));
34 |   
35 |   p.drawRect(0, 0, w, h);
36 | }
37 | 
38 | 


--------------------------------------------------------------------------------
/Views/test_form.ui:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <ui version="4.0">
 3 |  <class>MainWindow</class>
 4 |  <widget class="QMainWindow" name="MainWindow">
 5 |   <property name="geometry">
 6 |    <rect>
 7 |     <x>0</x>
 8 |     <y>0</y>
 9 |     <width>548</width>
10 |     <height>286</height>
11 |    </rect>
12 |   </property>
13 |   <property name="windowTitle">
14 |    <string>MainWindow</string>
15 |   </property>
16 |   <widget class="QWidget" name="centralwidget"/>
17 |   <widget class="QMenuBar" name="menubar">
18 |    <property name="geometry">
19 |     <rect>
20 |      <x>0</x>
21 |      <y>0</y>
22 |      <width>548</width>
23 |      <height>21</height>
24 |     </rect>
25 |    </property>
26 |   </widget>
27 |   <widget class="QStatusBar" name="statusbar"/>
28 |  </widget>
29 |  <resources/>
30 |  <connections/>
31 | </ui>
32 | 


--------------------------------------------------------------------------------
/tasks.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | - press mid button on text to select all or to select group
 3 | - [hex] inc/dec each hex digit (not group)
 4 | - saturation/value pointers on the sides of selector
 5 | - show half of hue trapezoid when in the top/bottom max position (when it is partially hidden)
 6 | - trim, remove \s+ after validation (when all comps are valid)
 7 | *- text fields scroll
 8 | *- text with commas (process, copy)
 9 | - add swatches/color combo box (list)
10 | - hint (value) on slider/selector hover
11 | *- ctrl+tab to tab on text fields
12 | 
13 | # - hold mid button to move on sv selector
14 | # - copy hex on Sample click
15 | # - mouse scroll on selectors
16 | # - validate on up/down, tab/btab
17 | # - short hex
18 | # - drag by any point
19 | # - paste validation
20 | # - hex ffffff => hue -1
21 | # - ctrl+scroll to inc/dec by 10 
22 | 
23 | # - esc
24 | # - field shortcuts
25 | # - button shortcuts
26 | # - change background
27 | # - draw gradient on hue selector instead of lines
28 | # - startup window position


--------------------------------------------------------------------------------
/Widgets/ColorWidgets/colorsample.h:
--------------------------------------------------------------------------------
 1 | #ifndef COLORSAMPLE_H
 2 | #define COLORSAMPLE_H
 3 | 
 4 | #include <QWidget>
 5 | #include <QMouseEvent>
 6 | 
 7 | #include "colorwidget.h"
 8 | 
 9 | 
10 | class ColorSample : public ColorWidget
11 | {
12 |   Q_OBJECT
13 |   
14 | private:
15 |   bool mouseMoving;
16 |   QColor borderColor;
17 |   
18 | public:
19 |   explicit ColorSample(QWidget *parent = 0);
20 |   
21 |   void reupdateColor();
22 |   
23 | 
24 | signals:
25 |   void colorChanged(QColor color);
26 |   void samplePressedLeft();
27 |   void samplePressedRight();
28 |   void samplePressedMiddle();
29 | 
30 | public slots:
31 |   void changeColor(QColor color);
32 |   void mouseMovedOnWindow();
33 |   void mouseReleasedOnWindow();
34 | 
35 | protected:
36 |   void paintEvent(QPaintEvent *event);
37 |   void mouseReleaseEvent(QMouseEvent* e);
38 |   void enterEvent(QEvent* e);
39 |   void leaveEvent(QEvent *e);
40 | 
41 | private:
42 |   void drawBorder(QPainter& p);
43 | 
44 | };
45 | 
46 | #endif // COLORSAMPLE_H
47 | 


--------------------------------------------------------------------------------
/Test/testpaint.cpp:
--------------------------------------------------------------------------------
 1 | #include "testpaint.h"
 2 | 
 3 | #include <QPainter>
 4 | #include <QDebug>
 5 | 
 6 | TestPaint::TestPaint(QWidget *parent) :
 7 |   QWidget(parent)
 8 | {
 9 | }
10 | 
11 | void TestPaint::smallLines(QPainter& p) {
12 |   p.setPen(Qt::black);
13 |   int lines = 0;
14 | 
15 |   for (int i = 0; i <= height(); i+=4) {
16 |     p.drawLine(0, i, width(), i);
17 |     lines++;
18 |   }
19 | 
20 |   qDebug() << "smallLines: " << lines;
21 | }
22 | 
23 | void TestPaint::largeLines(QPainter& p) {
24 |   QPen pen(QColor(0,0,0), 2);
25 |   p.setPen(pen);
26 |   int hlines = 0, vlines = 0;
27 | 
28 |   for (int i = 0; i <= height(); i+=40) {
29 |     p.drawLine(0, i, width(), i);
30 |     hlines++;
31 |   }
32 | 
33 |   for (int i = 0; i <= width(); i+=40) {
34 |     p.drawLine(i, 0, i, height());
35 |     vlines++;
36 |   }
37 | 
38 |   qDebug() << QString("largeLines: %1 h, %2 v").arg(hlines).arg(vlines);
39 | }
40 | 
41 | void TestPaint::paintEvent(QPaintEvent *event)
42 | {
43 |   QPainter p(this);
44 | 
45 | //  smallLines(p);
46 |   largeLines(p);
47 | }
48 | 
49 | 


--------------------------------------------------------------------------------
/Widgets/ColorWidgets/hselector.h:
--------------------------------------------------------------------------------
 1 | #ifndef HUEBAR_H
 2 | #define HUEBAR_H
 3 | 
 4 | #include <QWidget>
 5 | #include <QMouseEvent>
 6 | 
 7 | #include "colorwidget.h"
 8 | 
 9 | 
10 | class HSelector : public ColorWidget
11 | {
12 |   Q_OBJECT
13 |   
14 | private:
15 |   int barHeight;
16 |   // QColor color;
17 |   // int h,s,v;
18 |   
19 |   
20 | public:
21 |   explicit HSelector(QWidget *parent = 0);
22 | 
23 |   void setH(int h);
24 |   void setH(QColor color);
25 |   void setInitH(int h);
26 |   
27 |   void reupdateColor();
28 |   
29 | protected:
30 |   void paintEvent(QPaintEvent* e);
31 |   void mousePressEvent(QMouseEvent* e);
32 |   void mouseMoveEvent(QMouseEvent* e);
33 |   void mouseReleaseEvent(QMouseEvent *e);
34 |   void wheelEvent(QWheelEvent* e);
35 | 
36 | private:
37 |   void updateColor();
38 |   
39 |   void drawPointer(QPainter &p);
40 |   void correctPointer();
41 |   void movePointer(int y);
42 |   void incPointer(int val);
43 |   void decPointer(int val);
44 |   
45 |   void drawBorder(QPainter& p);
46 |   
47 | 
48 | signals:
49 |   void hueChanged(QColor);
50 | 
51 | 
52 | };
53 | 
54 | #endif // HUEBAR_H
55 | 


--------------------------------------------------------------------------------
/Service/validator.h:
--------------------------------------------------------------------------------
 1 | #ifndef VALIDATOR_H
 2 | #define VALIDATOR_H
 3 | 
 4 | #include <QObject>
 5 | #include <QColor>
 6 | 
 7 | #include "vars.h"
 8 | 
 9 | 
10 | class Validator : public QObject
11 | {
12 |   Q_OBJECT
13 |   
14 | public:
15 |   explicit Validator(QObject *parent = 0);
16 |   
17 |   static bool checkColorText(QString text, Vars::ColorType colorType=Vars::HSV);
18 |   
19 |   static bool checkValueHSV(QString text);
20 |   static bool checkValueRGB(QString text);
21 |   static bool checkValueCMYK(QString text);
22 |   static bool checkValueHex(QString text);
23 |   
24 |   static void correctHSV(QColor& color);
25 |   static void correctRGB(QColor& color);
26 |   static void correctCMYK(QColor& color);
27 |   
28 |   static QString correctColorText(QString text);
29 |   
30 |   static bool checkComponentVal(int val, Vars::ColorType colorType=Vars::HSV, int group=0, int hexLen=0);
31 |   static bool checkValueByType(QString text, Vars::ColorType colorType=Vars::HSV);
32 |   
33 |   
34 | private:
35 |   static int getSizeByType(Vars::ColorType colorType);
36 |   
37 | signals:
38 | 
39 | public slots:
40 | 
41 | };
42 | 
43 | #endif // VALIDATOR_H
44 | 


--------------------------------------------------------------------------------
/Widgets/colortext.h:
--------------------------------------------------------------------------------
 1 | #ifndef COLORTEXT_H
 2 | #define COLORTEXT_H
 3 | 
 4 | #include <QLineEdit>
 5 | #include <QKeyEvent>
 6 | 
 7 | #include "Service/vars.h"
 8 | 
 9 | class ColorText : public QLineEdit
10 | {
11 |   Q_OBJECT
12 | 
13 | private:
14 |   Vars::ColorType colorType;
15 |   QString separator;
16 |   int len;
17 | 
18 | public:
19 |   explicit ColorText(QWidget *parent = 0);
20 | 
21 |   void setType(Vars::ColorType colorType);
22 |   void updateText(QString text);
23 |   
24 | signals:
25 |   void focusNextField();
26 |   void focusPrevField();
27 |   
28 | 
29 | public slots:
30 | 
31 | protected:
32 |   void keyPressEvent(QKeyEvent *e);
33 |   void wheelEvent(QWheelEvent *e);
34 |   bool event(QEvent *e);
35 | 
36 | private:
37 |   void changeComponentVal(int pos, bool inc);
38 | 
39 |   int getGroup();
40 | 
41 |   void selectNextComponent();
42 |   void selectPrevComponent();
43 |   void selectComponent(bool next);
44 |   QStringList getComponentsFromHex(QString hex);
45 |   int getGroupNumber(int group, int groupLen, bool next);
46 |   int getHexGroup(int pos, int len);
47 |   bool checkValueHex(QString text);
48 |   
49 | };
50 | 
51 | #endif // COLORTEXT_H
52 | 


--------------------------------------------------------------------------------
/Widgets/Sliders/RGB/rgbslider.h:
--------------------------------------------------------------------------------
 1 | #ifndef RGBSLIDER_H
 2 | #define RGBSLIDER_H
 3 | 
 4 | #include "Widgets/Sliders/colorslider.h"
 5 | 
 6 | class RGBSlider : public ColorSlider
 7 | {
 8 |   Q_OBJECT
 9 |   
10 | public:
11 |   enum SliderType{Red, Green, Blue};
12 |     
13 | private:
14 |   qreal r,g,b;
15 |   SliderType sliderType;
16 |   
17 |   
18 | public:
19 |   RGBSlider(QWidget *parent = 0);
20 | 
21 |   void setType(SliderType type);
22 |   void init();
23 | 
24 |   void setR(QColor color);
25 |   void setG(QColor color);
26 |   void setB(QColor color);
27 |   
28 |   void changeRed(QColor color);
29 |   void changeGreen(QColor color);
30 |   void changeBlue(QColor color);
31 |   
32 | 
33 | protected:
34 |   void paintEvent(QPaintEvent* e);
35 |   void updateColor();
36 |   
37 | private:
38 |   void paintComponent();
39 |   void updateSlider();
40 |   void setColorComponent(QColor color, SliderType stype);
41 |   
42 |   void paintRed(QLinearGradient &grad);
43 |   void paintGreen(QLinearGradient &grad);
44 |   void paintBlue(QLinearGradient &grad);
45 |   
46 |   
47 | signals:
48 |   void redChanged(QColor);
49 |   void greenChanged(QColor);
50 |   void blueChanged(QColor);
51 |   
52 | };
53 | 
54 | #endif // RGBSLIDER_H
55 | 


--------------------------------------------------------------------------------
/Widgets/Sliders/HSV/hsvslider.h:
--------------------------------------------------------------------------------
 1 | #ifndef HSVSLIDER_H
 2 | #define HSVSLIDER_H
 3 | 
 4 | #include "Widgets/Sliders/colorslider.h"
 5 | 
 6 | class HSVSlider : public ColorSlider
 7 | {
 8 |   Q_OBJECT
 9 |   
10 | public:
11 |   enum SliderType{Hue, Saturation, Value};
12 |     
13 | private:
14 |   qreal h,s,v;
15 |   SliderType sliderType;
16 |   
17 |   
18 | public:
19 |   HSVSlider(QWidget *parent = 0);
20 | 
21 |   void setType(SliderType type);
22 |   void init();
23 | 
24 |   void setH(QColor color);
25 |   void setS(QColor color);
26 |   void setV(QColor color);
27 |   
28 |   void changeHue(QColor color);
29 |   void changeValue(QColor color);
30 |   void changeSaturation(QColor color);
31 |   
32 | 
33 | protected:
34 |   void paintEvent(QPaintEvent* e);
35 |   void updateColor();
36 |   
37 | private:
38 |   void paintComponent();
39 |   void updateSlider();
40 |   void setColorComponent(QColor color, SliderType stype);
41 |   
42 |   void paintHue(QLinearGradient &grad);
43 |   void paintSaturation(QLinearGradient &grad);
44 |   void paintValue(QLinearGradient &grad);
45 |   
46 |   
47 | signals:
48 |   void hueChanged(QColor);
49 |   void saturationChanged(QColor);
50 |   void valueChanged(QColor);
51 |     
52 |   
53 | };
54 | 
55 | #endif // HSVSLIDER_H
56 | 


--------------------------------------------------------------------------------
/Views/sliderswindow.h:
--------------------------------------------------------------------------------
 1 | #ifndef SLIDERSWINDOW_H
 2 | #define SLIDERSWINDOW_H
 3 | 
 4 | #include <QMainWindow>
 5 | #include <QMouseEvent>
 6 | 
 7 | #include "Controllers/sliderscontroller.h"
 8 | 
 9 | 
10 | namespace Ui {
11 | class SlidersWindow;
12 | }
13 | 
14 | class SlidersController;
15 | 
16 | class SlidersWindow : public QMainWindow
17 | {
18 |   Q_OBJECT
19 | 
20 | public:
21 |   Ui::SlidersWindow *ui;
22 |   
23 | private:
24 |   bool mouseDown;
25 |   bool mouseMoved;
26 |   int mx, my;  
27 |   
28 |   SlidersController *slidersController;  
29 |   
30 | public:
31 |   explicit SlidersWindow(SlidersController *slidersController, QWidget *parent = 0);
32 |   ~SlidersWindow();
33 | 
34 |   
35 | protected:
36 |   void mouseMoveEvent(QMouseEvent* e);
37 |   void mousePressEvent(QMouseEvent* e);
38 |   void mouseReleaseEvent(QMouseEvent* e);
39 | 
40 |   void keyPressEvent(QKeyEvent *e);
41 |   void keyReleaseEvent(QKeyEvent *e);
42 |   
43 | 
44 | private:
45 |   void addActions();
46 |   void addKeyActions();
47 |   void addShortcuts();
48 |   void init();
49 |   
50 |   
51 | signals:
52 | 
53 |   void ctrlPressed();
54 |   void ctrlReleased();
55 |   
56 |   
57 | private slots:
58 |   void sliderMiddlePressed(QMouseEvent* e);
59 |   
60 |   
61 | };
62 | 
63 | #endif // SLIDERS_H
64 | 


--------------------------------------------------------------------------------
/Models/colorprocessor.h:
--------------------------------------------------------------------------------
 1 | #ifndef COLORPROCESSOR_H
 2 | #define COLORPROCESSOR_H
 3 | 
 4 | #include <QtCore>
 5 | #include <QColor>
 6 | 
 7 | #include <QObject>
 8 | #include <QClipboard>
 9 | 
10 | #include "Widgets/ColorWidgets/hselector.h"
11 | #include "Widgets/ColorWidgets/svselector.h"
12 | 
13 | #include "Service/vars.h"
14 | 
15 | 
16 | class ColorProcessor : public QObject
17 | {
18 |   Q_OBJECT
19 | 
20 | public:
21 |   explicit ColorProcessor(HSelector* hSelector, SVSelector* svSelector, QObject* parent=0);
22 | 
23 |   QString getHSV(QColor color);
24 |   QString getRGB(QColor color);
25 |   QString getCMYK(QColor color);
26 |   QString getHex(QColor color);
27 |   
28 |   QColor getColorHSV(QString HSV_Text);
29 |   QColor getColorRGB(QString RGB_Text);
30 |   QColor getColorCMYK(QString CMYK_Text);
31 |   QColor getColorHex(QString Hex_Text);
32 | 
33 |   void updateColorHSV(QString HSV);
34 |   void updateColorRGB(QString RGB);
35 |   void updateColorCMYK(QString CMYK);
36 |   void updateColorHex(QString Hex);
37 |   
38 |   void updateColor(QColor color);
39 |   
40 |   void copyText(QString text);
41 |   QString pasteText();
42 | 
43 | signals:
44 |   void updateFinished();
45 | 
46 | private:
47 |   HSelector* hSelector;
48 |   SVSelector* svSelector;
49 |   QClipboard* clip;
50 |   
51 | };
52 | 
53 | #endif // COLORPROCESSOR_H
54 | 


--------------------------------------------------------------------------------
/Widgets/ColorWidgets/svselector.h:
--------------------------------------------------------------------------------
 1 | #ifndef SATVALUESELECTOR_H
 2 | #define SATVALUESELECTOR_H
 3 | 
 4 | #include <QWidget>
 5 | #include <QList>
 6 | #include <QPixmap>
 7 | 
 8 | #include "colorwidget.h"
 9 | 
10 | 
11 | class SVSelector : public ColorWidget
12 | {
13 |   Q_OBJECT
14 |   
15 | private:
16 |   // QColor color;
17 |   // int h,s,v;
18 |   
19 |   
20 | public:
21 |   explicit SVSelector(QWidget *parent = 0);
22 | 
23 |   void setS(QColor color);
24 |   void setV(QColor color);
25 |   void setSV(int s, int v);
26 |   
27 |   void reupdateColor();
28 | 
29 | 
30 | protected:
31 |   void paintEvent(QPaintEvent *e);
32 |   void mousePressEvent(QMouseEvent* e);
33 |   void mouseMoveEvent(QMouseEvent* e);
34 |   void mouseReleaseEvent(QMouseEvent* e);
35 |   void wheelEvent(QWheelEvent *e);
36 | 
37 | 
38 | private:
39 |   void updateColor();
40 |   
41 |   void drawPointer(QPainter &p);
42 |   void correctPointer();
43 |   void movePointer(int x, int y);
44 | 
45 |   void incPointerX(int val);
46 |   void decPointerX(int val);
47 |   void decPointerY(int val);
48 |   void incPointerY(int val);
49 | 
50 |   void drawBorder(QPainter& p);
51 | 
52 |   
53 | signals:
54 |   void colorChanged(QColor);
55 |   void saturationChanged(QColor);
56 |   void valueChanged(QColor);
57 | 
58 | public slots:
59 |   void changeHue(QColor color);  
60 | 
61 | 
62 | };
63 | 
64 | #endif // SATVALUESELECTOR_H
65 | 


--------------------------------------------------------------------------------
/Widgets/Sliders/CMYK/cmykslider.h:
--------------------------------------------------------------------------------
 1 | #ifndef CMYKSLIDER_H
 2 | #define CMYKSLIDER_H
 3 | 
 4 | #include "Widgets/Sliders/colorslider.h"
 5 | 
 6 | class CMYKSlider : public ColorSlider
 7 | {
 8 |   Q_OBJECT
 9 |   
10 | public:
11 |   enum SliderType{Cyan, Magenta, Yellow, Black};
12 |     
13 | private:
14 |   qreal c,m,y,k;
15 |   SliderType sliderType;
16 |   
17 |   
18 | public:
19 |   CMYKSlider(QWidget *parent = 0);
20 | 
21 |   void setType(SliderType type);
22 |   void init();
23 | 
24 |   void setC(QColor color);
25 |   void setM(QColor color);
26 |   void setY(QColor color);
27 |   void setK(QColor color);
28 |   
29 |   void changeCyan(QColor color);
30 |   void changeMagenta(QColor color);
31 |   void changeYellow(QColor color);
32 |   void changeBlack(QColor color);
33 |   
34 | 
35 | protected:
36 |   void paintEvent(QPaintEvent* e);
37 |   void updateColor();
38 |   
39 | private:
40 |   void paintComponent();
41 |   void updateSlider();
42 |   void setColorComponent(QColor color, SliderType stype);
43 |   
44 |   void paintCyan(QLinearGradient &grad);
45 |   void paintMagenta(QLinearGradient &grad);
46 |   void paintYellow(QLinearGradient &grad);
47 |   void paintBlack(QLinearGradient &grad);
48 |   
49 |   
50 | signals:
51 |   void cyanChanged(QColor);
52 |   void magentaChanged(QColor);
53 |   void yellowChanged(QColor);
54 |   void blackChanged(QColor);
55 |   
56 | };
57 | 
58 | #endif // CMYKSLIDER_H
59 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <QApplication>
 2 | #include <QDesktopWidget>
 3 | 
 4 | #include "Views/mainwindow.h"
 5 | 
 6 | // v1.0.2
 7 | 
 8 | void setPosition(MainWindow &view) {
 9 |   QDesktopWidget *w = QApplication::desktop();
10 |   int primary = w->primaryScreen();
11 |   QRect dim = w->screenGeometry(primary);
12 | 
13 |   int mx,my, corr = 20;
14 | 
15 |   mx = view.x();
16 |   mx = dim.width() - view.width() - corr;
17 |   my = corr;
18 | 
19 |   view.move(mx, my);
20 | }
21 | 
22 | int main(int argc, char *argv[])
23 | {
24 |   QApplication a(argc, argv);
25 |   MainWindow view;
26 | 
27 |   view.show();
28 |   setPosition(view);
29 | 
30 |   return a.exec();
31 | }
32 | 
33 | 
34 | // void saveHuesToFile() {
35 | //   QFile file("hues.dat");
36 | //   if ( !file.open(QIODevice::WriteOnly) ) {
37 | //     qDebug("Cannot open file");
38 | //     return;
39 | //   }
40 | 
41 | //   QList<QImage> hues;
42 | //   QColor color;
43 | 
44 | //   int maxHue = 360;
45 | //   int max = 255;
46 | 
47 | //   for (int h = 0;h<maxHue;h++) {
48 | //     QImage image(max+1, max+1, QImage::Format_RGB32);
49 | 
50 | //     for (int s = 0; s<=max; s++) {
51 | //       for (int v = 0; v<=max; v++) {
52 | //         color.setHsv(h, s, v);
53 | //         image.setPixel(s, max-v, color.rgb());
54 | //       }
55 | //     }
56 | 
57 | //     hues.append(image);
58 | //   }
59 | 
60 | //   QDataStream stream(&file);
61 | //   stream << hues;
62 | //   file.close();
63 | // }
64 | 


--------------------------------------------------------------------------------
/Widgets/Sliders/colorslider.h:
--------------------------------------------------------------------------------
 1 | #ifndef COLORSLIDER_H
 2 | #define COLORSLIDER_H
 3 | 
 4 | #include <QWidget>
 5 | 
 6 | class ColorSlider : public QWidget
 7 | {
 8 |   Q_OBJECT
 9 | public:
10 |   explicit ColorSlider(QWidget *parent = 0);
11 | 
12 |   void updatePaint();
13 | 
14 | protected:
15 |   void mousePressEvent(QMouseEvent* e);
16 |   void mouseMoveEvent(QMouseEvent* e);
17 | 
18 |   void mouseReleaseEvent(QMouseEvent *e);
19 |   void wheelEvent(QWheelEvent* e);
20 |   
21 | protected:
22 |   virtual void updateColor();
23 | 
24 |   qreal normalizeVal(int val);
25 |   int normalizePointerX(qreal val);
26 | 
27 |   void drawPointer(QPainter &p);
28 |   void correctPointer();
29 |   void movePointer(int x);
30 |   void incPointer(int val=1);
31 |   void decPointer(int val=1);
32 |   
33 |   void calcVars(qreal val);
34 |   void drawBorder(QPainter& p);
35 | 
36 |   void log(QString format, int var);
37 |   void log(QString format, qreal var);
38 | 
39 | 
40 | protected:
41 |   const qreal maxF=1.0;
42 |   
43 |   bool sliderDrawn;
44 |   QPixmap sliderPixmap;
45 |   
46 |   bool middlePresed;
47 |   bool ctrlHeld;
48 |   bool widthChanged;
49 | 
50 |   QColor color;
51 |   
52 |   int pointerX;
53 |   int pointerY;
54 |   
55 |   int minPointerX;
56 |   int maxPointerX;
57 |   
58 |   int sliderX;
59 |   int sliderY;
60 |   int sliderW;
61 |   int sliderH;
62 |   int prevSliderW;
63 | 
64 |   int sliderVal;
65 |   int maxRange;
66 | 
67 | 
68 | signals:
69 |   void middlePressedSignal(QMouseEvent* e);
70 | 
71 | public slots:  
72 |   void ctrlPressed();
73 |   void ctrlReleased();
74 | 
75 | };
76 | 
77 | #endif // COLORSLIDER_H
78 | 


--------------------------------------------------------------------------------
/Widgets/ColorWidgets/colorwidget.h:
--------------------------------------------------------------------------------
 1 | #ifndef COLORWIDGET_H
 2 | #define COLORWIDGET_H
 3 | 
 4 | #include <QWidget>
 5 | 
 6 | 
 7 | class ColorWidget : public QWidget
 8 | {
 9 |   Q_OBJECT
10 |   
11 |   
12 | protected:
13 |   const int maxH=360;
14 |   const int maxSV=255;
15 |   const qreal maxF=1.0;
16 |   
17 |   const qreal ratio=1.0/maxH;
18 |   
19 | 
20 |   const int border=2;
21 |   const int borderRadius=10;
22 | 
23 |   const int selectorX=border;
24 |   const int selectorY=border;
25 | 
26 |   const QColor borderColor=QColor(80,80,80,200);
27 |   const QColor pointerColor=QColor("#333");
28 |   
29 |   
30 | // --- H ---
31 |   const int barWidth=40;
32 | 
33 |   const int minPointerY = border;
34 |   const int maxPointerY = maxH + minPointerY;
35 | 
36 |   const int pointerWidth=10;
37 |   const int pointerDy1=1.5;
38 |   const int pointerDy2=5;
39 |   
40 |   
41 | // --- SV ---
42 |   const int selectorSize=maxSV+1;
43 |   const int minPointerXY = border;
44 |   const int maxPointerXY = maxSV+border;
45 | 
46 |   const int pointerR=5;
47 |   const int pointerBorder=2;
48 | 
49 |   const QColor pointerBorderColor=QColor("#ddd");  
50 |   
51 |   
52 | protected:  
53 |   bool middlePresed;
54 |   bool selectorDrawn;
55 |   bool shiftHeld;
56 |   bool ctrlHeld;
57 |   
58 |   QPixmap hSelectorPixmap;
59 |   QImage hueLayerImage;
60 |   QColor color;
61 |   
62 |   int h,s,v;
63 |   qreal hf,sf,vf;
64 |   
65 |   int pointerX;
66 |   int pointerY;
67 |     
68 |   
69 | public:
70 |   explicit ColorWidget(QWidget *parent = 0);
71 | 
72 | 
73 | protected:
74 |   void drawCircle(QPainter &p);
75 |   void drawRightTrapezoid(QPainter& p);
76 |   
77 |   void hideCursor(QMouseEvent *e);
78 |   void restoreCursor();
79 | 
80 |   void log(QString format, int var);
81 |   void log(QString format, qreal var);
82 |   
83 |   
84 | signals:
85 |   void middlePressedSignal(QMouseEvent* e);
86 |   
87 | 
88 | public slots:
89 |   void shiftPressed();
90 |   void shiftReleased();
91 |   void ctrlPressed();
92 |   void ctrlReleased();
93 |   
94 |   
95 | };
96 | 
97 | #endif // COLORWIDGET_H
98 | 


--------------------------------------------------------------------------------
/Controllers/maincontroller.h:
--------------------------------------------------------------------------------
 1 | #ifndef MAINCONTROLLER_H
 2 | #define MAINCONTROLLER_H
 3 | 
 4 | #include <QColor>
 5 | #include <QObject>
 6 | 
 7 | #include "Views/mainwindow.h"
 8 | #include "Controllers/sliderscontroller.h"
 9 | #include "Models/colorprocessor.h"
10 | 
11 | #include "Widgets/ColorWidgets/hselector.h"
12 | #include "Widgets/ColorWidgets/svselector.h"
13 | 
14 | 
15 | class MainWindow;
16 | 
17 | class MainController : public QObject
18 | {
19 |   Q_OBJECT
20 | 
21 | private:
22 |   HSelector* hSelector;
23 |   SVSelector* svSelector;
24 | 
25 |   ColorProcessor* colorProcessor;
26 |   SlidersController *slidersController;
27 |   
28 |   MainWindow* view;
29 |     
30 |   
31 | public:
32 |   explicit MainController(HSelector* hSelector, SVSelector* svSelector,
33 |                       ColorProcessor *colorProcessor, 
34 |                       MainWindow *view, 
35 |                       QObject* parent=0);
36 |   
37 |   void addSlidersController(SlidersController *slidersController);
38 |   
39 |   
40 | private:
41 |   void changeRGB(int pos, int val);
42 |   void changeCMYK(int pos, int val);
43 |   
44 |   void connectRGB();
45 |   void disconnectRGB();
46 |   void connectCMYK();
47 |   void disconnectCMYK();
48 |   
49 | signals:
50 |   void hueChanged(QColor);
51 |   void saturationChanged(QColor);
52 |   void valueChanged(QColor);
53 |   
54 |   void redChanged(QColor);
55 |   void greenChanged(QColor);
56 |   void blueChanged(QColor);
57 | 
58 |   void cyanChanged(QColor);
59 |   void magentaChanged(QColor);
60 |   void yellowChanged(QColor);
61 |   void blackChanged(QColor);  
62 |  
63 | 
64 | public slots:
65 |   void changeHue(QColor color);
66 |   void changeSaturation(QColor color);
67 |   void changeValue(QColor color);
68 |   
69 |   void changeRed(QColor color);
70 |   void changeGreen(QColor color);
71 |   void changeBlue(QColor color);
72 |   
73 |   void changeCyan(QColor color);
74 |   void changeMagenta(QColor color);
75 |   void changeYellow(QColor color);
76 |   void changeBlack(QColor color); 
77 |   
78 | };
79 | 
80 | #endif // MAINCONTROLLER_H
81 | 


--------------------------------------------------------------------------------
/QtColorPicker.pro:
--------------------------------------------------------------------------------
 1 | #-------------------------------------------------
 2 | #
 3 | # Project created by QtCreator 2015-05-28T15:25:48
 4 | #
 5 | #-------------------------------------------------
 6 | 
 7 | QT       += core gui
 8 | 
 9 | greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
10 | 
11 | TARGET = QtColorPicker
12 | TEMPLATE = app
13 | 
14 | QMAKE_CXXFLAGS -= -Wunused-parameter
15 | CONFIG += c++11
16 | 
17 | win32:RC_ICONS += icon.ico
18 | 
19 | 
20 | SOURCES += main.cpp\
21 |     Views/mainwindow.cpp \
22 |     Views/sliderswindow.cpp \
23 |     Views/pickerview.cpp \
24 | \
25 |     Widgets/ColorWidgets/colorwidget.cpp \
26 |     Widgets/ColorWidgets/colorsample.cpp \
27 |     Widgets/ColorWidgets/hselector.cpp \
28 |     Widgets/ColorWidgets/svselector.cpp \
29 |     Widgets/colortext.cpp \
30 | \    
31 |     Widgets/Sliders/colorslider.cpp \
32 |     Widgets/Sliders/HSV/hsvslider.cpp \
33 |     Widgets/Sliders/RGB/rgbslider.cpp \
34 |     Widgets/Sliders/CMYK/cmykslider.cpp \
35 | \
36 |     Service/services.cpp \
37 |     Service/validator.cpp \
38 |     Service/vars.cpp \
39 | \
40 |     Models/colorprocessor.cpp \
41 | \    
42 |     Controllers/sliderscontroller.cpp \
43 |     Controllers/maincontroller.cpp \
44 |     Views/testwidget.cpp \
45 |     Views/testdialog.cpp
46 | 
47 | 
48 | HEADERS  += Views/mainwindow.h \
49 |     Views/sliderswindow.h \
50 |     Views/pickerview.h \
51 | \
52 |     Widgets/ColorWidgets/colorwidget.h \
53 |     Widgets/ColorWidgets/colorsample.h \
54 |     Widgets/ColorWidgets/hselector.h \
55 |     Widgets/ColorWidgets/svselector.h \
56 |     Widgets/colortext.h \
57 | \
58 |     Widgets/Sliders/colorslider.h \
59 |     Widgets/Sliders/HSV/hsvslider.h \
60 |     Widgets/Sliders/RGB/rgbslider.h \
61 |     Widgets/Sliders/CMYK/cmykslider.h \
62 | \    
63 |     Service/services.h \
64 |     Service/validator.h \
65 |     Service/vars.h \
66 | \
67 |     Models/colorprocessor.h \
68 | \    
69 |     Controllers/sliderscontroller.h \
70 |     Controllers/maincontroller.h \
71 |     Views/testwidget.h \
72 |     Views/testdialog.h
73 |     
74 |     
75 | FORMS    += Views/mainwindow.ui \
76 |     Views/test_form.ui \
77 |     Views/sliderswindow.ui \
78 |     Views/testwidget.ui \
79 |     Views/testdialog.ui
80 | 


--------------------------------------------------------------------------------
/Service/services.cpp:
--------------------------------------------------------------------------------
 1 | #include "services.h"
 2 | 
 3 | Services::Services(QObject *parent) :
 4 |   QObject(parent)
 5 | {
 6 | }
 7 | 
 8 | // outer rect (specify rect with inner coordinates, the round rect will be outer)
 9 | 
10 | void Services::drawRoundRect(QPainter& p, QRectF sizeRect, int borderSize, int borderRadius, QColor borderColor) {
11 |   QPen pen;
12 |   pen.setWidth(borderSize);
13 |   pen.setColor(borderColor);
14 |   pen.setJoinStyle(Qt::RoundJoin);
15 | 
16 |   p.setPen(pen);
17 |   p.setBrush(Qt::NoBrush);
18 | 
19 |   QRectF rect(sizeRect.x() - borderSize/2, sizeRect.y() - borderSize/2,
20 |               sizeRect.width() + borderSize, sizeRect.height() + borderSize);
21 | 
22 |   if (borderSize % 2 == 0)
23 |     p.drawRoundedRect(rect, borderSize, borderSize);
24 |   else
25 |     p.drawRoundedRect(rect.translated(0.5, 0.5), borderRadius, borderRadius);
26 | }
27 | 
28 | 
29 | void Services::drawInnerRoundRect(QPainter& p, QRectF sizeRect, int borderSize, int borderRadius, QColor borderColor) {
30 |   QPen pen;
31 |   pen.setWidth(borderSize);
32 |   pen.setColor(borderColor);
33 |   pen.setJoinStyle(Qt::RoundJoin);
34 | 
35 |   p.setPen(pen);
36 |   p.setBrush(Qt::NoBrush);
37 | 
38 |   QRectF rect(sizeRect.x() + borderSize/2, sizeRect.y() + borderSize/2,
39 |               sizeRect.width() - borderSize, sizeRect.height() - borderSize);
40 | 
41 |   if (borderSize % 2 == 0)
42 |     p.drawRoundedRect(rect, borderSize, borderSize);
43 |   else
44 |     p.drawRoundedRect(rect.translated(0.5, 0.5), borderRadius, borderRadius);
45 | }
46 | 
47 | 
48 | // ----------------- triangles for HueBar -----------------
49 | 
50 | // void Services::drawLeftTriangle(QPainter& p) {
51 | //   QPen pen(Qt::NoPen);
52 | //   QBrush brush(pointerColor);
53 | //   pen.setCapStyle(Qt::FlatCap);
54 | //   p.setBrush(brush);
55 | //   p.setPen(pen);
56 | 
57 | //   QPolygonF triangle;
58 | 
59 | //   QPoint p1(border+pointerWidth, pointerY);
60 | //   QPoint p2(border, pointerY - triangleDy);
61 | //   QPoint p3(border, pointerY + triangleDy);
62 | 
63 | //   triangle << p1 << p2 << p3;
64 | //   QPainterPath path;
65 | //   path.addPolygon(triangle);
66 | //   p.drawPath(path);
67 | // }
68 | 
69 | // void Services::drawRightTriangle(QPainter& p) {
70 | //   QPen pen(Qt::NoPen);
71 | //   QBrush brush(pointerColor);
72 | //   pen.setCapStyle(Qt::FlatCap);
73 | //   p.setBrush(brush);
74 | //   p.setPen(pen);
75 | 
76 | //   QPolygonF triangle;
77 | 
78 | //   QPoint p1(width()-border-pointerWidth, pointerY);
79 | //   QPoint p2(width()-border, pointerY - triangleDy);
80 | //   QPoint p3(width()-border, pointerY + triangleDy);
81 | 
82 | //   triangle << p1 << p2 << p3;
83 | //   QPainterPath path;
84 | //   path.addPolygon(triangle);
85 | //   p.drawPath(path);
86 | // }
87 | 


--------------------------------------------------------------------------------
/Views/testwidget.cpp:
--------------------------------------------------------------------------------
  1 | #include "testwidget.h"
  2 | #include "ui_testwidget.h"
  3 | 
  4 | 
  5 | #include <QPainter>
  6 | #include <QDebug>
  7 | #include <QMouseEvent>
  8 | #include <QScreen>
  9 | 
 10 | 
 11 | TestWidget::TestWidget(QWidget *parent) :
 12 |   QWidget(parent),
 13 |   ui(new Ui::TestWidget)
 14 | {
 15 |   ui->setupUi(this);
 16 | }
 17 | 
 18 | TestWidget::~TestWidget()
 19 | {
 20 |   delete ui;
 21 | }
 22 | 
 23 | 
 24 | void TestWidget::paintEvent(QPaintEvent *event) {
 25 |   int w = width();
 26 |   int h = height();
 27 |   
 28 |   QPainter p(this);
 29 |   
 30 |   int b = 2;
 31 |   int step = 10;
 32 |   
 33 |   // -- setup
 34 |   QPen pen;
 35 |   pen.setWidth(b);
 36 |   pen.setColor(QColor(40,40,40));
 37 |   pen.setJoinStyle(Qt::RoundJoin);
 38 |   
 39 |   // p.setRenderHint(QPainter::Antialiasing);
 40 |   p.setPen(pen);
 41 |   p.setBrush(QBrush(QColor(255,255,255)));
 42 |   
 43 |   QPen penGrid;
 44 |   penGrid.setWidth(1);
 45 |   penGrid.setColor(QColor(0,0,0));
 46 |   
 47 |   // -- draw
 48 |   p.drawRect(b/2, b/2, w-b, h-b);
 49 |   p.setPen(penGrid);
 50 |   
 51 |   int cols = (w - 2*b) / step;
 52 |   int rows = (h - 2*b) / step;
 53 |   
 54 |   for (int i = 1; i < cols; i++) {
 55 |     int x = b/2 + i*(step+1);
 56 |     p.drawLine(x, b, x, h-b);
 57 |   }
 58 |   
 59 |   for (int i = 1; i < rows; i++) {
 60 |     int y = b/2 + i*(step+1);
 61 |     p.drawLine(b, y, w-b, y);
 62 |   }
 63 |   
 64 |   
 65 |   // -- screen pixels
 66 |   QPixmap pix = QPixmap();
 67 |   QScreen *screen = QGuiApplication::primaryScreen();
 68 |   if (screen) pix = screen->grabWindow(0);
 69 |   
 70 |   for (int row = 0; row < rows; row++) {
 71 |     for (int col = 0; col < cols; col++) {
 72 |       QRgb rgb = pix.toImage().pixel(row, col);
 73 |       QColor pixColor(rgb);
 74 |       p.setPen(QPen(pixColor));
 75 |       
 76 |       for (int k = 0; k < step*step; k++) {
 77 |         int x = col * step + k % step;
 78 |         int y = row * step + k / step;
 79 |         if (x == col*step || y == row*step) continue;
 80 |         if (x < b || y < b) continue;
 81 |         if (x >= w-b || y >= h-b) continue;
 82 |         p.drawPoint(x, y);
 83 |       }
 84 |     }
 85 |   }
 86 | }
 87 | 
 88 | void TestWidget::mousePressEvent(QMouseEvent *e)
 89 | {
 90 |   mx=e->x();
 91 |   my=e->y();
 92 | }
 93 | 
 94 | void TestWidget::mouseMoveEvent(QMouseEvent *e) {
 95 |   // int x = e->x();
 96 |   // int y = e->y();
 97 |   
 98 |   // int wx = x - width()/2;
 99 |   // int wy = y - height()/2;
100 |   
101 |   // // qDebug() << wx << wy;
102 |   // move(wx, wy);
103 |   
104 |   
105 |   int gx=e->globalX();
106 |   int gy=e->globalY();
107 | 
108 |   int corrX=geometry().x() - x();
109 |   int corrY=geometry().y() - y();
110 | 
111 |   int moveX=gx-mx-corrX;
112 |   int moveY=gy-my-corrY;
113 | 
114 |   move(moveX, moveY);
115 | }
116 | 
117 | 


--------------------------------------------------------------------------------
/Widgets/ColorWidgets/colorwidget.cpp:
--------------------------------------------------------------------------------
  1 | #include "colorwidget.h"
  2 | 
  3 | #include <QPainter>
  4 | #include <QDebug>
  5 | #include <QMouseEvent>
  6 | 
  7 | #include "Service/services.h"
  8 | 
  9 | 
 10 | // ----------------------------------------------------------------------------------------------------
 11 | 
 12 | ColorWidget::ColorWidget(QWidget *parent) : QWidget(parent) {
 13 |   selectorDrawn = false;
 14 |   middlePresed = false;
 15 |   
 16 |   shiftHeld = false;
 17 |   ctrlHeld = false;
 18 |  
 19 |   pointerY = 0;
 20 |   
 21 |   h = 0;
 22 |   s = maxSV;
 23 |   v = maxSV;
 24 |   
 25 |   hf = 0;
 26 |   sf = maxF;
 27 |   vf = maxF;
 28 |   
 29 |   color.setHsv(h, s, v);
 30 | }
 31 | 
 32 | 
 33 | // ---------------------------------------------- service ----------------------------------------------
 34 | 
 35 | void ColorWidget::drawCircle(QPainter& p) {
 36 |   QPen pen(pointerBorderColor, pointerBorder);
 37 |   p.setPen(pen);
 38 |   p.setBrush(pointerColor);
 39 |   p.drawEllipse( QPoint(pointerX, pointerY), pointerR, pointerR );
 40 | }
 41 | 
 42 | void ColorWidget::drawRightTrapezoid(QPainter& p) {
 43 |   QPen pen(Qt::NoPen);
 44 |   pen.setCapStyle(Qt::FlatCap);
 45 |   QBrush brush(pointerColor);
 46 |   p.setPen(pen);
 47 |   p.setBrush(brush);
 48 | 
 49 |   QPolygonF triangle;
 50 | 
 51 |   QPoint p1( width() - pointerWidth, pointerY + pointerDy1 );
 52 |   QPoint p2( width() - pointerWidth, pointerY - pointerDy1 );
 53 |   QPoint p3( width(), pointerY - pointerDy2 );
 54 |   QPoint p4( width(), pointerY + pointerDy2 );
 55 | 
 56 |   triangle << p1 << p2 << p3 << p4;
 57 |   
 58 |   QPainterPath path;
 59 |   path.addPolygon(triangle);
 60 |   p.drawPath(path);
 61 | }
 62 | 
 63 | void ColorWidget::hideCursor(QMouseEvent *e) {
 64 |   int x = e->x();
 65 |   int y = e->y();
 66 | 
 67 |   if ( ( x<minPointerXY || x>maxPointerXY ) || ( y<minPointerXY || y>maxPointerXY ) ) {
 68 |     restoreCursor();
 69 |     return;
 70 |   }
 71 |   this->setCursor( QCursor(Qt::BlankCursor) );
 72 | }
 73 | 
 74 | void ColorWidget::restoreCursor() {
 75 |   this->setCursor( QCursor(Qt::ArrowCursor) );
 76 | }
 77 | 
 78 | 
 79 | // ---------------------------------------------- slots ----------------------------------------------
 80 | 
 81 | void ColorWidget::shiftPressed() {
 82 |   shiftHeld = true;
 83 | }
 84 | 
 85 | void ColorWidget::shiftReleased() {
 86 |   shiftHeld = false;
 87 | }
 88 | 
 89 | void ColorWidget::ctrlPressed() {
 90 |   ctrlHeld = true;
 91 | }
 92 | 
 93 | void ColorWidget::ctrlReleased() {
 94 |   ctrlHeld = false;
 95 | }
 96 | 
 97 | // ---------------------------------------------- other ----------------------------------------------
 98 | 
 99 | void ColorWidget::log(QString format, int var) {
100 |  qDebug() << QString(format).arg(var);
101 | }
102 | 
103 | void ColorWidget::log(QString format, qreal var) {
104 |  qDebug() << QString(format).arg(var);
105 | }
106 | 


--------------------------------------------------------------------------------
/Views/mainwindow.h:
--------------------------------------------------------------------------------
  1 | #ifndef MAINWINDOW_H
  2 | #define MAINWINDOW_H
  3 | 
  4 | #include <QMainWindow>
  5 | #include <QSignalMapper>
  6 | 
  7 | #include <QLineEdit>
  8 | 
  9 | #include "Models/colorprocessor.h"
 10 | 
 11 | #include "Controllers/sliderscontroller.h"
 12 | #include "Controllers/maincontroller.h"
 13 | 
 14 | #include "sliderswindow.h"
 15 | 
 16 | namespace Ui {
 17 | class MainWindow;
 18 | }
 19 | 
 20 | class MainController;
 21 | 
 22 | class MainWindow : public QMainWindow
 23 | {
 24 |   Q_OBJECT
 25 | 
 26 | private:
 27 |   QSignalMapper *mapper;
 28 |   
 29 |   Ui::MainWindow *ui;
 30 |   
 31 |   SlidersController *slidersController;
 32 |   MainController *mainController;
 33 |   
 34 |   ColorProcessor *colorProcessor;
 35 |   SlidersWindow* slidersWindow;
 36 |   
 37 |   QString editingField;
 38 | 
 39 |   bool mouseDown;
 40 |   bool mouseMoved;
 41 |   int mx, my;
 42 |   
 43 | 
 44 | public:
 45 |   explicit MainWindow(QWidget *parent = 0);
 46 |   ~MainWindow();
 47 |   
 48 |   void setHSV(QString text);
 49 |   void setRGB(QString text);
 50 |   void setCMYK(QString text);
 51 |   void setHex(QString text);
 52 | 
 53 |   QString getHSV();
 54 |   QString getRGB();
 55 |   QString getCMYK();
 56 |   QString getHex();
 57 | 
 58 | 
 59 | private:
 60 |   void addActions();
 61 |   void addShortcuts();
 62 |   void addSlidersActions();
 63 |   void init();
 64 |     
 65 |   void updateSliders();
 66 |   void stickSliders();
 67 |   void status(QString msg);
 68 | 
 69 |   void correctFields();
 70 |   QString correctField(QString text);
 71 |   
 72 |   
 73 | protected:
 74 |   void mouseMoveEvent(QMouseEvent* e);
 75 |   void mousePressEvent(QMouseEvent* e);
 76 |   void mouseReleaseEvent(QMouseEvent* e);
 77 | 
 78 |   void keyPressEvent(QKeyEvent *e);
 79 |   void keyReleaseEvent(QKeyEvent *e);
 80 |   
 81 |   bool eventFilter(QObject *obj, QEvent *event);
 82 | 
 83 | signals:
 84 |   void mouseMovedOnWindow();
 85 |   void mouseReleasedOnWindow();
 86 |   void shiftPressed();
 87 |   void shiftReleased();
 88 |   void ctrlPressed();
 89 |   void ctrlReleased();
 90 | 
 91 | public slots:
 92 |   void updateColorHSV(QString HSV);
 93 |   void updateColorRGB(QString RGB);
 94 |   void updateColorCMYK(QString CMYK);
 95 |   void updateColorHex(QString Hex);
 96 | 
 97 | private slots:
 98 |   void selectField(QWidget* w);
 99 |   
100 |   void updateColorText(QColor color);
101 |   void updateColorFinished();
102 | 
103 |   void copyHSV();
104 |   void copyRGB();
105 |   void copyCMYK();
106 |   void copyHex();
107 |   void copyHexHash();
108 |   void pasteHex();  
109 | 
110 |   void middleClick(QMouseEvent *e);
111 |   void hsvMiddlePressed(QMouseEvent *e);
112 |   
113 |   void toggleSliders();
114 |   void closeSliders();
115 |   void openSliders();
116 |   
117 |   void focusNextField();
118 |   void focusPrevField();
119 |   
120 |   void showPickerClicked();
121 |   
122 | };
123 | 
124 | #endif // MAINWINDOW_H
125 | 
126 | 


--------------------------------------------------------------------------------
/Widgets/ColorWidgets/colorsample.cpp:
--------------------------------------------------------------------------------
  1 | #include "colorsample.h"
  2 | 
  3 | #include <QPainter>
  4 | #include <QDebug>
  5 | 
  6 | #include "Service/services.h"
  7 | 
  8 | 
  9 | // ----------------------------------------------- consts -----------------------------------------------
 10 | 
 11 | const QColor defaultBorderColor = QColor(80,80,80,200);
 12 | 
 13 | 
 14 | // ----------------------------------------------------------------------------------------------------
 15 | 
 16 | ColorSample::ColorSample(QWidget *parent) : ColorWidget(parent)
 17 | {
 18 |   color.setHsv(0, maxSV, maxSV);
 19 |   borderColor = defaultBorderColor;
 20 | }
 21 | 
 22 | 
 23 | // --------------------------------------------- events ---------------------------------------------
 24 | 
 25 | void ColorSample::paintEvent(QPaintEvent *event)
 26 | {
 27 |   QPainter p(this);
 28 |   p.setRenderHint(QPainter::Antialiasing);
 29 |   
 30 |   p.setPen(Qt::NoPen);
 31 |   p.setBrush(color);
 32 |   p.drawRect(border, border, width()-2*border, height()-2*border);
 33 |   
 34 |   drawBorder(p);
 35 | }
 36 | 
 37 | void ColorSample::mouseReleaseEvent(QMouseEvent *e)
 38 | {
 39 |   if (!mouseMoving) {
 40 |     switch ( e->button() ) {
 41 |       case Qt::LeftButton:
 42 |         emit samplePressedLeft();
 43 |         break;
 44 |       case Qt::RightButton:
 45 |         emit samplePressedRight();
 46 |         break;
 47 |       case Qt::MiddleButton:
 48 |         emit samplePressedMiddle();
 49 |         e->accept();
 50 |         return;
 51 |       default:
 52 |         return;
 53 |     }
 54 |   }
 55 |   
 56 |   if (e->button() == Qt::MiddleButton) {
 57 |     emit samplePressedMiddle();
 58 |     e->accept();
 59 |     return;
 60 |   }
 61 |   
 62 |   e->ignore();
 63 |   mouseMoving = false;
 64 | }
 65 | 
 66 | void ColorSample::enterEvent(QEvent *e)
 67 | {
 68 |   borderColor.setRgb(30,30,30,220);
 69 |   setCursor(Qt::PointingHandCursor);
 70 |   update();
 71 | }
 72 | 
 73 | void ColorSample::leaveEvent(QEvent *e)
 74 | {
 75 |   borderColor = defaultBorderColor;
 76 |   setCursor(Qt::ArrowCursor);
 77 |   update();
 78 | }
 79 | 
 80 | 
 81 | // --------------------------------------------- slots ---------------------------------------------
 82 | 
 83 | void ColorSample::mouseMovedOnWindow() {
 84 |   mouseMoving = true;
 85 | }
 86 | 
 87 | void ColorSample::mouseReleasedOnWindow() {
 88 |   mouseMoving = false;
 89 | }
 90 | 
 91 | void ColorSample::changeColor(QColor color)
 92 | {
 93 |   this->color = color;
 94 |   emit colorChanged(color);
 95 |   update();
 96 | }
 97 | 
 98 | void ColorSample::reupdateColor()
 99 | {
100 |   emit colorChanged(color);
101 | }
102 | 
103 | // --------------------------------------------- service ---------------------------------------------
104 | 
105 | void ColorSample::drawBorder(QPainter& p) {
106 |   QRectF rectangle(0, 0, width(), height());
107 |   Services::drawInnerRoundRect(p, rectangle, border, borderRadius, borderColor);
108 | }
109 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # QtColorPicker
 2 | 
 3 | ## Main features
 4 | 
 5 | - Hue, Saturation, Value selectors
 6 | - Conversion of selected color to text represented in text fields
 7 | - Buttons to copy color values and past **Hex** value
 8 | - Color sliders and spinners for 3 color models (**HSV, RGB, CMYK**)
 9 | 
10 | 
11 | ## Additional features
12 | 
13 | - Main window and sliders window can be moved by dragging background window space with **left/right/middle** mouse buttons
14 | - When mouse is on color selectors or sliders the parent window can be moved with the **middle** mouse button
15 | - Windows can be closed with the **middle button** click on any element except *text fields, color sample and spinners*
16 | - Separate component values in the text fields can be *increased/decreased* with **Up/Down** keys
17 | - In text fields selection of the *next/previous* component can be performed with **Tab/Shift+Tab** keys
18 | - Mouse scrolling can be used to *increase/decrease* values by 1 and by 10 with **Ctrl** key for selectors, sliders and spinners (to change **Saturation** on the selector with scrolling **Shift** is held)
19 | - **Left/Right click** on the color sample can be used to copy **Hex** color without and with leading # respectively
20 | 
21 | 
22 | ## Usage
23 | 
24 | - To *increase/decrease* value of a color component in text fields set text cursor near it or select it and press **Up/Down** keys or mouse scroll
25 | - To select *next/previous* color component in the same field press **Tab/Shift+Tab**
26 | - To toggle **Sliders window** click with middle mouse button on the color sample or use **Ctrl+S**
27 | - To **close** any window **middle click** somewhere on it
28 | - To **move** any window drag it with any mouse button by any part (except *selector, sliders, spinners, buttons and text fields* on which the middle button can be used)
29 | 
30 | 
31 | ## Shortcuts
32 | 
33 | - **F1 - F5** - copy color values (HSV, RGB, CMYK, Hex, # Hex)
34 | - **F6** - paste Hex value
35 | - **Shift+F1 - Shift+F4** - focus text fields (HSV, RGB, CMYK, Hex)
36 | - **Ctrl+S** - open/close Sliders window
37 | - **Esc** or mouse wheel press - exit
38 | - mouse wheel press on the color sample - open/close Sliders window
39 | - left/right mouse click on the color sample - copy Hex value (without/with leading #)
40 | - mouse scroll on the vertical Hue selector - change the Hue value by 1
41 | - mouse scroll on the rectangular Saturation/Value selector - change Value component by 1, with **Shift** - change Saturation component
42 | - mouse scroll with **Ctrl** - change values by 10
43 | 
44 | ## Download
45 | 
46 | Portable packages:
47 | 
48 | [All releases](https://github.com/mortalis13/Qt-Color-Picker-Qt/releases) <br>
49 | [SourceForge](https://sourceforge.net/projects/qtcolorpicker/files) <br>
50 | [Softpedia v1.0.0](http://www.softpedia.com/get/PORTABLE-SOFTWARE/Multimedia/Graphics/Portable-QtColorPicker.shtml)
51 | 
52 | ## Build
53 | 
54 | The program was created with [Qt 5.3.1](http://download.qt.io/official_releases/qt/5.3/5.3.1/) using MinGW compiler in [Qt Creator 3.1.2](http://download.qt.io/official_releases/qtcreator/3.1/3.1.2/).
55 | 
56 | 
57 | ## Screenshots
58 | 
59 | ![QtColorPicker-main](/files/qtcolorpicker-1.png)  
60 | ![QtColorPicker-sliders](/files/qtcolorpicker-2.png)
61 | 


--------------------------------------------------------------------------------
/Controllers/sliderscontroller.h:
--------------------------------------------------------------------------------
  1 | #ifndef SLIDERSCONTROLLER_H
  2 | #define SLIDERSCONTROLLER_H
  3 | 
  4 | #include <QColor>
  5 | #include <QObject>
  6 | 
  7 | #include "Views/sliderswindow.h"
  8 | 
  9 | 
 10 | class SlidersWindow;
 11 | 
 12 | class SlidersController : public QObject
 13 | {
 14 |   Q_OBJECT
 15 | 
 16 | private:
 17 |   SlidersWindow* slidersView;
 18 | 
 19 |   bool hueSpinManualEdit;
 20 |   bool saturationSpinManualEdit;
 21 |   bool valueSpinManualEdit;
 22 |   
 23 |   bool redSpinManualEdit;
 24 |   bool greenSpinManualEdit;
 25 |   bool blueSpinManualEdit;
 26 |   
 27 |   bool cyanSpinManualEdit;
 28 |   bool magentaSpinManualEdit;
 29 |   bool yellowSpinManualEdit;
 30 |   bool blackSpinManualEdit;
 31 |   
 32 |   
 33 | public:
 34 |   explicit SlidersController(QObject* parent=0);
 35 |   
 36 |   void setView(SlidersWindow* slidersView);
 37 |   
 38 |   void connectRGB();
 39 |   void disconnectRGB();
 40 |   void connectCMYK();
 41 |   void disconnectCMYK();
 42 | 
 43 | 
 44 | private:
 45 |   void addActions();
 46 |   void init();
 47 |   
 48 |   void updateRedValues(QColor color);
 49 |   void updateGreenValues(QColor color);
 50 |   void updateBlueValues(QColor color);
 51 |   
 52 |   void updateCyanValues(QColor color);
 53 |   void updateMagentaValues(QColor color);
 54 |   void updateYellowValues(QColor color);
 55 |   void updateBlackValues(QColor color);
 56 |   
 57 | 
 58 | signals:
 59 |   void RGBChanged(QColor);
 60 |   void CMYKChanged(QColor);
 61 |   
 62 |   
 63 |   void hueChanged(int);
 64 |   void hueChanged(QColor);
 65 |   
 66 |   void saturationChanged(int);
 67 |   void saturationChanged(QColor);
 68 |   
 69 |   void valueChanged(int);
 70 |   void valueChanged(QColor);
 71 |   
 72 |   
 73 |   void redChanged(int);
 74 |   void redChanged(QColor);
 75 |   
 76 |   void greenChanged(int);
 77 |   void greenChanged(QColor);
 78 |   
 79 |   void blueChanged(int);
 80 |   void blueChanged(QColor);
 81 |   
 82 | 
 83 |   void cyanChanged(int);
 84 |   void cyanChanged(QColor);
 85 |   
 86 |   void magentaChanged(int);
 87 |   void magentaChanged(QColor);
 88 |   
 89 |   void yellowChanged(int);
 90 |   void yellowChanged(QColor);
 91 |   
 92 |   void blackChanged(int);
 93 |   void blackChanged(QColor);
 94 | 
 95 | 
 96 | public slots:
 97 |   void changeHue(int h);
 98 |   void changeHue(QColor color);
 99 |   void changeHueFromSelector(QColor color);
100 |   
101 |   void changeSaturation(int s);
102 |   void changeSaturation(QColor color);
103 |   void changeSaturationFromSelector(QColor color);  
104 |   
105 |   void changeValue(int s);
106 |   void changeValue(QColor color);
107 |   void changeValueFromSelector(QColor color);  
108 |   
109 |   
110 |   void changeRed(int r);
111 |   void changeRed(QColor color);
112 |   void changeRedFromSelector(QColor color);
113 |   
114 |   void changeGreen(int g);
115 |   void changeGreen(QColor color);
116 |   void changeGreenFromSelector(QColor color);
117 |   
118 |   void changeBlue(int b);
119 |   void changeBlue(QColor color);
120 |   void changeBlueFromSelector(QColor color);
121 |   
122 |   
123 |   void changeCyan(int c);
124 |   void changeCyan(QColor color);
125 |   void changeCyanFromSelector(QColor color);
126 |   
127 |   void changeMagenta(int m);
128 |   void changeMagenta(QColor color);
129 |   void changeMagentaFromSelector(QColor color);
130 |   
131 |   void changeYellow(int y);
132 |   void changeYellow(QColor color);
133 |   void changeYellowFromSelector(QColor color);
134 |   
135 |   void changeBlack(int k);
136 |   void changeBlack(QColor color);
137 |   void changeBlackFromSelector(QColor color);
138 |   
139 | };
140 | 
141 | #endif // SLIDERSCONTROLLER_H
142 | 


--------------------------------------------------------------------------------
/Controllers/maincontroller.cpp:
--------------------------------------------------------------------------------
  1 | #include "maincontroller.h"
  2 | 
  3 | 
  4 | MainController::MainController(HSelector *hSelector, SVSelector *svSelector,
  5 |                        ColorProcessor *colorProcessor, 
  6 |                        MainWindow *view,
  7 |                        QObject* parent) : QObject(parent)
  8 | {
  9 |   this->hSelector = hSelector;
 10 |   this->svSelector = svSelector;
 11 |   this->view = view;
 12 |   this->colorProcessor = colorProcessor;
 13 |   
 14 |   slidersController = NULL;
 15 | }
 16 | 
 17 | void MainController::addSlidersController(SlidersController *slidersController) {
 18 |   this->slidersController = slidersController;
 19 | }
 20 | 
 21 | void MainController::connectRGB() {
 22 |   if (slidersController!=NULL)
 23 |     slidersController->connectRGB();
 24 | }
 25 | 
 26 | void MainController::disconnectRGB() {
 27 |   if (slidersController!=NULL)
 28 |     slidersController->disconnectRGB();
 29 | }
 30 | 
 31 | void MainController::connectCMYK() {
 32 |   if (slidersController!=NULL)
 33 |     slidersController->connectCMYK();
 34 | }
 35 | 
 36 | void MainController::disconnectCMYK() {
 37 |   if (slidersController!=NULL)
 38 |     slidersController->disconnectCMYK();
 39 | }
 40 | 
 41 | 
 42 | // --------------------------------------------- HSV ---------------------------------------------
 43 | 
 44 | // ===== hue =====
 45 | void MainController::changeHue(QColor color) {
 46 |   hSelector->setH(color);
 47 | }
 48 | 
 49 | // ===== saturation =====
 50 | void MainController::changeSaturation(QColor color) {
 51 |   svSelector->setS(color);
 52 | }
 53 | 
 54 | // ===== value =====
 55 | void MainController::changeValue(QColor color) {
 56 |   svSelector->setV(color);
 57 | }
 58 | 
 59 | 
 60 | // --------------------------------------------- RGB ---------------------------------------------
 61 | 
 62 | void MainController::changeRGB(int pos, int val) {
 63 |   QString RGB_Text = view->getRGB();
 64 |   QColor currentColor = colorProcessor->getColorRGB(RGB_Text);
 65 |   
 66 |   switch (pos) {
 67 |     case 0:
 68 |       currentColor.setRed(val);
 69 |       break;  
 70 |     case 1:
 71 |       currentColor.setGreen(val);
 72 |       break;  
 73 |     case 2:
 74 |       currentColor.setBlue(val);
 75 |       break;  
 76 |   }
 77 |   
 78 |   disconnectRGB();
 79 |   QString RGB = colorProcessor->getRGB(currentColor);
 80 |   view->setRGB(RGB);
 81 |   view->updateColorRGB(RGB);
 82 |   connectRGB();
 83 | }
 84 | 
 85 | // ===== red =====
 86 | void MainController::changeRed(QColor color) {
 87 |   changeRGB(0, color.red());
 88 | }
 89 | 
 90 | // ===== green =====
 91 | void MainController::changeGreen(QColor color) {
 92 |   changeRGB(1, color.green());
 93 | }
 94 | 
 95 | // ===== blue =====
 96 | void MainController::changeBlue(QColor color) {
 97 |   changeRGB(2, color.blue());
 98 | }
 99 | 
100 | 
101 | // --------------------------------------------- CMYK ---------------------------------------------
102 | 
103 | void MainController::changeCMYK(int pos, int val) {
104 |   QString CMYK_Text = view->getCMYK();
105 |   QColor currentColor = colorProcessor->getColorCMYK(CMYK_Text);
106 |   
107 |   int c = currentColor.cyan();
108 |   int m = currentColor.magenta();
109 |   int y = currentColor.yellow();
110 |   int k = currentColor.black();
111 |   
112 |   switch (pos) {
113 |     case 0:
114 |       c = val;
115 |       break;  
116 |     case 1:
117 |       m = val;
118 |       break;  
119 |     case 2:
120 |       y = val;
121 |       break;  
122 |     case 3:
123 |       k = val;
124 |       break;  
125 |   }
126 |   currentColor.setCmyk(c, m, y, k);
127 |   
128 |   disconnectCMYK();
129 |   QString CMYK = colorProcessor->getCMYK(currentColor);
130 |   view->setCMYK(CMYK);
131 |   view->updateColorCMYK(CMYK);
132 |   connectCMYK();
133 | }
134 | 
135 | // ===== cyan =====
136 | void MainController::changeCyan(QColor color) {
137 |   changeCMYK(0, color.cyan());
138 | }
139 | 
140 | // ===== magenta =====
141 | void MainController::changeMagenta(QColor color) {
142 |   changeCMYK(1, color.magenta());
143 | }
144 | 
145 | // ===== yellow =====
146 | void MainController::changeYellow(QColor color) {
147 |   changeCMYK(2, color.yellow());
148 | }
149 | 
150 | // ===== black =====
151 | void MainController::changeBlack(QColor color) {
152 |   changeCMYK(3, color.black());
153 | }
154 | 


--------------------------------------------------------------------------------
/Widgets/ColorWidgets/hselector.cpp:
--------------------------------------------------------------------------------
  1 | #include "hselector.h"
  2 | 
  3 | #include <QPainter>
  4 | #include <QDebug>
  5 | #include <QMouseEvent>
  6 | 
  7 | #include "Service/services.h"
  8 | 
  9 | 
 10 | // ----------------------------------------------------------------------------------------------------
 11 | 
 12 | HSelector::HSelector(QWidget *parent) : ColorWidget(parent) {
 13 | }
 14 | 
 15 | void HSelector::paintEvent(QPaintEvent *event)
 16 | {
 17 |   QPainter p(this);
 18 |   p.setRenderHint(QPainter::Antialiasing);
 19 | 
 20 |   barHeight = height()-2*border;
 21 |   
 22 |   if (!selectorDrawn) {
 23 |     hSelectorPixmap = QPixmap(barWidth, barHeight);
 24 |     QPainter huePainter(&hSelectorPixmap);
 25 |     
 26 |     QPointF p1( 0, selectorY );
 27 |     QPointF p2( 0, height()-border );
 28 |     QLinearGradient grad(p1, p2);
 29 |     
 30 |     QColor color;
 31 |     for (qreal hs = 0; hs<1.0; hs+=ratio) {
 32 |       color.setHsvF(hs, sf, vf);
 33 |       grad.setColorAt(hs, color);
 34 |     }
 35 |     
 36 |     huePainter.setPen(Qt::NoPen);
 37 |     huePainter.setBrush( QBrush(grad) );
 38 |     huePainter.drawRect(0, 0, barWidth, barHeight);
 39 |     
 40 |     selectorDrawn = true;
 41 |   }
 42 |   
 43 |   p.drawPixmap(selectorX, selectorY, hSelectorPixmap);
 44 | 
 45 |   drawPointer(p);
 46 |   drawBorder(p);
 47 | }
 48 | 
 49 | void HSelector::mousePressEvent(QMouseEvent *e)
 50 | {
 51 |   if ( e->button() == Qt::MiddleButton ) {
 52 |     middlePresed = true;
 53 |     e->ignore();
 54 |     
 55 |     QMouseEvent* mouseEvent = new QMouseEvent(e->type(), e->windowPos(), e->button(), e->buttons(), e->modifiers());
 56 |     emit middlePressedSignal(mouseEvent);
 57 |   }
 58 |   else {
 59 |     middlePresed = false;
 60 |     movePointer(e->y());
 61 |     updateColor();
 62 |   }
 63 | }
 64 | 
 65 | void HSelector::mouseMoveEvent(QMouseEvent *e)
 66 | {
 67 |   if (middlePresed) {
 68 |     e->ignore();
 69 |   }
 70 |   else {
 71 |     movePointer(e->y());
 72 |     updateColor();
 73 |   }
 74 | }
 75 | 
 76 | void HSelector::mouseReleaseEvent(QMouseEvent *e)
 77 | {
 78 |   e->ignore();
 79 | }
 80 | 
 81 | void HSelector::wheelEvent(QWheelEvent *e)
 82 | {
 83 |   QPoint p = e->angleDelta();
 84 |   
 85 |   int val = 1;
 86 |   if (ctrlHeld) val = 10;
 87 |   
 88 |   if (p.y()<0) incPointer(val);
 89 |   if (p.y()>0) decPointer(val);
 90 | 
 91 |   updateColor();
 92 |   e->accept();
 93 | }
 94 | 
 95 | 
 96 | // ---------------------------------------------- service ----------------------------------------------
 97 | 
 98 | void HSelector::drawPointer(QPainter& p) {
 99 |   correctPointer();
100 |   drawRightTrapezoid(p);
101 | }
102 | 
103 | void HSelector::correctPointer() {
104 |   pointerY = h + minPointerY;                       // to update pointer Y on text edit
105 |   pointerY = qMin(maxPointerY, qMax(minPointerY, pointerY));
106 | }
107 | 
108 | void HSelector::incPointer(int val) {
109 |   movePointer(pointerY+val);
110 | }
111 | 
112 | void HSelector::decPointer(int val) {
113 |   movePointer(pointerY-val);
114 | }
115 | 
116 | void HSelector::movePointer(int y) {
117 |   pointerY = y;
118 |   update();
119 | }
120 | 
121 | void HSelector::drawBorder(QPainter& p) {
122 |   QRectF rectangle( selectorX, selectorX, barWidth, barHeight );                               // set inner rect coordinates (the border will be outer)
123 |   Services::drawRoundRect( p, rectangle, border, borderRadius, borderColor );
124 | }
125 | 
126 | void HSelector::updateColor() {
127 |   h = pointerY-border;
128 |   h = qMax(0, h);
129 |   h = qMin(maxH, h);
130 |   
131 |   color.setHsv(h, s, v);
132 |   emit hueChanged(color);
133 | }
134 | 
135 | void HSelector::reupdateColor() {
136 |   emit hueChanged(color);
137 | }
138 | 
139 | // ---------------------------------------------- set/get ----------------------------------------------
140 | 
141 | void HSelector::setInitH(int h) {
142 |   QColor color;
143 |   color.setHsv(h, s, v);
144 |   this->h = color.hue();
145 |   emit hueChanged(color);
146 |   update();
147 | }
148 | 
149 | void HSelector::setH(int h)
150 | {
151 |   if (this->h == 360) this->h = 0;
152 |   if (this->h == h) return;
153 | 
154 |   QColor color;
155 |   color.setHsv(h, s, v);
156 |   setH(color);
157 | }
158 | 
159 | void HSelector::setH(QColor color)
160 | {
161 |   int h = color.hue();
162 |   if (this->h == 360) this->h = 0;
163 |   if (this->h == h) {
164 |     return;
165 |   }
166 |   
167 |   this->h = color.hue();
168 |   emit hueChanged(color);
169 |   update();
170 | }
171 | 


--------------------------------------------------------------------------------
/Models/colorprocessor.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "colorprocessor.h"
  3 | 
  4 | #include <QApplication>
  5 | 
  6 | #include "Service/validator.h"
  7 | 
  8 | 
  9 | 
 10 | ColorProcessor::ColorProcessor(HSelector *hSelector, SVSelector *svSelector, QObject* parent) : QObject(parent) {
 11 |   this->hSelector = hSelector;
 12 |   this->svSelector = svSelector;
 13 |   clip = QApplication::clipboard();
 14 | }
 15 | 
 16 | // -------------------------------------------- color strings --------------------------------------------
 17 | 
 18 | QString ColorProcessor::getHSV(QColor color) {
 19 |   QString res;
 20 |   Validator::correctHSV(color);
 21 | 
 22 |   int h = color.hue();
 23 |   int s = color.saturation();
 24 |   int v = color.value();
 25 |   
 26 |   res = QString("%1 %2 %3").arg(h).arg(s).arg(v);
 27 |   return res;
 28 | }
 29 | 
 30 | QString ColorProcessor::getRGB(QColor color) {
 31 |   QString res;
 32 |   Validator::correctRGB(color);
 33 | 
 34 |   int r = color.red();
 35 |   int g = color.green();
 36 |   int b = color.blue();
 37 | 
 38 |   res = QString("%1 %2 %3").arg(r).arg(g).arg(b);
 39 |   return res;
 40 | }
 41 | 
 42 | QString ColorProcessor::getCMYK(QColor color) {
 43 |   QString res;
 44 |   Validator::correctCMYK(color);
 45 | 
 46 |   int c = color.cyan();
 47 |   int m = color.magenta();
 48 |   int y = color.yellow();
 49 |   int k = color.black();
 50 | 
 51 |   res = QString("%1 %2 %3 %4").arg(c).arg(m).arg(y).arg(k);
 52 |   return res;
 53 | }
 54 | 
 55 | QString ColorProcessor::getHex(QColor color) {
 56 |   QString res;
 57 | 
 58 |   res = color.name();
 59 |   res = res.replace("#", "");
 60 |   return res;
 61 | }
 62 | 
 63 | 
 64 | // -------------------------------------------- color objects --------------------------------------------
 65 | 
 66 | QColor ColorProcessor::getColorHSV(QString HSV_Text) {
 67 |   QStringList list;
 68 |   QColor color;
 69 | 
 70 |   list = HSV_Text.split(" ");
 71 |   int h = list[0].toInt();
 72 |   int s = list[1].toInt();
 73 |   int v = list[2].toInt();
 74 | 
 75 |   color.setHsv(h, s, v);
 76 | 
 77 |   return color;
 78 | }
 79 | 
 80 | QColor ColorProcessor::getColorRGB(QString RGB_Text) {
 81 |   QStringList list;
 82 |   QColor color;
 83 | 
 84 |   list = RGB_Text.split(" ");
 85 |   int r = list[0].toInt();
 86 |   int g = list[1].toInt();
 87 |   int b = list[2].toInt();
 88 | 
 89 |   color.setRgb(r, g, b);
 90 | 
 91 |   return color;
 92 | }
 93 | 
 94 | QColor ColorProcessor::getColorCMYK(QString CMYK_Text) {
 95 |   QStringList list;
 96 |   QColor color;
 97 | 
 98 |   list = CMYK_Text.split(" ");
 99 |   int c = list[0].toInt();
100 |   int m = list[1].toInt();
101 |   int y = list[2].toInt();
102 |   int k = list[3].toInt();
103 | 
104 |   color.setCmyk(c, m, y, k);
105 | 
106 |   return color;
107 | }
108 | 
109 | QColor ColorProcessor::getColorHex(QString Hex_Text) {
110 |   QColor color;
111 |   color.setNamedColor("#"+Hex_Text);
112 |   return color;
113 | }
114 | 
115 | // -------------------------------------------- update color --------------------------------------------
116 | 
117 | void ColorProcessor::updateColorHSV(QString HSV_Text) {
118 |   if ( !Validator::checkColorText(HSV_Text, Vars::HSV) ) return;
119 |   if ( !Validator::checkValueHSV(HSV_Text) ) return;
120 | 
121 |   QColor color = getColorHSV(HSV_Text);
122 |   updateColor(color);
123 | }
124 | 
125 | void ColorProcessor::updateColorRGB(QString RGB_Text) {
126 |   if ( !Validator::checkColorText(RGB_Text, Vars::RGB) ) return;
127 |   if ( !Validator::checkValueRGB(RGB_Text) ) return;
128 | 
129 |   QColor color = getColorRGB(RGB_Text);
130 |   updateColor(color);
131 | }
132 | 
133 | void ColorProcessor::updateColorCMYK(QString CMYK_Text) {
134 |   if ( !Validator::checkColorText(CMYK_Text, Vars::CMYK) ) return;
135 |   if ( !Validator::checkValueCMYK(CMYK_Text) ) return;
136 | 
137 |   QColor color = getColorCMYK(CMYK_Text);
138 |   updateColor(color);
139 | }
140 | 
141 | void ColorProcessor::updateColorHex(QString Hex_Text) {
142 |   if ( !Validator::checkValueHex(Hex_Text) ) return;
143 | 
144 |   QColor color = getColorHex(Hex_Text);
145 |   updateColor(color);
146 | }
147 | 
148 | void ColorProcessor::updateColor(QColor color) {
149 |   int h = color.hue();
150 |   int s = color.saturation();
151 |   int v = color.value();
152 | 
153 |   hSelector->setH(h);
154 |   svSelector->setSV(s, v);
155 | 
156 |   emit updateFinished();
157 | }
158 | 
159 | // -------------------------------------------- copy color text --------------------------------------------
160 | 
161 | void ColorProcessor::copyText(QString text) {
162 |   clip->setText(text);
163 | }
164 | 
165 | QString ColorProcessor::pasteText() {
166 |   bool ok;
167 |   QString text = clip->text();
168 |   text = text.replace("#", "");
169 |   
170 |   int len = text.length();
171 |   if (len!=6 && len!=3) return QString();
172 | 
173 |   text.toInt(&ok, 16);
174 |   if (!ok) return QString();
175 |   
176 |   return text;
177 | }
178 | 


--------------------------------------------------------------------------------
/Widgets/Sliders/RGB/rgbslider.cpp:
--------------------------------------------------------------------------------
  1 | #include "rgbslider.h"
  2 | 
  3 | #include <QPainter>
  4 | #include <QDebug>
  5 | #include <QtCore>
  6 | 
  7 | 
  8 | // ---------------------------------------------- consts ----------------------------------------------
  9 | 
 10 | const int maxRGB = 255;
 11 | 
 12 | 
 13 | // ----------------------------------------------------------------------------------------------------
 14 | 
 15 | RGBSlider::RGBSlider(QWidget *parent) : ColorSlider(parent)
 16 | {
 17 |   sliderType = Red;
 18 |   
 19 |   r = maxF;
 20 |   g = 0;
 21 |   b = 0;
 22 |   
 23 |   color.setRgbF(r, g, b);
 24 | }
 25 | 
 26 | void RGBSlider::paintEvent(QPaintEvent *e)
 27 | {
 28 |   QPainter p(this);
 29 |   p.setRenderHint(QPainter::Antialiasing);
 30 |   
 31 |   qreal val;
 32 |   switch (sliderType) {
 33 |     case Red:
 34 |       val = r;
 35 |       break;
 36 |     case Green:
 37 |       val = g;
 38 |       break;
 39 |     case Blue:
 40 |       val = b;
 41 |       break;
 42 |   }
 43 |   calcVars(val);
 44 | 
 45 |   if (!sliderDrawn || widthChanged) {
 46 |     paintComponent();
 47 |   }
 48 |   p.drawPixmap(sliderX, sliderY, sliderPixmap);
 49 | 
 50 |   drawPointer(p);
 51 |   drawBorder(p);
 52 | }
 53 | 
 54 | void RGBSlider::paintComponent() {
 55 |   sliderPixmap = QPixmap(sliderW, sliderH);
 56 |   QPainter tempP( &sliderPixmap );
 57 | 
 58 |   QPointF p1( sliderX, sliderH/2 );
 59 |   QPointF p2( sliderX+sliderW, sliderH/2 );
 60 |   QLinearGradient grad(p1, p2);
 61 |   
 62 |   switch (sliderType) {
 63 |     case Red:
 64 |       paintRed(grad);
 65 |       break;
 66 |     case Green:
 67 |       paintGreen(grad);
 68 |       break;
 69 |     case Blue:
 70 |       paintBlue(grad);
 71 |       break;
 72 |   }
 73 |   
 74 |   tempP.setPen(Qt::NoPen);
 75 |   tempP.setBrush( QBrush(grad) );
 76 |   tempP.drawRect(0, 0, sliderW, sliderH);
 77 | 
 78 |   sliderDrawn = true;
 79 |   widthChanged = false;
 80 | }
 81 | 
 82 | void RGBSlider::paintRed(QLinearGradient &grad) {
 83 |   grad.setColorAt( 0, QColor::fromRgbF(0, g, b) );
 84 |   grad.setColorAt( 1, QColor::fromRgbF(1, g, b) );
 85 | }
 86 | 
 87 | void RGBSlider::paintGreen(QLinearGradient &grad) {
 88 |   grad.setColorAt( 0, QColor::fromRgbF(r, 0, b) );
 89 |   grad.setColorAt( 1, QColor::fromRgbF(r, 1, b) );
 90 | }
 91 | 
 92 | void RGBSlider::paintBlue(QLinearGradient &grad) {
 93 |   grad.setColorAt( 0, QColor::fromRgbF(r, g, 0) );
 94 |   grad.setColorAt( 1, QColor::fromRgbF(r, g, 1) );
 95 | }
 96 | 
 97 | void RGBSlider::updateColor() {
 98 |   ColorSlider::updateColor();
 99 | 
100 |   qreal val;
101 |   val = normalizeVal( sliderVal );
102 |   val = qMax(0.0, val);
103 |   val = qMin(maxF, val);
104 |   
105 |   switch (sliderType) {
106 |     case Red:
107 |       r = val;
108 |       color.setRgbF(r, g, b);
109 |       emit redChanged(color);
110 |       break;
111 |     case Green:
112 |       g = val;
113 |       color.setRgbF(r, g, b);
114 |       emit greenChanged(color);
115 |       break;
116 |     case Blue:
117 |       b = val;
118 |       color.setRgbF(r, g, b);
119 |       emit blueChanged(color);
120 |       break;
121 |   }
122 | }
123 | 
124 | // ---------------------------------------------- set/get ----------------------------------------------
125 | 
126 | void RGBSlider::setColorComponent(QColor color, SliderType stype) {
127 |   if (this->color == color) {
128 |     return;
129 |   }
130 |   
131 |   qreal val;
132 |   switch (stype) {
133 |     case Red:
134 |       r = color.redF();
135 |       val = r;
136 |       break;
137 |     case Green:
138 |       g = color.greenF();
139 |       val = g;
140 |       break;
141 |     case Blue:
142 |       b = color.blueF();
143 |       val = b;
144 |       break;
145 |   }
146 |   
147 |   sliderVal = qCeil( val * maxRange );
148 |   this->color = QColor::fromRgbF(r, g, b);
149 |   update();
150 | }
151 | 
152 | void RGBSlider::setR(QColor color) {
153 |   setColorComponent(color, Red);
154 | }
155 | 
156 | void RGBSlider::setG(QColor color) {
157 |   setColorComponent(color, Green);
158 | }
159 | 
160 | void RGBSlider::setB(QColor color) {
161 |   setColorComponent(color, Blue);
162 | }
163 | 
164 | // ---------------------------------------------- slots ----------------------------------------------
165 | 
166 | void RGBSlider::updateSlider() {
167 |   this->color = QColor::fromRgbF(r, g, b);
168 |   sliderDrawn = false;
169 |   update();
170 | }
171 | 
172 | void RGBSlider::changeRed(QColor color) {
173 |   r = color.redF();
174 |   updateSlider();
175 | }
176 | 
177 | void RGBSlider::changeGreen(QColor color) {
178 |   g = color.greenF();
179 |   updateSlider();
180 | }
181 | 
182 | void RGBSlider::changeBlue(QColor color) {
183 |   b = color.blueF();
184 |   updateSlider();
185 | }
186 | 
187 | // ---------------------------------------------- service ----------------------------------------------
188 | 
189 | void RGBSlider::init() {
190 |   if (sliderType == Red) {
191 |     sliderVal = maxRGB;
192 |   }
193 | }
194 | 
195 | void RGBSlider::setType(SliderType type) {
196 |   sliderType = type;
197 | }
198 | 


--------------------------------------------------------------------------------
/Widgets/Sliders/HSV/hsvslider.cpp:
--------------------------------------------------------------------------------
  1 | #include "hsvslider.h"
  2 | 
  3 | #include <QPainter>
  4 | #include <QDebug>
  5 | #include <QtCore>
  6 | 
  7 | 
  8 | // ---------------------------------------------- consts ----------------------------------------------
  9 | 
 10 | const int maxH = 360;
 11 | const int maxSV = 255;
 12 | const qreal ratio = 1.0/maxH;
 13 | 
 14 | 
 15 | // ----------------------------------------------------------------------------------------------------
 16 | 
 17 | HSVSlider::HSVSlider(QWidget *parent) : ColorSlider(parent)
 18 | {
 19 |   sliderType = Hue;
 20 | 
 21 |   h = 0;
 22 |   s = maxF;
 23 |   v = maxF;
 24 | 
 25 |   color.setHsvF(h, s, v);
 26 | }
 27 | 
 28 | void HSVSlider::paintEvent(QPaintEvent *e)
 29 | {
 30 |   QPainter p(this);
 31 |   p.setRenderHint(QPainter::Antialiasing);
 32 |   
 33 |   qreal val;
 34 |   switch (sliderType) {
 35 |     case Hue:
 36 |       val = h;
 37 |       break;
 38 |     case Saturation:
 39 |       val = s;
 40 |       break;
 41 |     case Value:
 42 |       val = v;
 43 |       break;
 44 |   }
 45 |   calcVars(val);
 46 | 
 47 |   if (!sliderDrawn || widthChanged) {
 48 |     paintComponent();
 49 |   }
 50 |   p.drawPixmap(sliderX, sliderY, sliderPixmap);
 51 | 
 52 |   drawPointer(p);
 53 |   drawBorder(p);
 54 | }
 55 | 
 56 | void HSVSlider::paintComponent() {
 57 |   sliderPixmap = QPixmap(sliderW, sliderH);
 58 |   QPainter tempP( &sliderPixmap );
 59 | 
 60 |   QPointF p1( sliderX, 0 );
 61 |   QPointF p2( sliderX+sliderW, 0 );
 62 |   
 63 |   QLinearGradient grad(p1, p2);
 64 |   
 65 |   switch (sliderType) {
 66 |     case Hue:
 67 |       paintHue(grad);
 68 |       break;
 69 |     case Saturation:
 70 |       paintSaturation(grad);
 71 |       break;
 72 |     case Value:
 73 |       paintValue(grad);
 74 |       break;
 75 |   }
 76 |   
 77 |   tempP.setPen(Qt::NoPen);
 78 |   tempP.setBrush( QBrush(grad) );
 79 |   tempP.drawRect(0, 0, sliderW, sliderH);
 80 | 
 81 |   sliderDrawn = true;
 82 |   widthChanged = false;
 83 | }
 84 | 
 85 | void HSVSlider::paintHue(QLinearGradient &grad) {
 86 |   QColor color;
 87 |   for (qreal hs = 0; hs<1.0; hs+=ratio) {
 88 |     color.setHsvF(hs, s, v);
 89 |     grad.setColorAt(hs, color);
 90 |   }
 91 | }
 92 | 
 93 | void HSVSlider::paintSaturation(QLinearGradient &grad) {
 94 |   grad.setColorAt( 0, QColor::fromHsvF(h, 0, v) );
 95 |   grad.setColorAt( 1, QColor::fromHsvF(h, 1, v) );
 96 | }
 97 | 
 98 | void HSVSlider::paintValue(QLinearGradient &grad) {
 99 |   grad.setColorAt( 0, QColor::fromHsvF(h, s, 0) );
100 |   grad.setColorAt( 1, QColor::fromHsvF(h, s, 1) );
101 | }
102 | 
103 | void HSVSlider::updateColor() {
104 |   ColorSlider::updateColor();
105 | 
106 |   qreal val;
107 | 
108 |   val = normalizeVal( sliderVal );
109 |   val = qMax(0.0, val);
110 |   val = qMin(maxF, val);
111 |   
112 |   switch (sliderType) {
113 |     case Hue:
114 |       h = val;
115 |       color.setHsvF(h, s, v);
116 |       emit hueChanged(color);
117 |       break;
118 |     case Saturation:
119 |       s = val;
120 |       color.setHsvF(h, s, v);
121 |       emit saturationChanged(color);
122 |       break;
123 |     case Value:
124 |       v = val;
125 |       color.setHsvF(h, s, v);
126 |       emit valueChanged(color);
127 |       break;
128 |   }
129 | }
130 | 
131 | // ---------------------------------------------- set/get ----------------------------------------------
132 | 
133 | void HSVSlider::setColorComponent(QColor color, SliderType stype) {
134 |   if (this->color == color) {
135 |     return;
136 |   }
137 |   
138 |   qreal val;
139 |   switch (stype) {
140 |     case Hue:
141 |       h = color.hueF();
142 |       val = h;
143 |       break;
144 |     case Saturation:
145 |       s = color.saturationF();
146 |       val = s;
147 |       break;
148 |     case Value:
149 |       v = color.valueF();
150 |       val = v;
151 |       break;
152 |   }
153 |   
154 |   sliderVal = qCeil( val * maxRange );
155 |   this->color = QColor::fromHsvF(h, s, v);
156 |   update();
157 | }
158 | 
159 | void HSVSlider::setH(QColor color) {
160 |   setColorComponent(color, Hue);
161 | }
162 | 
163 | void HSVSlider::setS(QColor color) {
164 |   setColorComponent(color, Saturation);
165 | }
166 | 
167 | void HSVSlider::setV(QColor color) {
168 |   setColorComponent(color, Value);
169 | }
170 | 
171 | // ---------------------------------------------- slots ----------------------------------------------
172 | 
173 | void HSVSlider::updateSlider() {
174 |   this->color = QColor::fromHsvF(h, s, v);
175 |   sliderDrawn = false;
176 |   update();
177 | }
178 |   
179 | void HSVSlider::changeHue(QColor color) {
180 |   h = color.hueF();
181 |   updateSlider();
182 | }
183 | 
184 | void HSVSlider::changeSaturation(QColor color) {
185 |   s = color.saturationF();
186 |   updateSlider();
187 | }
188 | 
189 | void HSVSlider::changeValue(QColor color) {
190 |   v = color.valueF();
191 |   updateSlider();
192 | }
193 | 
194 | // ---------------------------------------------- service ----------------------------------------------
195 | 
196 | void HSVSlider::init() {
197 |   if (sliderType == Saturation || sliderType == Value) {
198 |     sliderVal = maxSV;
199 |   }
200 | }
201 | 
202 | void HSVSlider::setType(SliderType type) {
203 |   sliderType = type;
204 | }
205 | 


--------------------------------------------------------------------------------
/Widgets/Sliders/colorslider.cpp:
--------------------------------------------------------------------------------
  1 | #include "colorslider.h"
  2 | 
  3 | #include <QPainter>
  4 | #include <QDebug>
  5 | #include <QMouseEvent>
  6 | #include <QLinearGradient>
  7 | 
  8 | #include <QtCore>
  9 | 
 10 | #include "Service/services.h"
 11 | 
 12 | 
 13 | // --------------------------------------------- consts ---------------------------------------------
 14 | 
 15 | const int border = 2;
 16 | const int borderRadius = 10;
 17 | 
 18 | const int sliderX = border;
 19 | const int sliderY = border;
 20 | 
 21 | const int pointerR = 5;
 22 | const int pointerBorder = 2;
 23 | 
 24 | const QColor borderColor(80,80,80,200);
 25 | 
 26 | const QColor pointerColor("#333");
 27 | const QColor pointerLineColor(80,80,80,200);
 28 | const QColor pointerBorderColor("#ddd");
 29 | const QColor pointerFillColor("#333");
 30 | 
 31 | 
 32 | // ----------------------------------------------------------------------------------------------------
 33 | 
 34 | ColorSlider::ColorSlider(QWidget *parent) :
 35 |   QWidget(parent)
 36 | {
 37 |   sliderDrawn = false;
 38 |   middlePresed = false;
 39 |   ctrlHeld = false;
 40 |   widthChanged = false;
 41 |   
 42 |   pointerX = 0;
 43 |   pointerY = 0;
 44 |   
 45 |   sliderVal = 0;
 46 | }
 47 | 
 48 | void ColorSlider::mousePressEvent(QMouseEvent *e)
 49 | {
 50 |   if ( e->button() == Qt::MiddleButton ) {
 51 |     middlePresed = true;
 52 |     e->ignore();
 53 |   }
 54 |   else {
 55 |     middlePresed = false;
 56 |     movePointer( e->x() );
 57 |     updateColor();
 58 |   }
 59 | }
 60 | 
 61 | void ColorSlider::mouseMoveEvent(QMouseEvent *e)
 62 | {
 63 |   if (middlePresed) {
 64 |     e->ignore();
 65 |   }
 66 |   else {
 67 |     movePointer( e->x() );
 68 |     updateColor();
 69 |   }
 70 | }
 71 | 
 72 | void ColorSlider::mouseReleaseEvent(QMouseEvent *e)
 73 | {
 74 |   e->ignore();
 75 | }
 76 | 
 77 | void ColorSlider::wheelEvent(QWheelEvent *e)
 78 | {
 79 |   QPoint p = e->angleDelta();
 80 |   
 81 |   int val = 1;
 82 |   if (ctrlHeld) val = 10;
 83 |   
 84 |   if (p.y()>0) incPointer(val);
 85 |   if (p.y()<0) decPointer(val);
 86 | 
 87 |   updateColor();
 88 |   e->accept();
 89 | }
 90 | 
 91 | 
 92 | // ---------------------------------------------- service ----------------------------------------------
 93 | 
 94 | void ColorSlider::calcVars(qreal val) {
 95 |   sliderX = border;
 96 |   sliderY = border;
 97 |   sliderW = width()-2*border;
 98 |   sliderH = height()-2*border;
 99 | 
100 |   maxRange = sliderW - 1;
101 |   minPointerX = sliderX;
102 |   maxPointerX = minPointerX + maxRange;
103 |   
104 |   if (sliderW!=prevSliderW) {
105 |     widthChanged = true;
106 |     sliderVal = normalizePointerX(val);
107 |   }
108 |   prevSliderW = sliderW;
109 | }
110 | 
111 | 
112 | void ColorSlider::movePointer(int x) {
113 |   pointerX = x;
114 |   update();
115 | }
116 | 
117 | void ColorSlider::correctPointer() {
118 |   pointerX = sliderVal + minPointerX;
119 |   pointerX = qMax( minPointerX, pointerX );
120 |   pointerX = qMin( maxPointerX, pointerX );
121 | }
122 | 
123 | void ColorSlider::incPointer(int val) {
124 |   movePointer(pointerX+val);
125 | }
126 | 
127 | void ColorSlider::decPointer(int val) {
128 |   movePointer(pointerX-val);
129 | }
130 | 
131 | 
132 | void ColorSlider::drawPointer(QPainter& p) {
133 |   correctPointer();
134 | 
135 |   pointerY = height()/2;
136 | 
137 |   QPen pen(pointerBorderColor, pointerBorder);
138 |   p.setPen(pen);
139 |   p.setBrush(pointerFillColor);
140 |   p.drawEllipse( QPoint(pointerX, pointerY), pointerR, pointerR );
141 | 
142 |   pen.setColor(pointerLineColor);
143 |   pen.setCapStyle(Qt::FlatCap);
144 |   p.setPen(pen);
145 | 
146 |   p.drawLine( QPoint(pointerX, sliderY), QPoint(pointerX, pointerY-pointerR-pointerBorder/2) );
147 |   p.drawLine( QPoint(pointerX, sliderY+sliderH), QPoint(pointerX, pointerY+pointerR+pointerBorder/2) );
148 | }
149 | 
150 | void ColorSlider::drawBorder(QPainter& p) {
151 |   QRectF rectangle( sliderX, sliderY, sliderW, sliderH );                               // set inner rect coordinates (the border will be outer)
152 |   Services::drawRoundRect( p, rectangle, border, borderRadius, borderColor );
153 | }
154 | 
155 | 
156 | void ColorSlider::updateColor() {
157 |   sliderVal = pointerX - minPointerX;
158 |   sliderVal = qMax(0, sliderVal);
159 |   sliderVal = qMin(maxRange, sliderVal);
160 | }
161 | 
162 | 
163 | // ---------------------------------------------- correction ----------------------------------------------
164 | 
165 | qreal ColorSlider::normalizeVal(int val) {
166 |   qreal h = (qreal)val/maxRange;
167 |   return h;
168 | }
169 | 
170 | int ColorSlider::normalizePointerX(qreal val) {
171 |   qreal d = val*maxRange;
172 |   return qCeil(d);
173 | }
174 | 
175 | 
176 | // ---------------------------------------------- slots ----------------------------------------------
177 | 
178 | void ColorSlider::ctrlPressed() {
179 |   ctrlHeld = true;
180 | }
181 | void ColorSlider::ctrlReleased() {
182 |   ctrlHeld = false;
183 | }
184 | 
185 | 
186 | // ---------------------------------------------- other ----------------------------------------------
187 | 
188 | void ColorSlider::updatePaint() {
189 |   update();
190 | }
191 | 
192 | void ColorSlider::log(QString format, int var) {
193 |  qDebug() << QString(format).arg(var);
194 | }
195 | 
196 | void ColorSlider::log(QString format, qreal var) {
197 |  qDebug() << QString(format).arg(var);
198 | }
199 | 


--------------------------------------------------------------------------------
/Widgets/ColorWidgets/svselector.cpp:
--------------------------------------------------------------------------------
  1 | #include "svselector.h"
  2 | 
  3 | #include <QPainter>
  4 | #include <QDebug>
  5 | #include <QMouseEvent>
  6 | 
  7 | #include "Service/services.h"
  8 | 
  9 | 
 10 | // ----------------------------------------------------------------------------------------------------
 11 | 
 12 | SVSelector::SVSelector(QWidget *parent) : ColorWidget(parent)
 13 | {
 14 |   pointerX = maxSV;
 15 | }
 16 | 
 17 | void SVSelector::paintEvent(QPaintEvent *event)
 18 | {
 19 |   QColor color;
 20 |   
 21 |   QPainter p(this);
 22 |   p.setRenderHint(QPainter::Antialiasing);
 23 | 
 24 |   if (!selectorDrawn) {
 25 |     hueLayerImage = QImage(maxSV+1, maxSV+1, QImage::Format_RGB32);
 26 |     for (int s = 0; s <= maxSV; s++) {
 27 |       for (int v = 0; v <= maxSV; v++) {
 28 |         color.setHsv(h, s, v);
 29 |         hueLayerImage.setPixel(s, maxSV-v, color.rgb());
 30 |       }
 31 |     }
 32 |     
 33 |     selectorDrawn = true;
 34 |   }
 35 |   p.drawImage(border, border, hueLayerImage);
 36 |   
 37 |   drawPointer(p);
 38 |   drawBorder(p);
 39 | }
 40 | 
 41 | void SVSelector::mousePressEvent(QMouseEvent *e)
 42 | {
 43 |   if ( e->button() == Qt::MiddleButton ) {
 44 |     middlePresed = true;
 45 |     e->ignore();
 46 |   }
 47 |   else {
 48 |     middlePresed = false;
 49 |     hideCursor(e);
 50 |     movePointer( e->x(), e->y() );
 51 |     updateColor();
 52 |   }
 53 | }
 54 | 
 55 | void SVSelector::mouseMoveEvent(QMouseEvent *e)
 56 | {
 57 |   if (middlePresed) {
 58 |     e->ignore();
 59 |   }
 60 |   else {
 61 |     hideCursor(e);
 62 |     movePointer( e->x(), e->y() );
 63 |     updateColor();
 64 |   }
 65 | }
 66 | 
 67 | void SVSelector::mouseReleaseEvent(QMouseEvent *e)
 68 | {
 69 |   restoreCursor();
 70 |   e->ignore();
 71 | }
 72 | 
 73 | void SVSelector::wheelEvent(QWheelEvent *e)
 74 | {
 75 |   QPoint p = e->angleDelta();
 76 |   int y = p.y();
 77 |   
 78 |   int val = 1;
 79 |   if (ctrlHeld) val = 10;
 80 | 
 81 |   if (shiftHeld) {
 82 |     if (y>0) incPointerX(val);
 83 |     if (y<0) decPointerX(val);
 84 |   }
 85 |   else {
 86 |     if (y<0) incPointerY(val);
 87 |     if (y>0) decPointerY(val);
 88 |   }
 89 | 
 90 |   updateColor();
 91 |   e->accept();
 92 | }
 93 | 
 94 | 
 95 | // ---------------------------------------------- service ----------------------------------------------
 96 | 
 97 | void SVSelector::drawPointer(QPainter& p) {
 98 |   correctPointer();
 99 |   drawCircle(p);
100 | }
101 | 
102 | void SVSelector::incPointerX(int val) {
103 |   movePointer(pointerX+val, pointerY);
104 | }
105 | 
106 | void SVSelector::decPointerX(int val) {
107 |   movePointer(pointerX-val, pointerY);
108 | }
109 | 
110 | void SVSelector::incPointerY(int val) {
111 |   movePointer(pointerX, pointerY+val);
112 | }
113 | 
114 | void SVSelector::decPointerY(int val) {
115 |   movePointer(pointerX, pointerY-val);
116 | }
117 | 
118 | void SVSelector::correctPointer() {
119 |   pointerX = s + minPointerXY;              // to update pointer XY on text edit
120 |   pointerY = maxPointerXY - v;
121 |   
122 |   pointerX = qMax( minPointerXY, pointerX );
123 |   pointerX = qMin( maxPointerXY, pointerX );
124 |   
125 |   pointerY = qMax( minPointerXY, pointerY );
126 |   pointerY = qMin( maxPointerXY, pointerY );
127 | }
128 | 
129 | void SVSelector::movePointer(int x, int y) {
130 |   pointerX = x;
131 |   pointerY = y;
132 | 
133 |   update();                     // if pointer doesn't move, move update() to both mousePress() and mouseMove() events
134 | //  repaint();                  // on repaint() here it doesn't move (it repaints before the correction)
135 | }
136 | 
137 | void SVSelector::drawBorder(QPainter& p) {
138 |   QRectF rectangle( selectorX, selectorY, selectorSize, selectorSize );
139 |   Services::drawRoundRect( p, rectangle, border, borderRadius, borderColor );
140 | }
141 | 
142 | void SVSelector::updateColor() {
143 |   s = pointerX - border;
144 |   v = maxSV - (pointerY - border);
145 | 
146 |   s = qMax(0, s);             // s = qMin( maxSV, qMax(0, s) );
147 |   s = qMin(maxSV, s);
148 | 
149 |   v = qMax(0, v);
150 |   v = qMin(maxSV, v);
151 | 
152 |   color.setHsv(h, s, v);
153 |   
154 |   emit colorChanged(color);
155 |   emit saturationChanged(color);
156 |   emit valueChanged(color);
157 | }
158 | 
159 | void SVSelector::reupdateColor()
160 | {
161 |   emit saturationChanged(color);
162 |   emit valueChanged(color);
163 | }
164 | 
165 | // ---------------------------------------------- slots ----------------------------------------------
166 | 
167 | void SVSelector::changeHue(QColor color)
168 | {
169 |   selectorDrawn = false;
170 |   
171 |   h = color.hue();
172 |   correctPointer();
173 |   
174 |   QColor newColor;
175 |   newColor.setHsv(h, s, v);
176 |   emit colorChanged(newColor);
177 | 
178 |   update();
179 |   // repaint();
180 | }
181 | 
182 | // ---------------------------------------------- set/get ----------------------------------------------
183 | 
184 | void SVSelector::setS(QColor color)
185 | {
186 |   s = color.saturation();
187 |   
188 |   correctPointer();
189 |   update();
190 | 
191 |   updateColor();
192 | }
193 | 
194 | void SVSelector::setV(QColor color)
195 | {
196 |   v = color.value();
197 |   
198 |   correctPointer();
199 |   update();
200 | 
201 |   updateColor();
202 | }
203 | 
204 | void SVSelector::setSV(int s, int v) {
205 |   this->s = s;
206 |   this->v = v;
207 |   
208 |   correctPointer();
209 |   update();
210 | 
211 |   updateColor();
212 | }
213 | 


--------------------------------------------------------------------------------
/Widgets/Sliders/CMYK/cmykslider.cpp:
--------------------------------------------------------------------------------
  1 | #include "cmykslider.h"
  2 | 
  3 | #include <QPainter>
  4 | #include <QDebug>
  5 | #include <QtCore>
  6 | 
  7 | 
  8 | // ---------------------------------------------- consts ----------------------------------------------
  9 | 
 10 | const int maxCMYK = 255;
 11 | 
 12 | 
 13 | // ----------------------------------------------------------------------------------------------------
 14 | 
 15 | CMYKSlider::CMYKSlider(QWidget *parent) : ColorSlider(parent)
 16 | {
 17 |   sliderType = Cyan;
 18 |   
 19 |   c = 0;
 20 |   m = maxF;
 21 |   y = maxF;
 22 |   k = 0;
 23 |   
 24 |   color.setCmykF(c, m, y, k);
 25 | }
 26 | 
 27 | void CMYKSlider::paintEvent(QPaintEvent *e)
 28 | {
 29 |   QPainter p(this);
 30 |   p.setRenderHint(QPainter::Antialiasing);
 31 |   
 32 |   qreal val;
 33 |   switch (sliderType) {
 34 |     case Cyan:
 35 |       val = c;
 36 |       break;
 37 |     case Magenta:
 38 |       val = m;
 39 |       break;
 40 |     case Yellow:
 41 |       val = y;
 42 |       break;
 43 |     case Black:
 44 |       val = k;
 45 |       break;
 46 |   }
 47 |   calcVars(val);
 48 | 
 49 |   if (!sliderDrawn || widthChanged) {
 50 |     paintComponent();
 51 |   }
 52 |   p.drawPixmap(sliderX, sliderY, sliderPixmap);
 53 | 
 54 |   drawPointer(p);
 55 |   drawBorder(p);
 56 | }
 57 | 
 58 | void CMYKSlider::paintComponent() {
 59 |   sliderPixmap = QPixmap(sliderW, sliderH);
 60 |   QPainter tempP( &sliderPixmap );
 61 | 
 62 |   QPointF p1( sliderX, sliderH/2 );
 63 |   QPointF p2( sliderX+sliderW, sliderH/2 );
 64 |   QLinearGradient grad(p1, p2);
 65 |   
 66 |   switch (sliderType) {
 67 |     case Cyan:
 68 |       paintCyan(grad);
 69 |       break;
 70 |     case Magenta:
 71 |       paintMagenta(grad);
 72 |       break;
 73 |     case Yellow:
 74 |       paintYellow(grad);
 75 |       break;
 76 |     case Black:
 77 |       paintBlack(grad);
 78 |       break;
 79 |   }
 80 |   
 81 |   tempP.setPen(Qt::NoPen);
 82 |   tempP.setBrush( QBrush(grad) );
 83 |   tempP.drawRect(0, 0, sliderW, sliderH);
 84 | 
 85 |   sliderDrawn = true;
 86 |   widthChanged = false;
 87 | }
 88 | 
 89 | void CMYKSlider::paintCyan(QLinearGradient &grad) {
 90 |   grad.setColorAt( 0, QColor::fromCmykF(0, m, y, k) );
 91 |   grad.setColorAt( 1, QColor::fromCmykF(1, m, y, k) );
 92 | }
 93 | 
 94 | void CMYKSlider::paintMagenta(QLinearGradient &grad) {
 95 |   grad.setColorAt( 0, QColor::fromCmykF(c, 0, y, k) );
 96 |   grad.setColorAt( 1, QColor::fromCmykF(c, 1, y, k) );
 97 | }
 98 | 
 99 | void CMYKSlider::paintYellow(QLinearGradient &grad) {
100 |   grad.setColorAt( 0, QColor::fromCmykF(c, m, 0, k) );
101 |   grad.setColorAt( 1, QColor::fromCmykF(c, m, 1, k) );
102 | }
103 | 
104 | void CMYKSlider::paintBlack(QLinearGradient &grad) {
105 |   grad.setColorAt( 0, QColor::fromCmykF(c, m, y, 0) );
106 |   grad.setColorAt( 1, QColor::fromCmykF(c, m, y, 1) );
107 | }
108 | 
109 | 
110 | void CMYKSlider::updateColor() {
111 |   ColorSlider::updateColor();
112 | 
113 |   qreal val;
114 |   val = normalizeVal( sliderVal );
115 |   val = qMax(0.0, val);
116 |   val = qMin(maxF, val);
117 |   
118 |   switch (sliderType) {
119 |     case Cyan:
120 |       c = val;
121 |       color.setCmykF(c, m, y, k);
122 |       emit cyanChanged(color);
123 |       break;
124 |     case Magenta:
125 |       m = val;
126 |       color.setCmykF(c, m, y, k);
127 |       emit magentaChanged(color);
128 |       break;
129 |     case Yellow:
130 |       y = val;
131 |       color.setCmykF(c, m, y, k);
132 |       emit yellowChanged(color);
133 |       break;
134 |     case Black:
135 |       k = val;
136 |       color.setCmykF(c, m, y, k);
137 |       emit blackChanged(color);
138 |       break;
139 |   }
140 | }
141 | 
142 | // ---------------------------------------------- set/get ----------------------------------------------
143 | 
144 | void CMYKSlider::setColorComponent(QColor color, SliderType stype) {
145 |   if (this->color == color) {
146 |     return;
147 |   }
148 |   
149 |   qreal val;
150 |   switch (stype) {
151 |     case Cyan:
152 |       c = color.cyanF();
153 |       val = c;
154 |       break;
155 |     case Magenta:
156 |       m = color.magentaF();
157 |       val = m;
158 |       break;
159 |     case Yellow:
160 |       y = color.yellowF();
161 |       val = y;
162 |       break;
163 |     case Black:
164 |       k = color.blackF();
165 |       val = k;
166 |       break;
167 |   }
168 |   
169 |   sliderVal = qCeil( val * maxRange );
170 |   this->color = QColor::fromCmykF(c, m, y, k);
171 |   update();
172 | }
173 | 
174 | void CMYKSlider::setC(QColor color) {
175 |   setColorComponent(color, Cyan);
176 | }
177 | 
178 | void CMYKSlider::setM(QColor color) {
179 |   setColorComponent(color, Magenta);
180 | }
181 | 
182 | void CMYKSlider::setY(QColor color) {
183 |   setColorComponent(color, Yellow);
184 | }
185 | 
186 | void CMYKSlider::setK(QColor color) {
187 |   setColorComponent(color, Black);
188 | }
189 | 
190 | // ---------------------------------------------- slots ----------------------------------------------
191 | 
192 | void CMYKSlider::updateSlider() {
193 |   this->color = QColor::fromCmykF(c, m, y, k);
194 |   sliderDrawn = false;
195 |   update();
196 | }
197 | 
198 | void CMYKSlider::changeCyan(QColor color) {
199 |   c = color.cyanF();
200 |   updateSlider();
201 | }
202 | 
203 | void CMYKSlider::changeMagenta(QColor color) {
204 |   m = color.magentaF();
205 |   updateSlider();
206 | }
207 | 
208 | void CMYKSlider::changeYellow(QColor color) {
209 |   y = color.yellowF();
210 |   updateSlider();
211 | }
212 | 
213 | void CMYKSlider::changeBlack(QColor color) {
214 |   k = color.blackF();
215 |   updateSlider();
216 | }
217 | 
218 | // ---------------------------------------------- service ----------------------------------------------
219 | 
220 | void CMYKSlider::init() {
221 |   if (sliderType == Magenta || sliderType == Yellow) {
222 |     sliderVal = maxCMYK;
223 |   }
224 | }
225 | 
226 | void CMYKSlider::setType(SliderType type) {
227 |   sliderType = type;
228 | }
229 | 


--------------------------------------------------------------------------------
/Service/validator.cpp:
--------------------------------------------------------------------------------
  1 | #include "validator.h"
  2 | 
  3 | #include <QtCore>
  4 | 
  5 | 
  6 | // -------------------------------------------- consts --------------------------------------------
  7 | 
  8 | const int maxH = 359;
  9 | const int maxS = 255;
 10 | const int maxV = 255;
 11 | 
 12 | const int maxRGB = 255;
 13 | const int maxCMYK = 255;
 14 | 
 15 | const int maxHex = 255;
 16 | const int maxShortHex = 15;
 17 | 
 18 | // ----------------------------------------------------------------------------------------------------
 19 | 
 20 | Validator::Validator(QObject *parent) :
 21 |   QObject(parent)
 22 | {
 23 | }
 24 | 
 25 | bool Validator::checkColorText(QString text, Vars::ColorType colorType) {
 26 |   int size = getSizeByType(colorType);
 27 |   
 28 |   QStringList list;
 29 |   list = text.split(" ");
 30 |   if (list.size()!=size) return false;
 31 | 
 32 |   foreach(QString comp, list) {
 33 |     if (!comp.length())
 34 |       return false;
 35 |   }
 36 | 
 37 |   foreach(QString comp, list) {
 38 |     bool ok;
 39 |     comp.toInt(&ok);
 40 |     if (!ok) return false;
 41 |   }
 42 | 
 43 |   return true;
 44 | }
 45 | 
 46 | bool Validator::checkValueByType(QString text, Vars::ColorType colorType) {
 47 |   switch (colorType) {
 48 |     case Vars::HSV:
 49 |       return checkValueHSV(text);
 50 |     case Vars::RGB:
 51 |       return checkValueRGB(text);
 52 |     case Vars::CMYK:
 53 |       return checkValueCMYK(text);
 54 |     case Vars::Hex:
 55 |       return checkValueHex(text);
 56 |   }
 57 |   return false;
 58 | }
 59 | 
 60 | bool Validator::checkValueHSV(QString text) {
 61 |   QStringList list;
 62 |   list = text.split(" ");
 63 | 
 64 |   int h = list[0].toInt();
 65 |   int s = list[1].toInt();
 66 |   int v = list[2].toInt();
 67 | 
 68 |   if (h<0 || h>maxH) return false;
 69 |   if (s<0 || s>maxH) return false;
 70 |   if (v<0 || v>maxH) return false;
 71 | 
 72 |   return true;
 73 | }
 74 | 
 75 | bool Validator::checkValueRGB(QString text) {
 76 |   QStringList list;
 77 |   list = text.split(" ");
 78 | 
 79 |   int r = list[0].toInt();
 80 |   int g = list[1].toInt();
 81 |   int b = list[2].toInt();
 82 | 
 83 |   if (r<0 || r>maxRGB) return false;
 84 |   if (g<0 || g>maxRGB) return false;
 85 |   if (b<0 || b>maxRGB) return false;
 86 | 
 87 |   return true;
 88 | }
 89 | 
 90 | bool Validator::checkValueCMYK(QString text) {
 91 |   QStringList list;
 92 |   list = text.split(" ");
 93 | 
 94 |   int c = list[0].toInt();
 95 |   int m = list[1].toInt();
 96 |   int y = list[2].toInt();
 97 |   int k = list[3].toInt();
 98 | 
 99 |   if (c<0 || c>maxCMYK) return false;
100 |   if (m<0 || m>maxCMYK) return false;
101 |   if (y<0 || y>maxCMYK) return false;
102 |   if (k<0 || k>maxCMYK) return false;
103 | 
104 |   return true;
105 | }
106 | 
107 | bool Validator::checkValueHex(QString text) {
108 |   int len = text.length();
109 |   if ( len!=6 && len!=3 ) return false;
110 |   
111 |   bool ok;
112 |   int factor = len/3;
113 | 
114 |   for (int i = 0; i<3; i++) {
115 |     QString comp = text.mid(i*factor, factor);
116 |     int val = comp.toInt(&ok, 16);
117 |     if (!ok) return false;
118 | 
119 |     if (len == 3) {
120 |       if (val<0 || val>maxShortHex) return false;
121 |     }
122 |     else {
123 |       if (val<0 || val>maxHex) return false;
124 |     }
125 |   }
126 | 
127 |   return true;
128 | }
129 | 
130 | bool Validator::checkComponentVal(int val, Vars::ColorType colorType, int group, int hexLen) {
131 |   if (colorType == Vars::HSV) {
132 |     switch (group) {
133 |     case 0:
134 |       return (val >= 0 && val <= maxH);
135 |     case 1:
136 |       return (val >= 0 && val <= maxS);
137 |     case 2:
138 |       return (val >= 0 && val <= maxV);
139 |     }
140 |   }
141 | 
142 |   if (colorType == Vars::RGB) {
143 |     return (val >= 0 && val <= maxRGB);
144 |   }
145 | 
146 |   if (colorType == Vars::CMYK) {
147 |     switch (group) {
148 |     case 0:
149 |       return (val >= 0 && val <= maxCMYK);
150 |     case 1:
151 |       return (val >= 0 && val <= maxCMYK);
152 |     case 2:
153 |       return (val >= 0 && val <= maxCMYK);
154 |     case 3:
155 |       return (val >= 0 && val <= maxCMYK);
156 |     }
157 |   }
158 | 
159 |   if (colorType == Vars::Hex) {
160 |     if (hexLen == 3)
161 |       return (val >= 0 && val <= maxShortHex);
162 |     else if (hexLen == 6)
163 |       return (val >= 0 && val <= maxHex);
164 |   }
165 | 
166 |   return false;
167 | }
168 | 
169 | 
170 | void Validator::correctHSV(QColor& color) {
171 |   int h = color.hue();
172 |   int s = color.saturation();
173 |   int v = color.value();
174 |   
175 |   h = qMin(maxH, qMax(0, h));
176 |   s = qMin(maxS, qMax(0, s));
177 |   v = qMin(maxV, qMax(0, v));
178 |   
179 |   color.setHsv(h, s, v);
180 | }
181 | 
182 | void Validator::correctRGB(QColor& color) {
183 |   int r = color.red();
184 |   int g = color.green();
185 |   int b = color.blue();
186 |   
187 |   r = qMin(maxRGB, qMax(0, r));
188 |   g = qMin(maxRGB, qMax(0, g));
189 |   b = qMin(maxRGB, qMax(0, b));
190 |   
191 |   color.setRgb(r, g, b);
192 | }
193 | 
194 | void Validator::correctCMYK(QColor& color) {
195 |   int c = color.cyan();
196 |   int m = color.magenta();
197 |   int y = color.yellow();
198 |   int k = color.black();
199 |   
200 |   c = qMin(maxCMYK, qMax(0, c));
201 |   m = qMin(maxCMYK, qMax(0, m));
202 |   y = qMin(maxCMYK, qMax(0, y));
203 |   k = qMin(maxCMYK, qMax(0, k));
204 |   
205 |   color.setCmyk(c, m, y, k);
206 | }
207 | 
208 | 
209 | QString Validator::correctColorText(QString text) {
210 |   if (!text.length()) return text;
211 |   return text.trimmed().replace(",", " ").replace(QRegExp("\\s+"), " ");
212 | }
213 | 
214 | 
215 | // --------------------------------------------- service ---------------------------------------------
216 | 
217 | int Validator::getSizeByType(Vars::ColorType colorType) {
218 |   switch (colorType) {
219 |     case Vars::HSV:
220 |       return 3;
221 |     case Vars::RGB:
222 |       return 3;
223 |     case Vars::CMYK:
224 |       return 4;
225 |     default:
226 |       return 0;
227 |   }
228 | }
229 | 


--------------------------------------------------------------------------------
/Widgets/colortext.cpp:
--------------------------------------------------------------------------------
  1 | #include "colortext.h"
  2 | 
  3 | #include <QDebug>
  4 | 
  5 | #include "Service/validator.h"
  6 | 
  7 | 
  8 | ColorText::ColorText(QWidget *parent) : QLineEdit(parent)
  9 | {
 10 |   colorType = Vars::HSV;
 11 |   separator = " ";
 12 | }
 13 | 
 14 | void ColorText::setType(Vars::ColorType colorType) {
 15 |   this->colorType = colorType;
 16 |   if (colorType == Vars::Hex)
 17 |     separator = "";
 18 | }
 19 | 
 20 | 
 21 | void ColorText::updateText(QString text) {
 22 |   int pos = cursorPosition();
 23 |   setText(text);
 24 |   setCursorPosition(pos);
 25 | }
 26 | 
 27 | 
 28 | 
 29 | // --------------------------------------------- inc/dec component ---------------------------------------------
 30 | 
 31 | void ColorText::changeComponentVal(int pos, bool inc) {
 32 |   int val;
 33 |   int group = -1;
 34 |   bool ok;
 35 |   QStringList comp;
 36 |   QString valText, newValText;
 37 | 
 38 |   QString colorText = text();
 39 | 
 40 |   if (colorType == Vars::Hex) {
 41 |     if ( !Validator::checkValueHex(colorText) ) return;
 42 |     
 43 |     len = colorText.length();
 44 |     comp = getComponentsFromHex(colorText);
 45 |     group = getHexGroup(pos, len);
 46 |     
 47 |     val = comp[group].toInt(&ok, 16);
 48 |     
 49 |     if (inc) val++;
 50 |     else val--;
 51 |     if ( !Validator::checkComponentVal(val, colorType, group, len) ) return;
 52 |     
 53 |     comp[group] = QString("%1").arg( val, len/3, 16, QChar('0'));      
 54 |   }
 55 |   else {
 56 |     if ( !Validator::checkColorText(colorText, colorType) ) return;
 57 |     if ( !Validator::checkValueByType(colorText, colorType) ) return;
 58 |     
 59 |     comp = colorText.split(separator);
 60 |     QRegExp rx(" ");
 61 |     int idx = 0;
 62 | 
 63 |     while ( (idx = rx.indexIn(colorText, idx)) != -1 ) {
 64 |       group++;
 65 |       if (idx >= pos) break;
 66 |       idx+=rx.matchedLength();
 67 |     }
 68 |     if (idx == -1) group = comp.size()-1;
 69 |     if (group == -1) return;
 70 | 
 71 |     valText = comp[group];
 72 |     val = valText.toInt();
 73 | 
 74 |     if (inc) val++;
 75 |     else val--;
 76 |     if ( !Validator::checkComponentVal(val, colorType, group) ) return;
 77 | 
 78 |     newValText = QString::number(val);
 79 | 
 80 |     pos = (idx == -1) ? colorText.length() : idx;
 81 |     if (inc) {
 82 |       if ( newValText.length() > valText.length() ) pos++;
 83 |     }
 84 |     else {
 85 |       if ( newValText.length() < valText.length() ) pos--;
 86 |     }
 87 | 
 88 |     comp[group] = newValText;
 89 |   }
 90 | 
 91 |   colorText = comp.join(separator);
 92 |   setText(colorText);
 93 |   setCursorPosition(pos);
 94 | 
 95 |   textEdited(text());
 96 | }
 97 | 
 98 | 
 99 | // --------------------------------------------- select component ---------------------------------------------
100 | 
101 | void ColorText::selectNextComponent() {
102 |   selectComponent(true);
103 | }
104 | 
105 | void ColorText::selectPrevComponent() {
106 |   selectComponent(false);
107 | }
108 | 
109 | void ColorText::selectComponent(bool next) {
110 |   int gpos = 0, glen;
111 |   int group = -1;
112 |   QStringList comp;
113 | 
114 |   int pos = cursorPosition();
115 |   QString colorText = text();
116 | 
117 |   if (colorType == Vars::Hex) {
118 |     if ( !Validator::checkValueHex(colorText) ) return;
119 |     
120 |     len = colorText.length();
121 |     comp = getComponentsFromHex(colorText);
122 |     group = getHexGroup(pos, len);
123 |     group = getGroupNumber(group, comp.size(), next);
124 |     
125 |     glen = len/3;
126 |     gpos = group*(len/3);
127 |   }
128 |   else {
129 |     if ( !Validator::checkColorText(colorText, colorType) ) return;
130 |     if ( !Validator::checkValueByType(colorText, colorType) ) return;
131 |     
132 |     comp = colorText.split(" ");
133 |     QRegExp rx(" ");
134 |     int idx = 0;
135 | 
136 |     while ( (idx = rx.indexIn(colorText, idx)) != -1 ) {
137 |       group++;
138 |       if (idx >= pos) break;
139 |       idx+=rx.matchedLength();
140 |     }
141 |     if (idx == -1) group = comp.size()-1;
142 |     if (group == -1) return;
143 | 
144 |     group = getGroupNumber(group, comp.size(), next);
145 | 
146 |     glen = comp[group].length();
147 |     for (int i = 0; i<group; i++)
148 |       gpos += comp[i].length();
149 |     gpos+=group;
150 |   }
151 | 
152 |   setSelection(gpos, glen);
153 | }
154 | 
155 | 
156 | // --------------------------------------------- service ---------------------------------------------
157 | 
158 | QStringList ColorText::getComponentsFromHex(QString hex) {
159 |   QStringList list;
160 | 
161 |   int len = hex.length();
162 |   int factor = len/3;
163 | 
164 |   for (int i = 0; i<3; i++)
165 |     list.append( hex.mid(i*factor, factor) );
166 | 
167 |   return list;
168 | }
169 | 
170 | int ColorText::getHexGroup(int pos, int len) {
171 |   int group;
172 | 
173 |   if (len == 3) {
174 |     if ( pos == 0 || pos == 1 ) group = 0;
175 |     if ( pos == 2 ) group = 1;
176 |     if ( pos == 3 ) group = 2;
177 |   }
178 |   else if (len == 6) {
179 |     if ( pos == 0 || pos == 1 || pos == 2 ) group = 0;
180 |     if ( pos == 3 || pos == 4 ) group = 1;
181 |     if ( pos == 5 || pos == 6 ) group = 2;
182 |   }
183 | 
184 |   return group;
185 | }
186 | 
187 | int ColorText::getGroupNumber(int group, int groupLen, bool next) {
188 |   if (next) {
189 |     group++;
190 |     if (group == groupLen) group = 0;
191 |   }
192 |   else {
193 |     group--;
194 |     if (group == -1) group = groupLen-1;
195 |   }
196 | 
197 |   return group;
198 | }
199 | 
200 | 
201 | // --------------------------------------------- events ---------------------------------------------
202 | 
203 | void ColorText::keyPressEvent(QKeyEvent *e)
204 | {
205 |   int key = e->key();
206 |   
207 |   int pos = cursorPosition();
208 |   
209 |   if (key == Qt::Key_Up) {
210 |     changeComponentVal(pos, true);
211 |   }
212 |   else if (key == Qt::Key_Down) {
213 |     changeComponentVal(pos, false);
214 |   }
215 |   else {
216 |     QLineEdit::keyPressEvent(e);
217 |   }
218 | }
219 | 
220 | void ColorText::wheelEvent(QWheelEvent *e) {
221 |   int delta = e->delta();
222 |   int x = e->x();
223 |   int y = e->y();
224 |   
225 |   int pos = cursorPositionAt(QPoint(x, y));
226 |   
227 |   
228 |   changeComponentVal(pos, delta > 0);
229 | 
230 |   // qDebug() << QString("WHEEL: %1, [%2;%3], %4").arg(delta).arg(x).arg(y).arg(pos);
231 |   
232 |   e->accept();
233 | }
234 | 
235 | bool ColorText::event(QEvent *e)
236 | {
237 |   if (e->type() == QEvent::KeyPress) {
238 |     QKeyEvent *ke = static_cast<QKeyEvent *>(e);
239 |     
240 |     if ( ke->key() == Qt::Key_Tab ) {
241 |       if (ke->modifiers() == Qt::ControlModifier) {
242 |         // nextInFocusChain()->setFocus(Qt::TabFocusReason);
243 |         emit focusNextField();
244 |         return true;
245 |       }
246 |       
247 |       selectNextComponent();
248 |       return true;
249 |     }
250 |     else if ( ke->key() == Qt::Key_Backtab ) {
251 |       if (ke->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) {
252 |         // previousInFocusChain()->setFocus(Qt::BacktabFocusReason);
253 |         emit focusPrevField();
254 |         return true;
255 |       }
256 |       
257 |       selectPrevComponent();
258 |       return true;
259 |     }
260 | 
261 |   }
262 | 
263 |   return QLineEdit::event(e);
264 | }
265 | 


--------------------------------------------------------------------------------
/Views/sliderswindow.cpp:
--------------------------------------------------------------------------------
  1 | #include "sliderswindow.h"
  2 | #include "ui_sliderswindow.h"
  3 | 
  4 | #include <QDebug>
  5 | #include <QShortcut>
  6 | 
  7 | 
  8 | SlidersWindow::SlidersWindow(SlidersController *slidersController, QWidget *parent) :
  9 |   QMainWindow(parent),
 10 |   ui(new Ui::SlidersWindow)
 11 | {
 12 |   ui->setupUi(this);
 13 |   
 14 |   this->slidersController = slidersController;
 15 | 
 16 |   addActions();
 17 |   addKeyActions();
 18 |   addShortcuts();
 19 |   init();
 20 | }
 21 | 
 22 | SlidersWindow::~SlidersWindow()
 23 | {
 24 |   delete ui;
 25 | }
 26 | 
 27 | void SlidersWindow::init() {
 28 |   // setAttribute(Qt::WA_DeleteOnClose);
 29 |   
 30 |   ui->hSlider->setType(HSVSlider::Hue);
 31 |   ui->sSlider->setType(HSVSlider::Saturation);
 32 |   ui->vSlider->setType(HSVSlider::Value);
 33 |   
 34 |   ui->sSlider->init();
 35 |   ui->vSlider->init();
 36 |   
 37 |   
 38 |   ui->rSlider->setType(RGBSlider::Red);
 39 |   ui->gSlider->setType(RGBSlider::Green);
 40 |   ui->bSlider->setType(RGBSlider::Blue);
 41 |   
 42 |   ui->rSlider->init();
 43 |   
 44 |   
 45 |   ui->cSlider->setType(CMYKSlider::Cyan);
 46 |   ui->mSlider->setType(CMYKSlider::Magenta);
 47 |   ui->ySlider->setType(CMYKSlider::Yellow);
 48 |   ui->kSlider->setType(CMYKSlider::Black);
 49 |   
 50 |   ui->mSlider->init();
 51 |   ui->ySlider->init();
 52 | }
 53 | 
 54 | void SlidersWindow::addActions() {
 55 |   connect( ui->hSlider, SIGNAL(hueChanged(QColor)), slidersController, SLOT(changeHue(QColor)) );
 56 |   connect( ui->sSlider, SIGNAL(saturationChanged(QColor)), slidersController, SLOT(changeSaturation(QColor)) );
 57 |   connect( ui->vSlider, SIGNAL(valueChanged(QColor)), slidersController, SLOT(changeValue(QColor)) );
 58 |   
 59 |   connect( ui->rSlider, SIGNAL(redChanged(QColor)), slidersController, SLOT(changeRed(QColor)) );
 60 |   connect( ui->gSlider, SIGNAL(greenChanged(QColor)), slidersController, SLOT(changeGreen(QColor)) );
 61 |   connect( ui->bSlider, SIGNAL(blueChanged(QColor)), slidersController, SLOT(changeBlue(QColor)) );
 62 | 
 63 |   connect( ui->cSlider, SIGNAL(cyanChanged(QColor)), slidersController, SLOT(changeCyan(QColor)) );
 64 |   connect( ui->mSlider, SIGNAL(magentaChanged(QColor)), slidersController, SLOT(changeMagenta(QColor)) );
 65 |   connect( ui->ySlider, SIGNAL(yellowChanged(QColor)), slidersController, SLOT(changeYellow(QColor)) );
 66 |   connect( ui->kSlider, SIGNAL(blackChanged(QColor)), slidersController, SLOT(changeBlack(QColor)) );
 67 | 
 68 | 
 69 |   connect( ui->spHue, SIGNAL(valueChanged(int)), slidersController, SLOT(changeHue(int)) );
 70 |   connect( ui->spSaturation, SIGNAL(valueChanged(int)), slidersController, SLOT(changeSaturation(int)) );
 71 |   connect( ui->spValue, SIGNAL(valueChanged(int)), slidersController, SLOT(changeValue(int)) );
 72 |   
 73 |   connect( ui->spRed, SIGNAL(valueChanged(int)), slidersController, SLOT(changeRed(int)) );
 74 |   connect( ui->spGreen, SIGNAL(valueChanged(int)), slidersController, SLOT(changeGreen(int)) );
 75 |   connect( ui->spBlue, SIGNAL(valueChanged(int)), slidersController, SLOT(changeBlue(int)) );
 76 |   
 77 |   connect( ui->spCyan, SIGNAL(valueChanged(int)), slidersController, SLOT(changeCyan(int)) );
 78 |   connect( ui->spMagenta, SIGNAL(valueChanged(int)), slidersController, SLOT(changeMagenta(int)) );
 79 |   connect( ui->spYellow, SIGNAL(valueChanged(int)), slidersController, SLOT(changeYellow(int)) );
 80 |   connect( ui->spBlack, SIGNAL(valueChanged(int)), slidersController, SLOT(changeBlack(int)) );
 81 | }
 82 | 
 83 | void SlidersWindow::addKeyActions() {
 84 |   connect( ui->hSlider, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(sliderMiddlePressed(QMouseEvent*)) );
 85 |   connect( ui->sSlider, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(sliderMiddlePressed(QMouseEvent*)) );
 86 |   connect( ui->vSlider, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(sliderMiddlePressed(QMouseEvent*)) );
 87 |   
 88 |   connect( ui->rSlider, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(sliderMiddlePressed(QMouseEvent*)) );
 89 |   connect( ui->gSlider, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(sliderMiddlePressed(QMouseEvent*)) );
 90 |   connect( ui->bSlider, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(sliderMiddlePressed(QMouseEvent*)) );
 91 | 
 92 |   connect( ui->cSlider, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(sliderMiddlePressed(QMouseEvent*)) );
 93 |   connect( ui->mSlider, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(sliderMiddlePressed(QMouseEvent*)) );
 94 |   connect( ui->ySlider, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(sliderMiddlePressed(QMouseEvent*)) );
 95 |   connect( ui->kSlider, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(sliderMiddlePressed(QMouseEvent*)) );
 96 |   
 97 |   
 98 |   connect( this, SIGNAL(ctrlPressed()), ui->hSlider, SLOT(ctrlPressed()) );
 99 |   connect( this, SIGNAL(ctrlReleased()), ui->hSlider, SLOT(ctrlReleased()) );
100 |   connect( this, SIGNAL(ctrlPressed()), ui->sSlider, SLOT(ctrlPressed()) );
101 |   connect( this, SIGNAL(ctrlReleased()), ui->sSlider, SLOT(ctrlReleased()) );
102 |   connect( this, SIGNAL(ctrlPressed()), ui->vSlider, SLOT(ctrlPressed()) );
103 |   connect( this, SIGNAL(ctrlReleased()), ui->vSlider, SLOT(ctrlReleased()) );
104 |   
105 |   connect( this, SIGNAL(ctrlPressed()), ui->rSlider, SLOT(ctrlPressed()) );
106 |   connect( this, SIGNAL(ctrlReleased()), ui->rSlider, SLOT(ctrlReleased()) );
107 |   connect( this, SIGNAL(ctrlPressed()), ui->gSlider, SLOT(ctrlPressed()) );
108 |   connect( this, SIGNAL(ctrlReleased()), ui->gSlider, SLOT(ctrlReleased()) );
109 |   connect( this, SIGNAL(ctrlPressed()), ui->bSlider, SLOT(ctrlPressed()) );
110 |   connect( this, SIGNAL(ctrlReleased()), ui->bSlider, SLOT(ctrlReleased()) );
111 |   
112 |   connect( this, SIGNAL(ctrlPressed()), ui->cSlider, SLOT(ctrlPressed()) );
113 |   connect( this, SIGNAL(ctrlReleased()), ui->cSlider, SLOT(ctrlReleased()) );
114 |   connect( this, SIGNAL(ctrlPressed()), ui->mSlider, SLOT(ctrlPressed()) );
115 |   connect( this, SIGNAL(ctrlReleased()), ui->mSlider, SLOT(ctrlReleased()) );
116 |   connect( this, SIGNAL(ctrlPressed()), ui->ySlider, SLOT(ctrlPressed()) );
117 |   connect( this, SIGNAL(ctrlReleased()), ui->ySlider, SLOT(ctrlReleased()) );
118 |   connect( this, SIGNAL(ctrlPressed()), ui->kSlider, SLOT(ctrlPressed()) );
119 |   connect( this, SIGNAL(ctrlReleased()), ui->kSlider, SLOT(ctrlReleased()) );
120 | }
121 | 
122 | void SlidersWindow::addShortcuts() {
123 |   QShortcut *quit = new QShortcut(QKeySequence("Esc"), this);
124 |   connect( quit, SIGNAL(activated()), this, SLOT(close()) );
125 | }
126 | 
127 | 
128 | // --------------------------------------------- slots ---------------------------------------------
129 | 
130 | void SlidersWindow::sliderMiddlePressed(QMouseEvent* e) {
131 |   mouseDown = true;
132 |   mouseMoved = false;
133 | 
134 |   mx = e->x();
135 |   my = e->y();
136 | }
137 | 
138 | 
139 | // --------------------------------------------- events ---------------------------------------------
140 | 
141 | void SlidersWindow::mousePressEvent(QMouseEvent *e)
142 | {
143 |   mouseDown = true;
144 |   mouseMoved = false;
145 | 
146 |   mx = e->x();
147 |   my = e->y();
148 | }
149 | 
150 | void SlidersWindow::mouseReleaseEvent(QMouseEvent *e)
151 | {
152 |   mouseDown = false;
153 |   if (e->button() == Qt::MiddleButton && !mouseMoved) close();
154 | }
155 | 
156 | void SlidersWindow::mouseMoveEvent(QMouseEvent *e)
157 | {
158 |   if (mouseDown) {
159 |     mouseMoved = true;
160 | 
161 |     int gx = e->globalX();
162 |     int gy = e->globalY();
163 | 
164 |     int corrX = geometry().x()-x();
165 |     int corrY = geometry().y()-y();
166 | 
167 |     int moveX = gx-mx-corrX;
168 |     int moveY = gy-my-corrY;
169 | 
170 |     move(moveX, moveY);
171 |   }
172 | }
173 | 
174 | void SlidersWindow::keyPressEvent(QKeyEvent *e)
175 | {
176 |   int key = e->key();
177 |   if (key == Qt::Key_Control) {
178 |     emit ctrlPressed();
179 |   }
180 | }
181 | 
182 | void SlidersWindow::keyReleaseEvent(QKeyEvent *e)
183 | {
184 |   int key = e->key();
185 |   if (key == Qt::Key_Control) {
186 |     emit ctrlReleased();
187 |   }
188 | }
189 | 


--------------------------------------------------------------------------------
/Controllers/sliderscontroller.cpp:
--------------------------------------------------------------------------------
  1 | #include "sliderscontroller.h"
  2 | #include "ui_sliderswindow.h"
  3 | 
  4 | // ------------------------------------------------------------------------------------------------
  5 | 
  6 | SlidersController::SlidersController(QObject* parent) : QObject(parent)
  7 | {
  8 |   addActions();
  9 |   init();
 10 | }
 11 | 
 12 | void SlidersController::init() {
 13 |   hueSpinManualEdit = true;
 14 |   saturationSpinManualEdit = true;
 15 |   valueSpinManualEdit = true;
 16 |   
 17 |   redSpinManualEdit = true;
 18 |   greenSpinManualEdit = true;
 19 |   blueSpinManualEdit = true;
 20 |   
 21 |   cyanSpinManualEdit = true;
 22 |   magentaSpinManualEdit = true;
 23 |   yellowSpinManualEdit = true;
 24 |   blackSpinManualEdit = true;
 25 | }
 26 | 
 27 | void SlidersController::addActions() {
 28 |   connectRGB();
 29 |   connectCMYK();
 30 | }
 31 | 
 32 | void SlidersController::setView(SlidersWindow* slidersView) {
 33 |   this->slidersView = slidersView;
 34 | }
 35 | 
 36 | 
 37 | void SlidersController::connectRGB() {
 38 |   connect( this, SIGNAL(RGBChanged(QColor)), this, SLOT(changeRedFromSelector(QColor)) );
 39 |   connect( this, SIGNAL(RGBChanged(QColor)), this, SLOT(changeGreenFromSelector(QColor)) );
 40 |   connect( this, SIGNAL(RGBChanged(QColor)), this, SLOT(changeBlueFromSelector(QColor)) );
 41 | }
 42 | 
 43 | void SlidersController::disconnectRGB() {
 44 |   disconnect( this, SIGNAL(RGBChanged(QColor)), 0, 0 );
 45 | }
 46 | 
 47 | void SlidersController::connectCMYK() {
 48 |   connect( this, SIGNAL(CMYKChanged(QColor)), this, SLOT(changeCyanFromSelector(QColor)) );
 49 |   connect( this, SIGNAL(CMYKChanged(QColor)), this, SLOT(changeMagentaFromSelector(QColor)) );
 50 |   connect( this, SIGNAL(CMYKChanged(QColor)), this, SLOT(changeYellowFromSelector(QColor)) );
 51 |   connect( this, SIGNAL(CMYKChanged(QColor)), this, SLOT(changeBlackFromSelector(QColor)) );
 52 | }
 53 | 
 54 | void SlidersController::disconnectCMYK() {
 55 |   disconnect( this, SIGNAL(CMYKChanged(QColor)), 0, 0 );
 56 | }
 57 | 
 58 | 
 59 | // --------------------------------------------- HSV ---------------------------------------------
 60 | 
 61 | // ===== hue =====
 62 | 
 63 | void SlidersController::changeHue(int h) {
 64 |   if (hueSpinManualEdit) {
 65 |     QColor filter = QColor::fromHsv(h, 0, 0);
 66 |     changeHue(filter);
 67 |   }
 68 |   hueSpinManualEdit = true;
 69 | }
 70 | 
 71 | void SlidersController::changeHue(QColor color) {
 72 |   emit hueChanged(color);
 73 | }
 74 | 
 75 | void SlidersController::changeHueFromSelector(QColor color) {
 76 |   hueSpinManualEdit = false;
 77 | 
 78 |   slidersView->ui->hSlider->setH(color);
 79 |   slidersView->ui->spHue->setValue(color.hue());
 80 |   
 81 |   slidersView->ui->sSlider->changeHue(color);
 82 |   slidersView->ui->vSlider->changeHue(color);
 83 | }
 84 | 
 85 | // ===== saturation =====
 86 | 
 87 | void SlidersController::changeSaturation(int s) {
 88 |   if (saturationSpinManualEdit) {
 89 |     QColor filter = QColor::fromHsv(0, s, 0);
 90 |     changeSaturation(filter);
 91 |   }
 92 |   saturationSpinManualEdit = true;
 93 | }
 94 | 
 95 | void SlidersController::changeSaturation(QColor color) {
 96 |   emit saturationChanged(color);
 97 | }
 98 | 
 99 | void SlidersController::changeSaturationFromSelector(QColor color) {
100 |   saturationSpinManualEdit = false;
101 |   
102 |   slidersView->ui->sSlider->setS(color);
103 |   slidersView->ui->spSaturation->setValue(color.saturation());
104 |   
105 |   slidersView->ui->hSlider->changeSaturation(color);
106 |   slidersView->ui->vSlider->changeSaturation(color);
107 | }
108 | 
109 | // ===== value =====
110 | 
111 | void SlidersController::changeValue(int v) {
112 |   if (valueSpinManualEdit) {
113 |     QColor filter = QColor::fromHsv(0, 0, v);
114 |     changeValue(filter);
115 |   }
116 |   valueSpinManualEdit = true;
117 | }
118 | 
119 | void SlidersController::changeValue(QColor color) {
120 |   emit valueChanged(color);
121 | }
122 | 
123 | void SlidersController::changeValueFromSelector(QColor color) {
124 |   valueSpinManualEdit = false;
125 |   
126 |   slidersView->ui->vSlider->setV(color);
127 |   slidersView->ui->spValue->setValue(color.value());
128 |   
129 |   slidersView->ui->hSlider->changeValue(color);
130 |   slidersView->ui->sSlider->changeValue(color);
131 | }
132 | 
133 | 
134 | // --------------------------------------------- RGB ---------------------------------------------
135 | 
136 | // ===== red =====
137 | 
138 | void SlidersController::changeRed(int r) {
139 |   if (redSpinManualEdit) {
140 |     QColor filter(r, 0, 0);
141 |     changeRed(filter);
142 |   }
143 |   redSpinManualEdit = true;
144 | }
145 | 
146 | void SlidersController::changeRed(QColor color) {
147 |   emit redChanged(color);
148 |   updateRedValues(color);
149 | }
150 | 
151 | void SlidersController::changeRedFromSelector(QColor color) {
152 |   updateRedValues(color);
153 | }
154 | 
155 | void SlidersController::updateRedValues(QColor color) {
156 |   slidersView->ui->rSlider->setR(color);
157 |   
158 |   redSpinManualEdit = false;
159 |   slidersView->ui->spRed->setValue(color.red());
160 |   
161 |   slidersView->ui->gSlider->changeRed(color);
162 |   slidersView->ui->bSlider->changeRed(color);
163 | }
164 | 
165 | // ===== green =====
166 | 
167 | void SlidersController::changeGreen(int g) {
168 |   if (greenSpinManualEdit) {
169 |     QColor filter(0, g, 0);
170 |     changeGreen(filter);
171 |   }
172 |   greenSpinManualEdit = true;
173 | }
174 | 
175 | void SlidersController::changeGreen(QColor color) {
176 |   emit greenChanged(color);
177 |   updateGreenValues(color);
178 | }
179 | 
180 | void SlidersController::changeGreenFromSelector(QColor color) {
181 |   updateGreenValues(color);
182 | }
183 | 
184 | void SlidersController::updateGreenValues(QColor color) {
185 |   slidersView->ui->gSlider->setG(color);
186 | 
187 |   greenSpinManualEdit = false;
188 |   slidersView->ui->spGreen->setValue(color.green());
189 | 
190 |   slidersView->ui->rSlider->changeGreen(color);
191 |   slidersView->ui->bSlider->changeGreen(color);
192 | }
193 | 
194 | // ===== blue =====
195 | 
196 | void SlidersController::changeBlue(int b) {
197 |   if (blueSpinManualEdit) {
198 |     QColor filter(0, 0, b);
199 |     changeBlue(filter);
200 |   }
201 |   blueSpinManualEdit = true;
202 | }
203 | 
204 | void SlidersController::changeBlue(QColor color) {
205 |   emit blueChanged(color);
206 |   updateBlueValues(color);
207 | }
208 | 
209 | void SlidersController::changeBlueFromSelector(QColor color) {
210 |   updateBlueValues(color);
211 | }
212 | 
213 | void SlidersController::updateBlueValues(QColor color) {
214 |   slidersView->ui->bSlider->setB(color);
215 |   
216 |   blueSpinManualEdit = false;
217 |   slidersView->ui->spBlue->setValue(color.blue());
218 |   
219 |   slidersView->ui->rSlider->changeBlue(color);
220 |   slidersView->ui->gSlider->changeBlue(color);
221 | }
222 | 
223 | 
224 | // --------------------------------------------- CMYK ---------------------------------------------
225 | 
226 | // ===== cyan =====
227 | 
228 | void SlidersController::changeCyan(int c) {
229 |   if (cyanSpinManualEdit) {
230 |     QColor filter = QColor::fromCmyk(c, 0, 0, 0);
231 |     changeCyan(filter);
232 |   }
233 |   cyanSpinManualEdit = true;
234 | }
235 | 
236 | void SlidersController::changeCyan(QColor color) {
237 |   emit cyanChanged(color);
238 |   updateCyanValues(color);
239 | }
240 | 
241 | void SlidersController::changeCyanFromSelector(QColor color) {
242 |   updateCyanValues(color);
243 | }
244 | 
245 | void SlidersController::updateCyanValues(QColor color) {
246 |   slidersView->ui->cSlider->setC(color);
247 |   
248 |   cyanSpinManualEdit = false;
249 |   slidersView->ui->spCyan->setValue(color.cyan());
250 |   
251 |   slidersView->ui->ySlider->changeCyan(color);
252 |   slidersView->ui->mSlider->changeCyan(color);
253 |   slidersView->ui->kSlider->changeCyan(color);
254 | }
255 | 
256 | // ===== magenta =====
257 | 
258 | void SlidersController::changeMagenta(int m) {
259 |   if (magentaSpinManualEdit) {
260 |     QColor filter = QColor::fromCmyk(0, m, 0, 0);
261 |     changeMagenta(filter);
262 |   }
263 |   magentaSpinManualEdit = true;
264 | }
265 | 
266 | void SlidersController::changeMagenta(QColor color) {
267 |   emit magentaChanged(color);
268 |   updateMagentaValues(color);
269 | }
270 | 
271 | void SlidersController::changeMagentaFromSelector(QColor color) {
272 |   updateMagentaValues(color);
273 | }
274 | 
275 | void SlidersController::updateMagentaValues(QColor color) {
276 |   slidersView->ui->mSlider->setM(color);
277 |   
278 |   magentaSpinManualEdit = false;
279 |   slidersView->ui->spMagenta->setValue(color.magenta());
280 |   
281 |   slidersView->ui->cSlider->changeMagenta(color);
282 |   slidersView->ui->ySlider->changeMagenta(color);
283 |   slidersView->ui->kSlider->changeMagenta(color);
284 | }
285 | 
286 | // ===== yellow =====
287 | 
288 | void SlidersController::changeYellow(int y) {
289 |   if (yellowSpinManualEdit) {
290 |     QColor filter = QColor::fromCmyk(0, 0, y, 0);
291 |     changeYellow(filter);
292 |   }
293 |   yellowSpinManualEdit = true;
294 | }
295 | 
296 | void SlidersController::changeYellow(QColor color) {
297 |   emit yellowChanged(color);
298 |   updateYellowValues(color);
299 | }
300 | 
301 | void SlidersController::changeYellowFromSelector(QColor color) {
302 |   updateYellowValues(color);
303 | }
304 | 
305 | void SlidersController::updateYellowValues(QColor color) {
306 |   slidersView->ui->ySlider->setY(color);
307 |   
308 |   yellowSpinManualEdit = false;
309 |   slidersView->ui->spYellow->setValue(color.yellow());
310 |   
311 |   slidersView->ui->cSlider->changeYellow(color);
312 |   slidersView->ui->mSlider->changeYellow(color);
313 |   slidersView->ui->kSlider->changeYellow(color);
314 | }
315 | 
316 | // ===== black =====
317 | 
318 | void SlidersController::changeBlack(int k) {
319 |   if (blackSpinManualEdit) {
320 |     QColor filter = QColor::fromCmyk(0, 0, 0, k);
321 |     changeBlack(filter);
322 |   }
323 |   blackSpinManualEdit = true;
324 | }
325 | 
326 | void SlidersController::changeBlack(QColor color) {
327 |   emit blackChanged(color);
328 |   updateBlackValues(color);
329 | }
330 | 
331 | void SlidersController::changeBlackFromSelector(QColor color) {
332 |   updateBlackValues(color);
333 | }
334 | 
335 | void SlidersController::updateBlackValues(QColor color) {
336 |   slidersView->ui->kSlider->setK(color);
337 |   
338 |   blackSpinManualEdit = false;
339 |   slidersView->ui->spBlack->setValue(color.black());
340 |   
341 |   slidersView->ui->cSlider->changeBlack(color);
342 |   slidersView->ui->mSlider->changeBlack(color);
343 |   slidersView->ui->ySlider->changeBlack(color);
344 | }
345 | 


--------------------------------------------------------------------------------
/Views/mainwindow.cpp:
--------------------------------------------------------------------------------
  1 | #include "mainwindow.h"
  2 | #include "ui_mainwindow.h"
  3 | 
  4 | #include <QPainter>
  5 | #include <QShortcut>
  6 | #include <QScreen>
  7 | 
  8 | #include "Widgets/ColorWidgets/hselector.h"
  9 | #include "Service/validator.h"
 10 | 
 11 | #include "pickerview.h"
 12 | #include "testwidget.h"
 13 | #include "testdialog.h"
 14 | 
 15 | 
 16 | MainWindow::MainWindow(QWidget *parent) :
 17 |   QMainWindow(parent),
 18 |   ui(new Ui::MainWindow)
 19 | {
 20 |   ui->setupUi(this);
 21 |   colorProcessor = new ColorProcessor(ui->hSelector, ui->svSelector);
 22 |   mainController = new MainController(ui->hSelector, ui->svSelector, colorProcessor, this);
 23 |   
 24 |   slidersWindow = NULL;
 25 | 
 26 |   addActions();
 27 |   addShortcuts();
 28 |   init();
 29 | }
 30 | 
 31 | MainWindow::~MainWindow()
 32 | {
 33 |   delete ui;
 34 | }
 35 | 
 36 | 
 37 | bool MainWindow::eventFilter(QObject *obj, QEvent *event) {
 38 |   qDebug() << "Event Filter: " << event->type();
 39 |   return QObject::eventFilter(obj, event);
 40 | }
 41 | 
 42 | 
 43 | void MainWindow::init() {
 44 |   QApplication::setStyle("fusion");
 45 |   
 46 |   mx = 0;
 47 |   my = 0;
 48 |   
 49 |   mouseDown = false;
 50 | 
 51 |   QMargins margins(5,0,0,0);
 52 | 
 53 |   ui->leHSV->setTextMargins(margins);
 54 |   ui->leRGB->setTextMargins(margins);
 55 |   ui->leCMYK->setTextMargins(margins);
 56 |   ui->leHex->setTextMargins(margins);
 57 | 
 58 |   ui->leHSV->setType(Vars::HSV);
 59 |   ui->leRGB->setType(Vars::RGB);
 60 |   ui->leCMYK->setType(Vars::CMYK);
 61 |   ui->leHex->setType(Vars::Hex);
 62 |   
 63 |   ui->hSelector->setInitH(0);
 64 |   
 65 |   // qApp->installEventFilter(this);
 66 | }
 67 | 
 68 | void MainWindow::addActions() {
 69 |   connect( ui->hSelector, SIGNAL(hueChanged(QColor)), ui->svSelector, SLOT(changeHue(QColor)) );
 70 |   connect( ui->svSelector, SIGNAL(colorChanged(QColor)), ui->colorSample, SLOT(changeColor(QColor)) );
 71 |   connect( ui->colorSample, SIGNAL(colorChanged(QColor)), this, SLOT(updateColorText(QColor)) );
 72 |   // connect( ui->svSelector, SIGNAL(colorChanged(QColor)), this, SLOT(updateColorText(QColor)) );
 73 | 
 74 |   connect( ui->leHSV,  SIGNAL(textEdited(QString)), this, SLOT(updateColorHSV(QString)) );
 75 |   connect( ui->leRGB,  SIGNAL(textEdited(QString)), this, SLOT(updateColorRGB(QString)) );
 76 |   connect( ui->leCMYK, SIGNAL(textEdited(QString)), this, SLOT(updateColorCMYK(QString)) );
 77 |   connect( ui->leHex,  SIGNAL(textEdited(QString)), this, SLOT(updateColorHex(QString)) );
 78 |   
 79 |   connect( ui->leHSV,  SIGNAL(focusNextField()), this, SLOT(focusNextField()) );
 80 |   connect( ui->leRGB,  SIGNAL(focusNextField()), this, SLOT(focusNextField()) );
 81 |   connect( ui->leCMYK, SIGNAL(focusNextField()), this, SLOT(focusNextField()) );
 82 |   connect( ui->leHex,  SIGNAL(focusNextField()), this, SLOT(focusNextField()) );
 83 |   
 84 |   connect( ui->leHSV,  SIGNAL(focusPrevField()), this, SLOT(focusPrevField()) );
 85 |   connect( ui->leRGB,  SIGNAL(focusPrevField()), this, SLOT(focusPrevField()) );
 86 |   connect( ui->leCMYK, SIGNAL(focusPrevField()), this, SLOT(focusPrevField()) );
 87 |   connect( ui->leHex,  SIGNAL(focusPrevField()), this, SLOT(focusPrevField()) );
 88 |   
 89 |   connect( colorProcessor, SIGNAL(updateFinished()), this, SLOT(updateColorFinished()) );
 90 | 
 91 |   connect( ui->bHSV, SIGNAL(clicked()), this, SLOT(copyHSV()) );
 92 |   connect( ui->bRGB, SIGNAL(clicked()), this, SLOT(copyRGB()) );
 93 |   connect( ui->bCMYK, SIGNAL(clicked()), this, SLOT(copyCMYK()) );
 94 | 
 95 |   connect( ui->bHex, SIGNAL(clicked()), this, SLOT(copyHex()) );
 96 |   connect( ui->bHexHash, SIGNAL(clicked()), this, SLOT(copyHexHash()) );
 97 |   connect( ui->bPasteHex, SIGNAL(clicked()), this, SLOT(pasteHex()) );
 98 | 
 99 |   connect( ui->colorSample, SIGNAL(samplePressedLeft()), this, SLOT(copyHex()) );
100 |   connect( ui->colorSample, SIGNAL(samplePressedRight()), this, SLOT(copyHexHash()) );
101 |   connect( ui->colorSample, SIGNAL(samplePressedMiddle()), this, SLOT(toggleSliders()) );
102 | 
103 |   connect( ui->hSelector, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(hsvMiddlePressed(QMouseEvent*)) );
104 |   connect( ui->svSelector, SIGNAL(middlePressedSignal(QMouseEvent*)), this, SLOT(hsvMiddlePressed(QMouseEvent*)) );
105 | 
106 |   connect( this, SIGNAL(mouseMovedOnWindow()), ui->colorSample, SLOT(mouseMovedOnWindow()) );
107 |   connect( this, SIGNAL(mouseReleasedOnWindow()), ui->colorSample, SLOT(mouseReleasedOnWindow()) );
108 |   connect( this, SIGNAL(shiftPressed()), ui->svSelector, SLOT(shiftPressed()) );
109 |   connect( this, SIGNAL(shiftReleased()), ui->svSelector, SLOT(shiftReleased()) );
110 |   
111 |   connect( this, SIGNAL(ctrlPressed()), ui->svSelector, SLOT(ctrlPressed()) );
112 |   connect( this, SIGNAL(ctrlReleased()), ui->svSelector, SLOT(ctrlReleased()) );
113 |   connect( this, SIGNAL(ctrlPressed()), ui->hSelector, SLOT(ctrlPressed()) );
114 |   connect( this, SIGNAL(ctrlReleased()), ui->hSelector, SLOT(ctrlReleased()) );
115 |   
116 |   // connect( ui->bShowPicker, SIGNAL(clicked()), this, SLOT(showPickerClicked()) );
117 |   // connect( ui->bSliders, SIGNAL(clicked()), this, SLOT(openSliders()) );
118 | }
119 | 
120 | void MainWindow::addSlidersActions() {
121 |   // === HSV ===
122 |   connect( slidersController, SIGNAL(hueChanged(QColor)), mainController, SLOT(changeHue(QColor)) );
123 |   connect( slidersController, SIGNAL(saturationChanged(QColor)), mainController, SLOT(changeSaturation(QColor)) );
124 |   connect( slidersController, SIGNAL(valueChanged(QColor)), mainController, SLOT(changeValue(QColor)) );
125 |   
126 |   connect( ui->hSelector, SIGNAL(hueChanged(QColor)), slidersController, SLOT(changeHueFromSelector(QColor)) );
127 |   connect( ui->svSelector, SIGNAL(saturationChanged(QColor)), slidersController, SLOT(changeSaturationFromSelector(QColor)) );
128 |   connect( ui->svSelector, SIGNAL(valueChanged(QColor)), slidersController, SLOT(changeValueFromSelector(QColor)) );
129 |   
130 |   // === RGB ===
131 |   connect( slidersController, SIGNAL(redChanged(QColor)), mainController, SLOT(changeRed(QColor)) );
132 |   connect( slidersController, SIGNAL(greenChanged(QColor)), mainController, SLOT(changeGreen(QColor)) );
133 |   connect( slidersController, SIGNAL(blueChanged(QColor)), mainController, SLOT(changeBlue(QColor)) );
134 |   
135 |   connect( ui->colorSample, SIGNAL(colorChanged(QColor)), slidersController, SIGNAL(RGBChanged(QColor)) );
136 |   
137 |   // === CMYK ===
138 |   connect( slidersController, SIGNAL(cyanChanged(QColor)), mainController, SLOT(changeCyan(QColor)) );
139 |   connect( slidersController, SIGNAL(magentaChanged(QColor)), mainController, SLOT(changeMagenta(QColor)) );
140 |   connect( slidersController, SIGNAL(yellowChanged(QColor)), mainController, SLOT(changeYellow(QColor)) );
141 |   connect( slidersController, SIGNAL(blackChanged(QColor)), mainController, SLOT(changeBlack(QColor)) );
142 |   
143 |   connect( ui->colorSample, SIGNAL(colorChanged(QColor)), slidersController, SIGNAL(CMYKChanged(QColor)) );
144 | }
145 | 
146 | void MainWindow::addShortcuts() {
147 |   QShortcut* HSV_Text = new QShortcut(QKeySequence("Shift+F1"), this);
148 |   QShortcut* RGB_Text = new QShortcut(QKeySequence("Shift+F2"), this);
149 |   QShortcut* CMYK_Text = new QShortcut(QKeySequence("Shift+F3"), this);
150 |   QShortcut* Hex_Text = new QShortcut(QKeySequence("Shift+F4"), this);
151 |   
152 |   QShortcut* toggleSlider_Key = new QShortcut(QKeySequence("Ctrl+S"), this);
153 |   connect( toggleSlider_Key, SIGNAL(activated()), this, SLOT(toggleSliders()) );
154 |   
155 |   mapper = new QSignalMapper(this);
156 |   mapper->setMapping(HSV_Text, ui->leHSV);
157 |   mapper->setMapping(RGB_Text, ui->leRGB);
158 |   mapper->setMapping(CMYK_Text, ui->leCMYK);
159 |   mapper->setMapping(Hex_Text, ui->leHex);
160 |   
161 |   connect( HSV_Text, SIGNAL(activated()), mapper, SLOT(map()) );
162 |   connect( RGB_Text, SIGNAL(activated()), mapper, SLOT(map()) );
163 |   connect( CMYK_Text, SIGNAL(activated()), mapper, SLOT(map()) );
164 |   connect( Hex_Text, SIGNAL(activated()), mapper, SLOT(map()) );
165 |   connect( mapper, SIGNAL(mapped(QWidget*)), this, SLOT(selectField(QWidget*)) );
166 |   
167 |   
168 |   QShortcut* HSV_Button = new QShortcut(QKeySequence("F1"), this);
169 |   connect( HSV_Button, SIGNAL(activated()), ui->bHSV, SLOT(click()) );
170 |   
171 |   QShortcut* RGB_Button = new QShortcut(QKeySequence("F2"), this);
172 |   connect( RGB_Button, SIGNAL(activated()), ui->bRGB, SLOT(click()) );
173 |   
174 |   QShortcut* CMYK_Button = new QShortcut(QKeySequence("F3"), this);
175 |   connect( CMYK_Button, SIGNAL(activated()), ui->bCMYK, SLOT(click()) );
176 |   
177 |   QShortcut* Hex_Button = new QShortcut(QKeySequence("F4"), this);
178 |   connect( Hex_Button, SIGNAL(activated()), ui->bHex, SLOT(click()) );
179 | 
180 |   QShortcut* HexHash_Button = new QShortcut(QKeySequence("F5"), this);
181 |   connect( HexHash_Button, SIGNAL(activated()), ui->bHexHash, SLOT(click()) );
182 | 
183 |   QShortcut* PasteHex_Button = new QShortcut(QKeySequence("F6"), this);
184 |   connect( PasteHex_Button, SIGNAL(activated()), ui->bPasteHex, SLOT(click()) );
185 | 
186 |   
187 |   QShortcut *quit = new QShortcut(QKeySequence("Esc"), this);
188 |   connect( quit, SIGNAL(activated()), this, SLOT(close()) );
189 | }
190 | 
191 | void MainWindow::selectField(QWidget* w) {
192 |   QLineEdit* field = (QLineEdit*) w;
193 |   field->setFocus();
194 |   field->selectAll();
195 | }
196 | 
197 | 
198 | // --------------------------------------------- slots ---------------------------------------------
199 | 
200 | void MainWindow::hsvMiddlePressed(QMouseEvent* e) {
201 |   mouseDown = true;
202 |   mouseMoved = false;
203 | 
204 |   mx = e->x();
205 |   my = e->y();
206 | }
207 | 
208 | void MainWindow::middleClick(QMouseEvent* e) {
209 |   mouseReleaseEvent(e);
210 | }
211 | 
212 | void MainWindow::updateSliders() {
213 |   ui->hSelector->reupdateColor();
214 |   ui->svSelector->reupdateColor();
215 |   ui->colorSample->reupdateColor();
216 | }
217 | 
218 | void MainWindow::toggleSliders() {
219 |   if (slidersWindow == NULL || !slidersWindow->isVisible())
220 |     openSliders();
221 |   else
222 |     closeSliders();
223 | }
224 | 
225 | void MainWindow::closeSliders() {
226 |   slidersWindow->hide();
227 | }
228 | 
229 | void MainWindow::openSliders() {
230 |   if (slidersWindow == NULL) {
231 |     slidersController = new SlidersController();
232 |     slidersWindow = new SlidersWindow(slidersController, this);
233 |     
234 |     slidersController->setView(slidersWindow);
235 |     mainController->addSlidersController(slidersController);
236 |     
237 |     addSlidersActions();
238 |     updateSliders();
239 |   }
240 |   
241 |   if (slidersWindow!=NULL) {
242 |     stickSliders();
243 |     slidersWindow->show();
244 |   }
245 | }
246 | 
247 | void MainWindow::stickSliders() {
248 |   int corrX = frameGeometry().width()-width();
249 | 
250 |   int sx = x();
251 |   int sy = y();
252 |   int w = slidersWindow->width()+corrX;
253 |   sx-=w;
254 |   
255 |   // qDebug() << QString("Sliders: %1, %2").arg(sx).arg(sy);
256 |   
257 |   sx = qMax(0, sx);
258 |   
259 |   slidersWindow->move(sx, sy);
260 | }
261 | 
262 | 
263 | void MainWindow::focusNextField() {
264 |   if (ui->leHSV->hasFocus()) {
265 |     ui->leRGB->setFocus(Qt::TabFocusReason);
266 |   }
267 |   else if (ui->leRGB->hasFocus()) {
268 |     ui->leCMYK->setFocus(Qt::TabFocusReason);
269 |   }
270 |   else if (ui->leCMYK->hasFocus()) {
271 |     ui->leHex->setFocus(Qt::TabFocusReason);
272 |   }
273 |   else if (ui->leHex->hasFocus()) {
274 |     ui->leHSV->setFocus(Qt::TabFocusReason);
275 |   }
276 | }
277 | 
278 | void MainWindow::focusPrevField() {
279 |   if (ui->leHSV->hasFocus()) {
280 |     ui->leHex->setFocus(Qt::BacktabFocusReason);
281 |   }
282 |   else if (ui->leHex->hasFocus()) {
283 |     ui->leCMYK->setFocus(Qt::BacktabFocusReason);
284 |   }
285 |   else if (ui->leCMYK->hasFocus()) {
286 |     ui->leRGB->setFocus(Qt::BacktabFocusReason);
287 |   }
288 |   else if (ui->leRGB->hasFocus()) {
289 |     ui->leHSV->setFocus(Qt::BacktabFocusReason);
290 |   }
291 | }
292 | 
293 | void MainWindow::showPickerClicked() {
294 |   // PickerView* w = new PickerView(this);
295 |   TestWidget* w = new TestWidget(this);
296 |   // TestWidget* w = new TestWidget;
297 |   // TestDialog* w = new TestDialog(this);
298 |   
299 |   w->setWindowFlags(Qt::Window | Qt::FramelessWindowHint);
300 |   
301 |   QPoint pos = QCursor::pos();
302 |   int wx = pos.x() - w->width()/2;
303 |   int wy = pos.y() - w->height()/2;
304 |   
305 |   // w->move(10, 10);
306 |   w->move(wx, wy);
307 |   w->show();
308 |   
309 |   // w->grabMouse();
310 | }
311 | 
312 | 
313 | // --------------------------------------------- buttons ---------------------------------------------
314 | 
315 | void MainWindow::copyHSV() {
316 |   QString text = ui->leHSV->text();
317 |   text = text.replace(" ", ", ");
318 |   colorProcessor->copyText(text);
319 |   status("HSV copied");
320 | }
321 | 
322 | void MainWindow::copyRGB() {
323 |   QString text = ui->leRGB->text();
324 |   text = text.replace(" ", ", ");
325 |   colorProcessor->copyText(text);
326 |   status("RGB copied");
327 | }
328 | 
329 | void MainWindow::copyCMYK() {
330 |   QString text = ui->leCMYK->text();
331 |   text = text.replace(" ", ", ");
332 |   colorProcessor->copyText(text);
333 |   status("CMYK copied");
334 | }
335 | 
336 | void MainWindow::copyHex() {
337 |   QString text = ui->leHex->text();
338 |   colorProcessor->copyText(text);
339 |   status("Hex copied");
340 | }
341 | 
342 | void MainWindow::copyHexHash() {
343 |   QString text = ui->leHex->text();
344 |   colorProcessor->copyText("#"+text);
345 |   status("Hex # copied");
346 | }
347 | 
348 | void MainWindow::pasteHex() {
349 |   QString text = colorProcessor->pasteText();
350 |   if (!text.length()) return;
351 | 
352 |   ui->leHex->setText(text);
353 |   ui->leHex->textEdited(text);
354 |   status("Hex value pasted");
355 | }
356 | 
357 | // --------------------------------------------- update color ---------------------------------------------
358 | 
359 | void MainWindow::updateColorFinished() {
360 |   editingField = "";
361 | }
362 | 
363 | void MainWindow::updateColorHSV(QString text) {
364 |   editingField = "HSV";
365 |   text = Validator::correctColorText(text);
366 |   ui->leHSV->updateText(text);
367 |   colorProcessor->updateColorHSV(text);
368 | }
369 | 
370 | void MainWindow::updateColorRGB(QString text) {
371 |   editingField = "RGB";
372 |   text = Validator::correctColorText(text);
373 |   ui->leRGB->updateText(text);
374 |   colorProcessor->updateColorRGB(text);
375 | }
376 | 
377 | void MainWindow::updateColorCMYK(QString text) {
378 |   editingField = "CMYK";
379 |   text = Validator::correctColorText(text);
380 |   ui->leCMYK->updateText(text);
381 |   colorProcessor->updateColorCMYK(text);
382 | }
383 | 
384 | void MainWindow::updateColorHex(QString text) {
385 |   editingField = "Hex";
386 |   text = Validator::correctColorText(text);
387 |   ui->leHex->updateText(text);
388 |   colorProcessor->updateColorHex(text);
389 | }
390 | 
391 | // --------------------------------------------- update color text ---------------------------------------------
392 | 
393 | void MainWindow::updateColorText(QColor color) {
394 |   QString HSV, RGB, CMYK, Hex;
395 |   
396 |   HSV = colorProcessor->getHSV(color);
397 |   RGB = colorProcessor->getRGB(color);
398 |   CMYK = colorProcessor->getCMYK(color);
399 |   Hex = colorProcessor->getHex(color);
400 |   
401 |   setHSV(HSV);
402 |   setRGB(RGB);
403 |   setCMYK(CMYK);
404 |   setHex(Hex);
405 | }
406 | 
407 | void MainWindow::setHSV(QString text) {
408 |   if (editingField == "HSV") return;
409 |   ui->leHSV->setText(text);
410 | }
411 | 
412 | void MainWindow::setRGB(QString text) {
413 |   if (editingField == "RGB") return;
414 |   ui->leRGB->setText(text);
415 | }
416 | 
417 | void MainWindow::setCMYK(QString text) {
418 |   if (editingField == "CMYK") return;
419 |   ui->leCMYK->setText(text);
420 | }
421 | 
422 | void MainWindow::setHex(QString text) {
423 |   if (editingField == "Hex") return;
424 |   ui->leHex->setText(text);
425 | }
426 | 
427 | 
428 | QString MainWindow::getHSV() {
429 |   return ui->leHSV->text();
430 | }
431 | 
432 | QString MainWindow::getRGB() {
433 |   return ui->leRGB->text();
434 | }
435 | 
436 | QString MainWindow::getCMYK() {
437 |   return ui->leCMYK->text();
438 | }
439 | 
440 | QString MainWindow::getHex() {
441 |   return ui->leHex->text();
442 | }
443 | 
444 | // --------------------------------------------- service ---------------------------------------------
445 | 
446 | void MainWindow::correctFields() {
447 |   QString text;
448 |   text = ui->leHSV->text();
449 |   text = correctField(text);
450 |   ui->leHSV->setText(text);
451 |   
452 |   text = ui->leRGB->text();
453 |   text = correctField(text);
454 |   ui->leRGB->setText(text);
455 |   
456 |   text = ui->leCMYK->text();
457 |   text = correctField(text);
458 |   ui->leCMYK->setText(text);
459 |   
460 |   text = ui->leHex->text();
461 |   text = correctField(text);
462 |   ui->leHex->setText(text);
463 | }
464 | 
465 | QString MainWindow::correctField(QString text) {         // +++ to Validator
466 |   text = text.trimmed();
467 |   text = text.replace(QRegExp("\\s+"), " ");
468 |     
469 |   return text;
470 | }
471 | 
472 | void MainWindow::status(QString msg) {
473 |   ui->statusBar->showMessage(msg, 3000);
474 | }
475 | 
476 | // --------------------------------------------- events ---------------------------------------------
477 | 
478 | void MainWindow::mousePressEvent(QMouseEvent *e)
479 | {
480 |   mouseDown = true;
481 |   mouseMoved = false;
482 | 
483 |   mx = e->x();
484 |   my = e->y();
485 | }
486 | 
487 | void MainWindow::mouseReleaseEvent(QMouseEvent *e)
488 | {
489 |   mouseDown = false;
490 |   if (e->button() == Qt::MiddleButton && !mouseMoved) close();
491 |   emit mouseReleasedOnWindow();
492 | }
493 | 
494 | void MainWindow::mouseMoveEvent(QMouseEvent *e)
495 | {
496 |   if (mouseDown) {
497 |     mouseMoved = true;
498 | 
499 |     emit mouseMovedOnWindow();
500 | 
501 |     int gx = e->globalX();
502 |     int gy = e->globalY();
503 | 
504 |     int corrX = geometry().x()-x();
505 |     int corrY = geometry().y()-y();
506 | 
507 |     int moveX = gx-mx-corrX;
508 |     int moveY = gy-my-corrY;
509 | 
510 |     move(moveX, moveY);
511 |   }
512 | }
513 | 
514 | void MainWindow::keyPressEvent(QKeyEvent *e)
515 | {
516 |   int key = e->key();
517 |   if (key == Qt::Key_Shift) {
518 |     emit shiftPressed();
519 |   }
520 |   if (key == Qt::Key_Control) {
521 |     emit ctrlPressed();
522 |   }
523 | }
524 | 
525 | void MainWindow::keyReleaseEvent(QKeyEvent *e)
526 | {
527 |   int key = e->key();
528 |   if (key == Qt::Key_Shift) {
529 |     emit shiftReleased();
530 |   }
531 |   if (key == Qt::Key_Control) {
532 |     emit ctrlReleased();
533 |   }
534 | }
535 | 


--------------------------------------------------------------------------------
/Views/mainwindow.ui:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <ui version="4.0">
  3 |  <class>MainWindow</class>
  4 |  <widget class="QMainWindow" name="MainWindow">
  5 |   <property name="geometry">
  6 |    <rect>
  7 |     <x>0</x>
  8 |     <y>0</y>
  9 |     <width>636</width>
 10 |     <height>414</height>
 11 |    </rect>
 12 |   </property>
 13 |   <property name="sizePolicy">
 14 |    <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
 15 |     <horstretch>0</horstretch>
 16 |     <verstretch>0</verstretch>
 17 |    </sizepolicy>
 18 |   </property>
 19 |   <property name="minimumSize">
 20 |    <size>
 21 |     <width>636</width>
 22 |     <height>414</height>
 23 |    </size>
 24 |   </property>
 25 |   <property name="maximumSize">
 26 |    <size>
 27 |     <width>636</width>
 28 |     <height>414</height>
 29 |    </size>
 30 |   </property>
 31 |   <property name="palette">
 32 |    <palette>
 33 |     <active>
 34 |      <colorrole role="Base">
 35 |       <brush brushstyle="SolidPattern">
 36 |        <color alpha="255">
 37 |         <red>255</red>
 38 |         <green>255</green>
 39 |         <blue>255</blue>
 40 |        </color>
 41 |       </brush>
 42 |      </colorrole>
 43 |      <colorrole role="Window">
 44 |       <brush brushstyle="SolidPattern">
 45 |        <color alpha="255">
 46 |         <red>219</red>
 47 |         <green>221</green>
 48 |         <blue>219</blue>
 49 |        </color>
 50 |       </brush>
 51 |      </colorrole>
 52 |     </active>
 53 |     <inactive>
 54 |      <colorrole role="Base">
 55 |       <brush brushstyle="SolidPattern">
 56 |        <color alpha="255">
 57 |         <red>255</red>
 58 |         <green>255</green>
 59 |         <blue>255</blue>
 60 |        </color>
 61 |       </brush>
 62 |      </colorrole>
 63 |      <colorrole role="Window">
 64 |       <brush brushstyle="SolidPattern">
 65 |        <color alpha="255">
 66 |         <red>219</red>
 67 |         <green>221</green>
 68 |         <blue>219</blue>
 69 |        </color>
 70 |       </brush>
 71 |      </colorrole>
 72 |     </inactive>
 73 |     <disabled>
 74 |      <colorrole role="Base">
 75 |       <brush brushstyle="SolidPattern">
 76 |        <color alpha="255">
 77 |         <red>219</red>
 78 |         <green>221</green>
 79 |         <blue>219</blue>
 80 |        </color>
 81 |       </brush>
 82 |      </colorrole>
 83 |      <colorrole role="Window">
 84 |       <brush brushstyle="SolidPattern">
 85 |        <color alpha="255">
 86 |         <red>219</red>
 87 |         <green>221</green>
 88 |         <blue>219</blue>
 89 |        </color>
 90 |       </brush>
 91 |      </colorrole>
 92 |     </disabled>
 93 |    </palette>
 94 |   </property>
 95 |   <property name="windowTitle">
 96 |    <string>QtColorPicker v1.0.2</string>
 97 |   </property>
 98 |   <property name="styleSheet">
 99 |    <string notr="true"/>
100 |   </property>
101 |   <widget class="QWidget" name="centralWidget">
102 |    <layout class="QVBoxLayout" name="verticalLayout">
103 |     <property name="spacing">
104 |      <number>0</number>
105 |     </property>
106 |     <property name="leftMargin">
107 |      <number>0</number>
108 |     </property>
109 |     <property name="topMargin">
110 |      <number>0</number>
111 |     </property>
112 |     <property name="rightMargin">
113 |      <number>0</number>
114 |     </property>
115 |     <property name="bottomMargin">
116 |      <number>0</number>
117 |     </property>
118 |     <item>
119 |      <spacer name="topVSpacer">
120 |       <property name="orientation">
121 |        <enum>Qt::Vertical</enum>
122 |       </property>
123 |       <property name="sizeType">
124 |        <enum>QSizePolicy::MinimumExpanding</enum>
125 |       </property>
126 |       <property name="sizeHint" stdset="0">
127 |        <size>
128 |         <width>20</width>
129 |         <height>14</height>
130 |        </size>
131 |       </property>
132 |      </spacer>
133 |     </item>
134 |     <item>
135 |      <widget class="QWidget" name="widget" native="true">
136 |       <layout class="QHBoxLayout" name="horizontalLayout">
137 |        <property name="spacing">
138 |         <number>0</number>
139 |        </property>
140 |        <property name="leftMargin">
141 |         <number>0</number>
142 |        </property>
143 |        <property name="topMargin">
144 |         <number>0</number>
145 |        </property>
146 |        <property name="rightMargin">
147 |         <number>0</number>
148 |        </property>
149 |        <property name="bottomMargin">
150 |         <number>0</number>
151 |        </property>
152 |        <item>
153 |         <spacer name="leftHSpacer">
154 |          <property name="orientation">
155 |           <enum>Qt::Horizontal</enum>
156 |          </property>
157 |          <property name="sizeType">
158 |           <enum>QSizePolicy::Fixed</enum>
159 |          </property>
160 |          <property name="sizeHint" stdset="0">
161 |           <size>
162 |            <width>10</width>
163 |            <height>20</height>
164 |           </size>
165 |          </property>
166 |         </spacer>
167 |        </item>
168 |        <item>
169 |         <widget class="QWidget" name="pColorPicker" native="true">
170 |          <property name="sizePolicy">
171 |           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
172 |            <horstretch>0</horstretch>
173 |            <verstretch>0</verstretch>
174 |           </sizepolicy>
175 |          </property>
176 |          <property name="minimumSize">
177 |           <size>
178 |            <width>0</width>
179 |            <height>365</height>
180 |           </size>
181 |          </property>
182 |          <property name="maximumSize">
183 |           <size>
184 |            <width>16777215</width>
185 |            <height>365</height>
186 |           </size>
187 |          </property>
188 |          <property name="autoFillBackground">
189 |           <bool>false</bool>
190 |          </property>
191 |          <layout class="QGridLayout" name="gridLayout">
192 |           <property name="leftMargin">
193 |            <number>0</number>
194 |           </property>
195 |           <property name="topMargin">
196 |            <number>0</number>
197 |           </property>
198 |           <property name="rightMargin">
199 |            <number>0</number>
200 |           </property>
201 |           <property name="bottomMargin">
202 |            <number>0</number>
203 |           </property>
204 |           <property name="spacing">
205 |            <number>0</number>
206 |           </property>
207 |           <item row="3" column="0">
208 |            <widget class="ColorSample" name="colorSample" native="true">
209 |             <property name="sizePolicy">
210 |              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
211 |               <horstretch>0</horstretch>
212 |               <verstretch>0</verstretch>
213 |              </sizepolicy>
214 |             </property>
215 |             <property name="minimumSize">
216 |              <size>
217 |               <width>260</width>
218 |               <height>80</height>
219 |              </size>
220 |             </property>
221 |             <property name="styleSheet">
222 |              <string notr="true">border:1px solid;</string>
223 |             </property>
224 |            </widget>
225 |           </item>
226 |           <item row="0" column="2" rowspan="4" alignment="Qt::AlignTop">
227 |            <widget class="HSelector" name="hSelector" native="true">
228 |             <property name="sizePolicy">
229 |              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
230 |               <horstretch>0</horstretch>
231 |               <verstretch>0</verstretch>
232 |              </sizepolicy>
233 |             </property>
234 |             <property name="minimumSize">
235 |              <size>
236 |               <width>54</width>
237 |               <height>365</height>
238 |              </size>
239 |             </property>
240 |             <property name="maximumSize">
241 |              <size>
242 |               <width>54</width>
243 |               <height>16777215</height>
244 |              </size>
245 |             </property>
246 |             <property name="autoFillBackground">
247 |              <bool>false</bool>
248 |             </property>
249 |             <property name="styleSheet">
250 |              <string notr="true">border:1px solid</string>
251 |             </property>
252 |            </widget>
253 |           </item>
254 |           <item row="0" column="0" alignment="Qt::AlignTop">
255 |            <widget class="SVSelector" name="svSelector" native="true">
256 |             <property name="sizePolicy">
257 |              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
258 |               <horstretch>0</horstretch>
259 |               <verstretch>0</verstretch>
260 |              </sizepolicy>
261 |             </property>
262 |             <property name="minimumSize">
263 |              <size>
264 |               <width>260</width>
265 |               <height>260</height>
266 |              </size>
267 |             </property>
268 |             <property name="styleSheet">
269 |              <string notr="true">border:1px solid;</string>
270 |             </property>
271 |            </widget>
272 |           </item>
273 |           <item row="1" column="0">
274 |            <spacer name="vSpacer2">
275 |             <property name="orientation">
276 |              <enum>Qt::Vertical</enum>
277 |             </property>
278 |             <property name="sizeType">
279 |              <enum>QSizePolicy::Fixed</enum>
280 |             </property>
281 |             <property name="sizeHint" stdset="0">
282 |              <size>
283 |               <width>20</width>
284 |               <height>20</height>
285 |              </size>
286 |             </property>
287 |            </spacer>
288 |           </item>
289 |           <item row="0" column="1" rowspan="2">
290 |            <spacer name="hSpacer2">
291 |             <property name="orientation">
292 |              <enum>Qt::Horizontal</enum>
293 |             </property>
294 |             <property name="sizeType">
295 |              <enum>QSizePolicy::Fixed</enum>
296 |             </property>
297 |             <property name="sizeHint" stdset="0">
298 |              <size>
299 |               <width>10</width>
300 |               <height>20</height>
301 |              </size>
302 |             </property>
303 |            </spacer>
304 |           </item>
305 |          </layout>
306 |          <zorder>svSelector</zorder>
307 |          <zorder>colorSample</zorder>
308 |          <zorder>hSelector</zorder>
309 |         </widget>
310 |        </item>
311 |        <item>
312 |         <spacer name="innerHSpacer1">
313 |          <property name="orientation">
314 |           <enum>Qt::Horizontal</enum>
315 |          </property>
316 |          <property name="sizeType">
317 |           <enum>QSizePolicy::Fixed</enum>
318 |          </property>
319 |          <property name="sizeHint" stdset="0">
320 |           <size>
321 |            <width>10</width>
322 |            <height>20</height>
323 |           </size>
324 |          </property>
325 |         </spacer>
326 |        </item>
327 |        <item>
328 |         <layout class="QVBoxLayout" name="loColorText">
329 |          <property name="spacing">
330 |           <number>0</number>
331 |          </property>
332 |          <property name="rightMargin">
333 |           <number>0</number>
334 |          </property>
335 |          <item>
336 |           <widget class="QWidget" name="pHSV" native="true">
337 |            <property name="sizePolicy">
338 |             <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
339 |              <horstretch>0</horstretch>
340 |              <verstretch>0</verstretch>
341 |             </sizepolicy>
342 |            </property>
343 |            <property name="minimumSize">
344 |             <size>
345 |              <width>0</width>
346 |              <height>0</height>
347 |             </size>
348 |            </property>
349 |            <layout class="QHBoxLayout" name="horizontalLayout_4">
350 |             <property name="spacing">
351 |              <number>10</number>
352 |             </property>
353 |             <property name="leftMargin">
354 |              <number>0</number>
355 |             </property>
356 |             <property name="topMargin">
357 |              <number>0</number>
358 |             </property>
359 |             <property name="rightMargin">
360 |              <number>0</number>
361 |             </property>
362 |             <property name="bottomMargin">
363 |              <number>0</number>
364 |             </property>
365 |             <item>
366 |              <widget class="QPushButton" name="bHSV">
367 |               <property name="sizePolicy">
368 |                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
369 |                 <horstretch>0</horstretch>
370 |                 <verstretch>0</verstretch>
371 |                </sizepolicy>
372 |               </property>
373 |               <property name="minimumSize">
374 |                <size>
375 |                 <width>110</width>
376 |                 <height>36</height>
377 |                </size>
378 |               </property>
379 |               <property name="font">
380 |                <font>
381 |                 <family>Trebuchet MS</family>
382 |                 <pointsize>11</pointsize>
383 |                 <weight>75</weight>
384 |                 <italic>false</italic>
385 |                 <bold>true</bold>
386 |                </font>
387 |               </property>
388 |               <property name="text">
389 |                <string>HSV</string>
390 |               </property>
391 |              </widget>
392 |             </item>
393 |             <item alignment="Qt::AlignLeft">
394 |              <widget class="ColorText" name="leHSV">
395 |               <property name="sizePolicy">
396 |                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
397 |                 <horstretch>0</horstretch>
398 |                 <verstretch>0</verstretch>
399 |                </sizepolicy>
400 |               </property>
401 |               <property name="minimumSize">
402 |                <size>
403 |                 <width>160</width>
404 |                 <height>36</height>
405 |                </size>
406 |               </property>
407 |               <property name="font">
408 |                <font>
409 |                 <family>Consolas</family>
410 |                 <pointsize>12</pointsize>
411 |                 <weight>75</weight>
412 |                 <bold>true</bold>
413 |                </font>
414 |               </property>
415 |               <property name="styleSheet">
416 |                <string notr="true"/>
417 |               </property>
418 |               <property name="text">
419 |                <string/>
420 |               </property>
421 |               <property name="readOnly">
422 |                <bool>false</bool>
423 |               </property>
424 |              </widget>
425 |             </item>
426 |            </layout>
427 |           </widget>
428 |          </item>
429 |          <item>
430 |           <spacer name="verticalSpacer_5">
431 |            <property name="orientation">
432 |             <enum>Qt::Vertical</enum>
433 |            </property>
434 |            <property name="sizeType">
435 |             <enum>QSizePolicy::Fixed</enum>
436 |            </property>
437 |            <property name="sizeHint" stdset="0">
438 |             <size>
439 |              <width>20</width>
440 |              <height>30</height>
441 |             </size>
442 |            </property>
443 |           </spacer>
444 |          </item>
445 |          <item>
446 |           <widget class="QWidget" name="pRGB" native="true">
447 |            <property name="sizePolicy">
448 |             <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
449 |              <horstretch>0</horstretch>
450 |              <verstretch>0</verstretch>
451 |             </sizepolicy>
452 |            </property>
453 |            <property name="minimumSize">
454 |             <size>
455 |              <width>0</width>
456 |              <height>0</height>
457 |             </size>
458 |            </property>
459 |            <layout class="QHBoxLayout" name="horizontalLayout_3">
460 |             <property name="spacing">
461 |              <number>10</number>
462 |             </property>
463 |             <property name="leftMargin">
464 |              <number>0</number>
465 |             </property>
466 |             <property name="topMargin">
467 |              <number>0</number>
468 |             </property>
469 |             <property name="rightMargin">
470 |              <number>0</number>
471 |             </property>
472 |             <property name="bottomMargin">
473 |              <number>0</number>
474 |             </property>
475 |             <item>
476 |              <widget class="QPushButton" name="bRGB">
477 |               <property name="sizePolicy">
478 |                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
479 |                 <horstretch>0</horstretch>
480 |                 <verstretch>0</verstretch>
481 |                </sizepolicy>
482 |               </property>
483 |               <property name="minimumSize">
484 |                <size>
485 |                 <width>110</width>
486 |                 <height>36</height>
487 |                </size>
488 |               </property>
489 |               <property name="font">
490 |                <font>
491 |                 <family>Trebuchet MS</family>
492 |                 <pointsize>11</pointsize>
493 |                 <weight>75</weight>
494 |                 <italic>false</italic>
495 |                 <bold>true</bold>
496 |                </font>
497 |               </property>
498 |               <property name="text">
499 |                <string>RGB</string>
500 |               </property>
501 |              </widget>
502 |             </item>
503 |             <item>
504 |              <widget class="ColorText" name="leRGB">
505 |               <property name="sizePolicy">
506 |                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
507 |                 <horstretch>0</horstretch>
508 |                 <verstretch>0</verstretch>
509 |                </sizepolicy>
510 |               </property>
511 |               <property name="minimumSize">
512 |                <size>
513 |                 <width>160</width>
514 |                 <height>36</height>
515 |                </size>
516 |               </property>
517 |               <property name="font">
518 |                <font>
519 |                 <family>Consolas</family>
520 |                 <pointsize>12</pointsize>
521 |                 <weight>75</weight>
522 |                 <bold>true</bold>
523 |                </font>
524 |               </property>
525 |               <property name="styleSheet">
526 |                <string notr="true"/>
527 |               </property>
528 |               <property name="text">
529 |                <string/>
530 |               </property>
531 |              </widget>
532 |             </item>
533 |            </layout>
534 |           </widget>
535 |          </item>
536 |          <item>
537 |           <spacer name="verticalSpacer_6">
538 |            <property name="orientation">
539 |             <enum>Qt::Vertical</enum>
540 |            </property>
541 |            <property name="sizeType">
542 |             <enum>QSizePolicy::Fixed</enum>
543 |            </property>
544 |            <property name="sizeHint" stdset="0">
545 |             <size>
546 |              <width>20</width>
547 |              <height>30</height>
548 |             </size>
549 |            </property>
550 |           </spacer>
551 |          </item>
552 |          <item>
553 |           <widget class="QWidget" name="pCMYK" native="true">
554 |            <property name="sizePolicy">
555 |             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
556 |              <horstretch>0</horstretch>
557 |              <verstretch>0</verstretch>
558 |             </sizepolicy>
559 |            </property>
560 |            <property name="minimumSize">
561 |             <size>
562 |              <width>0</width>
563 |              <height>0</height>
564 |             </size>
565 |            </property>
566 |            <layout class="QHBoxLayout" name="horizontalLayout_2">
567 |             <property name="spacing">
568 |              <number>10</number>
569 |             </property>
570 |             <property name="leftMargin">
571 |              <number>0</number>
572 |             </property>
573 |             <property name="topMargin">
574 |              <number>0</number>
575 |             </property>
576 |             <property name="rightMargin">
577 |              <number>0</number>
578 |             </property>
579 |             <property name="bottomMargin">
580 |              <number>0</number>
581 |             </property>
582 |             <item>
583 |              <widget class="QPushButton" name="bCMYK">
584 |               <property name="sizePolicy">
585 |                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
586 |                 <horstretch>0</horstretch>
587 |                 <verstretch>0</verstretch>
588 |                </sizepolicy>
589 |               </property>
590 |               <property name="minimumSize">
591 |                <size>
592 |                 <width>110</width>
593 |                 <height>36</height>
594 |                </size>
595 |               </property>
596 |               <property name="font">
597 |                <font>
598 |                 <family>Trebuchet MS</family>
599 |                 <pointsize>11</pointsize>
600 |                 <weight>75</weight>
601 |                 <italic>false</italic>
602 |                 <bold>true</bold>
603 |                </font>
604 |               </property>
605 |               <property name="text">
606 |                <string>CMYK</string>
607 |               </property>
608 |              </widget>
609 |             </item>
610 |             <item>
611 |              <widget class="ColorText" name="leCMYK">
612 |               <property name="sizePolicy">
613 |                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
614 |                 <horstretch>0</horstretch>
615 |                 <verstretch>0</verstretch>
616 |                </sizepolicy>
617 |               </property>
618 |               <property name="minimumSize">
619 |                <size>
620 |                 <width>160</width>
621 |                 <height>36</height>
622 |                </size>
623 |               </property>
624 |               <property name="font">
625 |                <font>
626 |                 <family>Consolas</family>
627 |                 <pointsize>12</pointsize>
628 |                 <weight>75</weight>
629 |                 <bold>true</bold>
630 |                </font>
631 |               </property>
632 |               <property name="styleSheet">
633 |                <string notr="true"/>
634 |               </property>
635 |               <property name="text">
636 |                <string/>
637 |               </property>
638 |              </widget>
639 |             </item>
640 |            </layout>
641 |           </widget>
642 |          </item>
643 |          <item>
644 |           <spacer name="verticalSpacer_4">
645 |            <property name="orientation">
646 |             <enum>Qt::Vertical</enum>
647 |            </property>
648 |            <property name="sizeType">
649 |             <enum>QSizePolicy::Fixed</enum>
650 |            </property>
651 |            <property name="sizeHint" stdset="0">
652 |             <size>
653 |              <width>30</width>
654 |              <height>30</height>
655 |             </size>
656 |            </property>
657 |           </spacer>
658 |          </item>
659 |          <item alignment="Qt::AlignTop">
660 |           <widget class="QWidget" name="pHex" native="true">
661 |            <property name="sizePolicy">
662 |             <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
663 |              <horstretch>0</horstretch>
664 |              <verstretch>0</verstretch>
665 |             </sizepolicy>
666 |            </property>
667 |            <property name="minimumSize">
668 |             <size>
669 |              <width>0</width>
670 |              <height>0</height>
671 |             </size>
672 |            </property>
673 |            <layout class="QGridLayout" name="gridLayout_2">
674 |             <property name="leftMargin">
675 |              <number>0</number>
676 |             </property>
677 |             <property name="topMargin">
678 |              <number>0</number>
679 |             </property>
680 |             <property name="rightMargin">
681 |              <number>0</number>
682 |             </property>
683 |             <property name="bottomMargin">
684 |              <number>0</number>
685 |             </property>
686 |             <property name="spacing">
687 |              <number>10</number>
688 |             </property>
689 |             <item row="0" column="1">
690 |              <widget class="ColorText" name="leHex">
691 |               <property name="sizePolicy">
692 |                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
693 |                 <horstretch>0</horstretch>
694 |                 <verstretch>0</verstretch>
695 |                </sizepolicy>
696 |               </property>
697 |               <property name="minimumSize">
698 |                <size>
699 |                 <width>160</width>
700 |                 <height>36</height>
701 |                </size>
702 |               </property>
703 |               <property name="font">
704 |                <font>
705 |                 <family>Consolas</family>
706 |                 <pointsize>12</pointsize>
707 |                 <weight>75</weight>
708 |                 <bold>true</bold>
709 |                </font>
710 |               </property>
711 |               <property name="styleSheet">
712 |                <string notr="true"/>
713 |               </property>
714 |               <property name="text">
715 |                <string/>
716 |               </property>
717 |              </widget>
718 |             </item>
719 |             <item row="1" column="1">
720 |              <widget class="QPushButton" name="bPasteHex">
721 |               <property name="minimumSize">
722 |                <size>
723 |                 <width>0</width>
724 |                 <height>36</height>
725 |                </size>
726 |               </property>
727 |               <property name="font">
728 |                <font>
729 |                 <family>Trebuchet MS</family>
730 |                 <pointsize>11</pointsize>
731 |                 <weight>75</weight>
732 |                 <italic>false</italic>
733 |                 <bold>true</bold>
734 |                </font>
735 |               </property>
736 |               <property name="text">
737 |                <string>Paste Hex</string>
738 |               </property>
739 |              </widget>
740 |             </item>
741 |             <item row="0" column="0">
742 |              <widget class="QPushButton" name="bHex">
743 |               <property name="sizePolicy">
744 |                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
745 |                 <horstretch>0</horstretch>
746 |                 <verstretch>0</verstretch>
747 |                </sizepolicy>
748 |               </property>
749 |               <property name="minimumSize">
750 |                <size>
751 |                 <width>110</width>
752 |                 <height>36</height>
753 |                </size>
754 |               </property>
755 |               <property name="font">
756 |                <font>
757 |                 <family>Trebuchet MS</family>
758 |                 <pointsize>11</pointsize>
759 |                 <weight>75</weight>
760 |                 <italic>false</italic>
761 |                 <bold>true</bold>
762 |                </font>
763 |               </property>
764 |               <property name="text">
765 |                <string>Hex</string>
766 |               </property>
767 |              </widget>
768 |             </item>
769 |             <item row="1" column="0">
770 |              <widget class="QPushButton" name="bHexHash">
771 |               <property name="sizePolicy">
772 |                <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
773 |                 <horstretch>0</horstretch>
774 |                 <verstretch>0</verstretch>
775 |                </sizepolicy>
776 |               </property>
777 |               <property name="minimumSize">
778 |                <size>
779 |                 <width>110</width>
780 |                 <height>36</height>
781 |                </size>
782 |               </property>
783 |               <property name="font">
784 |                <font>
785 |                 <family>Trebuchet MS</family>
786 |                 <pointsize>11</pointsize>
787 |                 <weight>75</weight>
788 |                 <italic>false</italic>
789 |                 <bold>true</bold>
790 |                </font>
791 |               </property>
792 |               <property name="text">
793 |                <string>Hex #</string>
794 |               </property>
795 |              </widget>
796 |             </item>
797 |            </layout>
798 |           </widget>
799 |          </item>
800 |          <item>
801 |           <spacer name="verticalSpacer_7">
802 |            <property name="orientation">
803 |             <enum>Qt::Vertical</enum>
804 |            </property>
805 |            <property name="sizeType">
806 |             <enum>QSizePolicy::Expanding</enum>
807 |            </property>
808 |            <property name="sizeHint" stdset="0">
809 |             <size>
810 |              <width>20</width>
811 |              <height>32</height>
812 |             </size>
813 |            </property>
814 |           </spacer>
815 |          </item>
816 |          <item>
817 |           <widget class="QWidget" name="widget_2" native="true">
818 |            <property name="sizePolicy">
819 |             <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
820 |              <horstretch>0</horstretch>
821 |              <verstretch>0</verstretch>
822 |             </sizepolicy>
823 |            </property>
824 |            <property name="minimumSize">
825 |             <size>
826 |              <width>0</width>
827 |              <height>50</height>
828 |             </size>
829 |            </property>
830 |            <layout class="QHBoxLayout" name="horizontalLayout_5">
831 |             <property name="spacing">
832 |              <number>5</number>
833 |             </property>
834 |             <property name="leftMargin">
835 |              <number>0</number>
836 |             </property>
837 |             <property name="topMargin">
838 |              <number>0</number>
839 |             </property>
840 |             <property name="rightMargin">
841 |              <number>0</number>
842 |             </property>
843 |             <property name="bottomMargin">
844 |              <number>0</number>
845 |             </property>
846 |            </layout>
847 |           </widget>
848 |          </item>
849 |          <item>
850 |           <spacer name="vSpacer1">
851 |            <property name="orientation">
852 |             <enum>Qt::Vertical</enum>
853 |            </property>
854 |            <property name="sizeType">
855 |             <enum>QSizePolicy::Fixed</enum>
856 |            </property>
857 |            <property name="sizeHint" stdset="0">
858 |             <size>
859 |              <width>20</width>
860 |              <height>0</height>
861 |             </size>
862 |            </property>
863 |           </spacer>
864 |          </item>
865 |         </layout>
866 |        </item>
867 |        <item>
868 |         <spacer name="rightHSpacer">
869 |          <property name="orientation">
870 |           <enum>Qt::Horizontal</enum>
871 |          </property>
872 |          <property name="sizeType">
873 |           <enum>QSizePolicy::Minimum</enum>
874 |          </property>
875 |          <property name="sizeHint" stdset="0">
876 |           <size>
877 |            <width>10</width>
878 |            <height>18</height>
879 |           </size>
880 |          </property>
881 |         </spacer>
882 |        </item>
883 |       </layout>
884 |      </widget>
885 |     </item>
886 |     <item>
887 |      <spacer name="verticalSpacer">
888 |       <property name="orientation">
889 |        <enum>Qt::Vertical</enum>
890 |       </property>
891 |       <property name="sizeType">
892 |        <enum>QSizePolicy::Fixed</enum>
893 |       </property>
894 |       <property name="sizeHint" stdset="0">
895 |        <size>
896 |         <width>20</width>
897 |         <height>0</height>
898 |        </size>
899 |       </property>
900 |      </spacer>
901 |     </item>
902 |     <item>
903 |      <spacer name="bottomVSpacer">
904 |       <property name="orientation">
905 |        <enum>Qt::Vertical</enum>
906 |       </property>
907 |       <property name="sizeType">
908 |        <enum>QSizePolicy::MinimumExpanding</enum>
909 |       </property>
910 |       <property name="sizeHint" stdset="0">
911 |        <size>
912 |         <width>20</width>
913 |         <height>14</height>
914 |        </size>
915 |       </property>
916 |      </spacer>
917 |     </item>
918 |    </layout>
919 |   </widget>
920 |   <widget class="QStatusBar" name="statusBar">
921 |    <property name="font">
922 |     <font>
923 |      <family>Lucida Sans Unicode</family>
924 |      <pointsize>9</pointsize>
925 |      <weight>75</weight>
926 |      <bold>true</bold>
927 |     </font>
928 |    </property>
929 |    <property name="autoFillBackground">
930 |     <bool>false</bool>
931 |    </property>
932 |    <property name="styleSheet">
933 |     <string notr="true">border-top:1px dotted #444;</string>
934 |    </property>
935 |    <property name="sizeGripEnabled">
936 |     <bool>false</bool>
937 |    </property>
938 |   </widget>
939 |  </widget>
940 |  <layoutdefault spacing="6" margin="11"/>
941 |  <customwidgets>
942 |   <customwidget>
943 |    <class>HSelector</class>
944 |    <extends>QWidget</extends>
945 |    <header>Widgets/ColorWidgets/hselector.h</header>
946 |    <container>1</container>
947 |   </customwidget>
948 |   <customwidget>
949 |    <class>SVSelector</class>
950 |    <extends>QWidget</extends>
951 |    <header>Widgets/ColorWidgets/svselector.h</header>
952 |    <container>1</container>
953 |   </customwidget>
954 |   <customwidget>
955 |    <class>ColorSample</class>
956 |    <extends>QWidget</extends>
957 |    <header>Widgets/ColorWidgets/colorsample.h</header>
958 |    <container>1</container>
959 |   </customwidget>
960 |   <customwidget>
961 |    <class>ColorText</class>
962 |    <extends>QLineEdit</extends>
963 |    <header>Widgets/colortext.h</header>
964 |   </customwidget>
965 |  </customwidgets>
966 |  <tabstops>
967 |   <tabstop>bHSV</tabstop>
968 |   <tabstop>bRGB</tabstop>
969 |   <tabstop>bCMYK</tabstop>
970 |   <tabstop>bHex</tabstop>
971 |   <tabstop>bHexHash</tabstop>
972 |   <tabstop>leHSV</tabstop>
973 |   <tabstop>leRGB</tabstop>
974 |   <tabstop>leCMYK</tabstop>
975 |   <tabstop>leHex</tabstop>
976 |   <tabstop>bPasteHex</tabstop>
977 |  </tabstops>
978 |  <resources/>
979 |  <connections/>
980 | </ui>
981 | 


--------------------------------------------------------------------------------
/files/mockup.bmml:
--------------------------------------------------------------------------------
  1 | <mockup version="1.0" skin="sketch" fontFace="Balsamiq Sans" measuredW="2071" measuredH="935" mockupW="2051" mockupH="925">
  2 |   <controls>
  3 |     <control controlID="120" controlTypeID="__group__" x="20" y="10" w="620" h="439" measuredW="620" measuredH="439" zOrder="0" locked="false" isInGroup="-1">
  4 |       <groupChildrenDescriptors>
  5 |         <control controlID="0" controlTypeID="com.balsamiq.mockups::TitleWindow" x="0" y="0" w="620" h="439" measuredW="450" measuredH="400" zOrder="0" locked="false" isInGroup="120">
  6 |           <controlProperties>
  7 |             <close>true</close>
  8 |             <maximizeRestore>false</maximizeRestore>
  9 |             <minimize>true</minimize>
 10 |             <text>QtColorPicker</text>
 11 |             <verticalScrollbar>false</verticalScrollbar>
 12 |           </controlProperties>
 13 |         </control>
 14 |         <control controlID="1" controlTypeID="__group__" x="15" y="39" w="315" h="360" measuredW="315" measuredH="360" zOrder="1" locked="false" isInGroup="120">
 15 |           <groupChildrenDescriptors>
 16 |             <control controlID="0" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="0" w="256" h="256" measuredW="100" measuredH="70" zOrder="0" locked="false" isInGroup="1"/>
 17 |             <control controlID="1" controlTypeID="com.balsamiq.mockups::Canvas" x="275" y="0" w="40" h="360" measuredW="100" measuredH="70" zOrder="1" locked="false" isInGroup="1"/>
 18 |             <control controlID="2" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="287" w="256" h="73" measuredW="100" measuredH="70" zOrder="2" locked="false" isInGroup="1"/>
 19 |           </groupChildrenDescriptors>
 20 |         </control>
 21 |         <control controlID="2" controlTypeID="__group__" x="352" y="39" w="251" h="298" measuredW="251" measuredH="298" zOrder="2" locked="false" isInGroup="120">
 22 |           <groupChildrenDescriptors>
 23 |             <control controlID="0" controlTypeID="__group__" x="0" y="0" w="251" h="56" measuredW="251" measuredH="56" zOrder="0" locked="false" isInGroup="2">
 24 |               <groupChildrenDescriptors>
 25 |                 <control controlID="0" controlTypeID="__group__" x="0" y="0" w="143" h="49" measuredW="143" measuredH="49" zOrder="0" locked="false" isInGroup="0">
 26 |                   <groupChildrenDescriptors>
 27 |                     <control controlID="0" controlTypeID="com.balsamiq.mockups::Label" x="0" y="0" w="-1" h="-1" measuredW="27" measuredH="21" zOrder="0" locked="false" isInGroup="0">
 28 |                       <controlProperties>
 29 |                         <text>HSV</text>
 30 |                       </controlProperties>
 31 |                     </control>
 32 |                     <control controlID="1" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="21" w="143" h="-1" measuredW="86" measuredH="28" zOrder="1" locked="false" isInGroup="0">
 33 |                       <controlProperties>
 34 |                         <size>14</size>
 35 |                         <text>257%2036%20185</text>
 36 |                       </controlProperties>
 37 |                     </control>
 38 |                   </groupChildrenDescriptors>
 39 |                 </control>
 40 |                 <control controlID="1" controlTypeID="com.balsamiq.mockups::Button" x="158" y="21" w="93" h="35" measuredW="53" measuredH="27" zOrder="1" locked="false" isInGroup="0">
 41 |                   <controlProperties>
 42 |                     <text>Copy</text>
 43 |                   </controlProperties>
 44 |                 </control>
 45 |               </groupChildrenDescriptors>
 46 |             </control>
 47 |             <control controlID="1" controlTypeID="__group__" x="0" y="64" w="251" h="56" measuredW="251" measuredH="56" zOrder="1" locked="false" isInGroup="2">
 48 |               <groupChildrenDescriptors>
 49 |                 <control controlID="0" controlTypeID="__group__" x="0" y="0" w="143" h="49" measuredW="143" measuredH="49" zOrder="0" locked="false" isInGroup="1">
 50 |                   <groupChildrenDescriptors>
 51 |                     <control controlID="0" controlTypeID="com.balsamiq.mockups::Label" x="0" y="0" w="-1" h="-1" measuredW="27" measuredH="21" zOrder="0" locked="false" isInGroup="0">
 52 |                       <controlProperties>
 53 |                         <text>RGB</text>
 54 |                       </controlProperties>
 55 |                     </control>
 56 |                     <control controlID="1" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="21" w="143" h="-1" measuredW="72" measuredH="28" zOrder="1" locked="false" isInGroup="0">
 57 |                       <controlProperties>
 58 |                         <size>14</size>
 59 |                         <text>255%209%2067</text>
 60 |                       </controlProperties>
 61 |                     </control>
 62 |                   </groupChildrenDescriptors>
 63 |                 </control>
 64 |                 <control controlID="1" controlTypeID="com.balsamiq.mockups::Button" x="158" y="21" w="93" h="35" measuredW="53" measuredH="27" zOrder="1" locked="false" isInGroup="1">
 65 |                   <controlProperties>
 66 |                     <text>Copy</text>
 67 |                   </controlProperties>
 68 |                 </control>
 69 |               </groupChildrenDescriptors>
 70 |             </control>
 71 |             <control controlID="2" controlTypeID="__group__" x="0" y="128" w="251" h="56" measuredW="251" measuredH="56" zOrder="2" locked="false" isInGroup="2">
 72 |               <groupChildrenDescriptors>
 73 |                 <control controlID="0" controlTypeID="__group__" x="0" y="0" w="143" h="49" measuredW="143" measuredH="49" zOrder="0" locked="false" isInGroup="2">
 74 |                   <groupChildrenDescriptors>
 75 |                     <control controlID="0" controlTypeID="com.balsamiq.mockups::Label" x="0" y="0" w="-1" h="-1" measuredW="38" measuredH="21" zOrder="0" locked="false" isInGroup="0">
 76 |                       <controlProperties>
 77 |                         <text>CMYK</text>
 78 |                       </controlProperties>
 79 |                     </control>
 80 |                     <control controlID="1" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="21" w="143" h="-1" measuredW="100" measuredH="28" zOrder="1" locked="false" isInGroup="0">
 81 |                       <controlProperties>
 82 |                         <size>14</size>
 83 |                         <text>98%20100%2056%2032</text>
 84 |                       </controlProperties>
 85 |                     </control>
 86 |                   </groupChildrenDescriptors>
 87 |                 </control>
 88 |                 <control controlID="1" controlTypeID="com.balsamiq.mockups::Button" x="158" y="21" w="93" h="35" measuredW="53" measuredH="27" zOrder="1" locked="false" isInGroup="2">
 89 |                   <controlProperties>
 90 |                     <text>Copy</text>
 91 |                   </controlProperties>
 92 |                 </control>
 93 |               </groupChildrenDescriptors>
 94 |             </control>
 95 |             <control controlID="3" controlTypeID="__group__" x="0" y="192" w="251" h="106" measuredW="251" measuredH="106" zOrder="3" locked="false" isInGroup="2">
 96 |               <groupChildrenDescriptors>
 97 |                 <control controlID="0" controlTypeID="__group__" x="0" y="0" w="143" h="49" measuredW="143" measuredH="49" zOrder="0" locked="false" isInGroup="3">
 98 |                   <groupChildrenDescriptors>
 99 |                     <control controlID="0" controlTypeID="com.balsamiq.mockups::Label" x="0" y="0" w="-1" h="-1" measuredW="23" measuredH="21" zOrder="0" locked="false" isInGroup="0">
100 |                       <controlProperties>
101 |                         <text>Hex</text>
102 |                       </controlProperties>
103 |                     </control>
104 |                     <control controlID="1" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="21" w="143" h="-1" measuredW="64" measuredH="28" zOrder="1" locked="false" isInGroup="0">
105 |                       <controlProperties>
106 |                         <backgroundAlpha>1</backgroundAlpha>
107 |                         <size>14</size>
108 |                         <text>a86d52</text>
109 |                       </controlProperties>
110 |                     </control>
111 |                   </groupChildrenDescriptors>
112 |                 </control>
113 |                 <control controlID="1" controlTypeID="com.balsamiq.mockups::Button" x="158" y="21" w="93" h="35" measuredW="53" measuredH="27" zOrder="1" locked="false" isInGroup="3">
114 |                   <controlProperties>
115 |                     <text>Copy</text>
116 |                   </controlProperties>
117 |                 </control>
118 |                 <control controlID="2" controlTypeID="com.balsamiq.mockups::Button" x="158" y="71" w="93" h="35" measuredW="65" measuredH="27" zOrder="2" locked="false" isInGroup="3">
119 |                   <controlProperties>
120 |                     <text>Copy%20%23</text>
121 |                   </controlProperties>
122 |                 </control>
123 |               </groupChildrenDescriptors>
124 |             </control>
125 |           </groupChildrenDescriptors>
126 |         </control>
127 |       </groupChildrenDescriptors>
128 |     </control>
129 |     <control controlID="121" controlTypeID="__group__" x="698" y="10" w="620" h="439" measuredW="620" measuredH="439" zOrder="1" locked="false" isInGroup="-1">
130 |       <groupChildrenDescriptors>
131 |         <control controlID="0" controlTypeID="com.balsamiq.mockups::TitleWindow" x="0" y="0" w="620" h="439" measuredW="450" measuredH="400" zOrder="0" locked="false" isInGroup="121">
132 |           <controlProperties>
133 |             <close>true</close>
134 |             <maximizeRestore>false</maximizeRestore>
135 |             <minimize>true</minimize>
136 |             <text>QtColorPicker</text>
137 |             <verticalScrollbar>false</verticalScrollbar>
138 |           </controlProperties>
139 |         </control>
140 |         <control controlID="1" controlTypeID="__group__" x="15" y="39" w="315" h="360" measuredW="315" measuredH="360" zOrder="1" locked="false" isInGroup="121">
141 |           <groupChildrenDescriptors>
142 |             <control controlID="0" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="0" w="256" h="256" measuredW="100" measuredH="70" zOrder="0" locked="false" isInGroup="1"/>
143 |             <control controlID="1" controlTypeID="com.balsamiq.mockups::Canvas" x="275" y="0" w="40" h="360" measuredW="100" measuredH="70" zOrder="1" locked="false" isInGroup="1"/>
144 |             <control controlID="2" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="287" w="256" h="73" measuredW="100" measuredH="70" zOrder="2" locked="false" isInGroup="1"/>
145 |           </groupChildrenDescriptors>
146 |         </control>
147 |         <control controlID="2" controlTypeID="__group__" x="460" y="39" w="143" h="241" measuredW="143" measuredH="241" zOrder="2" locked="false" isInGroup="121">
148 |           <groupChildrenDescriptors>
149 |             <control controlID="0" controlTypeID="__group__" x="0" y="0" w="143" h="49" measuredW="143" measuredH="49" zOrder="0" locked="false" isInGroup="2">
150 |               <groupChildrenDescriptors>
151 |                 <control controlID="0" controlTypeID="com.balsamiq.mockups::Label" x="0" y="0" w="-1" h="-1" measuredW="27" measuredH="21" zOrder="0" locked="false" isInGroup="0">
152 |                   <controlProperties>
153 |                     <text>HSV</text>
154 |                   </controlProperties>
155 |                 </control>
156 |                 <control controlID="1" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="21" w="143" h="-1" measuredW="86" measuredH="28" zOrder="1" locked="false" isInGroup="0">
157 |                   <controlProperties>
158 |                     <size>14</size>
159 |                     <text>257%2036%20185</text>
160 |                   </controlProperties>
161 |                 </control>
162 |               </groupChildrenDescriptors>
163 |             </control>
164 |             <control controlID="1" controlTypeID="__group__" x="0" y="64" w="143" h="49" measuredW="143" measuredH="49" zOrder="1" locked="false" isInGroup="2">
165 |               <groupChildrenDescriptors>
166 |                 <control controlID="0" controlTypeID="com.balsamiq.mockups::Label" x="0" y="0" w="-1" h="-1" measuredW="27" measuredH="21" zOrder="0" locked="false" isInGroup="1">
167 |                   <controlProperties>
168 |                     <text>RGB</text>
169 |                   </controlProperties>
170 |                 </control>
171 |                 <control controlID="1" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="21" w="143" h="-1" measuredW="72" measuredH="28" zOrder="1" locked="false" isInGroup="1">
172 |                   <controlProperties>
173 |                     <size>14</size>
174 |                     <text>255%209%2067</text>
175 |                   </controlProperties>
176 |                 </control>
177 |               </groupChildrenDescriptors>
178 |             </control>
179 |             <control controlID="2" controlTypeID="__group__" x="0" y="128" w="143" h="49" measuredW="143" measuredH="49" zOrder="2" locked="false" isInGroup="2">
180 |               <groupChildrenDescriptors>
181 |                 <control controlID="0" controlTypeID="com.balsamiq.mockups::Label" x="0" y="0" w="-1" h="-1" measuredW="38" measuredH="21" zOrder="0" locked="false" isInGroup="2">
182 |                   <controlProperties>
183 |                     <text>CMYK</text>
184 |                   </controlProperties>
185 |                 </control>
186 |                 <control controlID="1" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="21" w="143" h="-1" measuredW="100" measuredH="28" zOrder="1" locked="false" isInGroup="2">
187 |                   <controlProperties>
188 |                     <size>14</size>
189 |                     <text>98%20100%2056%2032</text>
190 |                   </controlProperties>
191 |                 </control>
192 |               </groupChildrenDescriptors>
193 |             </control>
194 |             <control controlID="3" controlTypeID="__group__" x="0" y="192" w="143" h="49" measuredW="143" measuredH="49" zOrder="3" locked="false" isInGroup="2">
195 |               <groupChildrenDescriptors>
196 |                 <control controlID="0" controlTypeID="com.balsamiq.mockups::Label" x="0" y="0" w="-1" h="-1" measuredW="23" measuredH="21" zOrder="0" locked="false" isInGroup="3">
197 |                   <controlProperties>
198 |                     <text>Hex</text>
199 |                   </controlProperties>
200 |                 </control>
201 |                 <control controlID="1" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="21" w="143" h="-1" measuredW="64" measuredH="28" zOrder="1" locked="false" isInGroup="3">
202 |                   <controlProperties>
203 |                     <backgroundAlpha>1</backgroundAlpha>
204 |                     <size>14</size>
205 |                     <text>a86d52</text>
206 |                   </controlProperties>
207 |                 </control>
208 |               </groupChildrenDescriptors>
209 |             </control>
210 |           </groupChildrenDescriptors>
211 |         </control>
212 |         <control controlID="3" controlTypeID="com.balsamiq.mockups::Button" x="352" y="59" w="93" h="35" measuredW="53" measuredH="27" zOrder="3" locked="false" isInGroup="121">
213 |           <controlProperties>
214 |             <text>Copy</text>
215 |           </controlProperties>
216 |         </control>
217 |         <control controlID="4" controlTypeID="com.balsamiq.mockups::Button" x="352" y="123" w="93" h="35" measuredW="53" measuredH="27" zOrder="4" locked="false" isInGroup="121">
218 |           <controlProperties>
219 |             <text>Copy</text>
220 |           </controlProperties>
221 |         </control>
222 |         <control controlID="5" controlTypeID="com.balsamiq.mockups::Button" x="352" y="187" w="93" h="35" measuredW="53" measuredH="27" zOrder="5" locked="false" isInGroup="121">
223 |           <controlProperties>
224 |             <text>Copy</text>
225 |           </controlProperties>
226 |         </control>
227 |         <control controlID="6" controlTypeID="com.balsamiq.mockups::Button" x="352" y="251" w="93" h="35" measuredW="53" measuredH="27" zOrder="6" locked="false" isInGroup="121">
228 |           <controlProperties>
229 |             <text>Copy</text>
230 |           </controlProperties>
231 |         </control>
232 |         <control controlID="7" controlTypeID="com.balsamiq.mockups::Button" x="352" y="298" w="93" h="35" measuredW="65" measuredH="27" zOrder="7" locked="false" isInGroup="121">
233 |           <controlProperties>
234 |             <text>Copy%20%23</text>
235 |           </controlProperties>
236 |         </control>
237 |       </groupChildrenDescriptors>
238 |     </control>
239 |     <control controlID="122" controlTypeID="__group__" x="20" y="496" w="620" h="439" measuredW="620" measuredH="439" zOrder="2" locked="false" isInGroup="-1">
240 |       <groupChildrenDescriptors>
241 |         <control controlID="0" controlTypeID="com.balsamiq.mockups::TitleWindow" x="0" y="0" w="620" h="439" measuredW="450" measuredH="400" zOrder="0" locked="false" isInGroup="122">
242 |           <controlProperties>
243 |             <close>true</close>
244 |             <maximizeRestore>false</maximizeRestore>
245 |             <minimize>true</minimize>
246 |             <text>QtColorPicker</text>
247 |             <verticalScrollbar>false</verticalScrollbar>
248 |           </controlProperties>
249 |         </control>
250 |         <control controlID="1" controlTypeID="__group__" x="15" y="39" w="315" h="360" measuredW="315" measuredH="360" zOrder="1" locked="false" isInGroup="122">
251 |           <groupChildrenDescriptors>
252 |             <control controlID="0" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="0" w="256" h="256" measuredW="100" measuredH="70" zOrder="0" locked="false" isInGroup="1"/>
253 |             <control controlID="1" controlTypeID="com.balsamiq.mockups::Canvas" x="275" y="0" w="40" h="360" measuredW="100" measuredH="70" zOrder="1" locked="false" isInGroup="1"/>
254 |             <control controlID="2" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="287" w="256" h="73" measuredW="100" measuredH="70" zOrder="2" locked="false" isInGroup="1"/>
255 |           </groupChildrenDescriptors>
256 |         </control>
257 |         <control controlID="2" controlTypeID="com.balsamiq.mockups::Label" x="460" y="70" w="-1" h="-1" measuredW="27" measuredH="21" zOrder="2" locked="false" isInGroup="122">
258 |           <controlProperties>
259 |             <text>HSV</text>
260 |           </controlProperties>
261 |         </control>
262 |         <control controlID="3" controlTypeID="com.balsamiq.mockups::TextInput" x="460" y="40" w="143" h="-1" measuredW="86" measuredH="28" zOrder="3" locked="false" isInGroup="122">
263 |           <controlProperties>
264 |             <size>14</size>
265 |             <text>257%2036%20185</text>
266 |           </controlProperties>
267 |         </control>
268 |         <control controlID="4" controlTypeID="com.balsamiq.mockups::Label" x="460" y="136" w="-1" h="-1" measuredW="27" measuredH="21" zOrder="4" locked="false" isInGroup="122">
269 |           <controlProperties>
270 |             <text>RGB</text>
271 |           </controlProperties>
272 |         </control>
273 |         <control controlID="5" controlTypeID="com.balsamiq.mockups::TextInput" x="460" y="104" w="143" h="-1" measuredW="72" measuredH="28" zOrder="5" locked="false" isInGroup="122">
274 |           <controlProperties>
275 |             <size>14</size>
276 |             <text>255%209%2067</text>
277 |           </controlProperties>
278 |         </control>
279 |         <control controlID="6" controlTypeID="com.balsamiq.mockups::Label" x="460" y="199" w="-1" h="-1" measuredW="38" measuredH="21" zOrder="6" locked="false" isInGroup="122">
280 |           <controlProperties>
281 |             <text>CMYK</text>
282 |           </controlProperties>
283 |         </control>
284 |         <control controlID="7" controlTypeID="com.balsamiq.mockups::TextInput" x="460" y="168" w="143" h="-1" measuredW="100" measuredH="28" zOrder="7" locked="false" isInGroup="122">
285 |           <controlProperties>
286 |             <size>14</size>
287 |             <text>98%20100%2056%2032</text>
288 |           </controlProperties>
289 |         </control>
290 |         <control controlID="8" controlTypeID="com.balsamiq.mockups::Label" x="460" y="262" w="-1" h="-1" measuredW="23" measuredH="21" zOrder="8" locked="false" isInGroup="122">
291 |           <controlProperties>
292 |             <text>Hex</text>
293 |           </controlProperties>
294 |         </control>
295 |         <control controlID="9" controlTypeID="com.balsamiq.mockups::TextInput" x="460" y="232" w="143" h="-1" measuredW="64" measuredH="28" zOrder="9" locked="false" isInGroup="122">
296 |           <controlProperties>
297 |             <backgroundAlpha>1</backgroundAlpha>
298 |             <size>14</size>
299 |             <text>a86d52</text>
300 |           </controlProperties>
301 |         </control>
302 |         <control controlID="10" controlTypeID="com.balsamiq.mockups::Button" x="352" y="39" w="93" h="35" measuredW="53" measuredH="27" zOrder="10" locked="false" isInGroup="122">
303 |           <controlProperties>
304 |             <text>Copy</text>
305 |           </controlProperties>
306 |         </control>
307 |         <control controlID="11" controlTypeID="com.balsamiq.mockups::Button" x="352" y="103" w="93" h="35" measuredW="53" measuredH="27" zOrder="11" locked="false" isInGroup="122">
308 |           <controlProperties>
309 |             <text>Copy</text>
310 |           </controlProperties>
311 |         </control>
312 |         <control controlID="12" controlTypeID="com.balsamiq.mockups::Button" x="352" y="167" w="93" h="35" measuredW="53" measuredH="27" zOrder="12" locked="false" isInGroup="122">
313 |           <controlProperties>
314 |             <text>Copy</text>
315 |           </controlProperties>
316 |         </control>
317 |         <control controlID="13" controlTypeID="com.balsamiq.mockups::Button" x="352" y="231" w="93" h="35" measuredW="53" measuredH="27" zOrder="13" locked="false" isInGroup="122">
318 |           <controlProperties>
319 |             <text>Copy</text>
320 |           </controlProperties>
321 |         </control>
322 |         <control controlID="14" controlTypeID="com.balsamiq.mockups::Button" x="352" y="278" w="93" h="35" measuredW="65" measuredH="27" zOrder="14" locked="false" isInGroup="122">
323 |           <controlProperties>
324 |             <text>Copy%20%23</text>
325 |           </controlProperties>
326 |         </control>
327 |       </groupChildrenDescriptors>
328 |     </control>
329 |     <control controlID="123" controlTypeID="__group__" x="698" y="496" w="664" h="439" measuredW="664" measuredH="439" zOrder="3" locked="false" isInGroup="-1">
330 |       <groupChildrenDescriptors>
331 |         <control controlID="0" controlTypeID="com.balsamiq.mockups::TitleWindow" x="0" y="0" w="664" h="439" measuredW="450" measuredH="400" zOrder="0" locked="false" isInGroup="123">
332 |           <controlProperties>
333 |             <close>true</close>
334 |             <maximizeRestore>false</maximizeRestore>
335 |             <minimize>true</minimize>
336 |             <text>QtColorPicker</text>
337 |             <verticalScrollbar>false</verticalScrollbar>
338 |           </controlProperties>
339 |         </control>
340 |         <control controlID="1" controlTypeID="__group__" x="15" y="39" w="315" h="360" measuredW="315" measuredH="360" zOrder="1" locked="false" isInGroup="123">
341 |           <groupChildrenDescriptors>
342 |             <control controlID="0" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="0" w="256" h="256" measuredW="100" measuredH="70" zOrder="0" locked="false" isInGroup="1"/>
343 |             <control controlID="1" controlTypeID="com.balsamiq.mockups::Canvas" x="275" y="0" w="40" h="360" measuredW="100" measuredH="70" zOrder="1" locked="false" isInGroup="1"/>
344 |             <control controlID="2" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="287" w="256" h="73" measuredW="100" measuredH="70" zOrder="2" locked="false" isInGroup="1"/>
345 |           </groupChildrenDescriptors>
346 |         </control>
347 |         <control controlID="2" controlTypeID="com.balsamiq.mockups::Label" x="611" y="40" w="-1" h="-1" measuredW="27" measuredH="21" zOrder="2" locked="false" isInGroup="123">
348 |           <controlProperties>
349 |             <text>HSV</text>
350 |           </controlProperties>
351 |         </control>
352 |         <control controlID="3" controlTypeID="com.balsamiq.mockups::TextInput" x="460" y="40" w="143" h="-1" measuredW="86" measuredH="28" zOrder="3" locked="false" isInGroup="123">
353 |           <controlProperties>
354 |             <size>14</size>
355 |             <text>257%2036%20185</text>
356 |           </controlProperties>
357 |         </control>
358 |         <control controlID="4" controlTypeID="com.balsamiq.mockups::Label" x="611" y="97" w="-1" h="-1" measuredW="27" measuredH="21" zOrder="4" locked="false" isInGroup="123">
359 |           <controlProperties>
360 |             <text>RGB</text>
361 |           </controlProperties>
362 |         </control>
363 |         <control controlID="5" controlTypeID="com.balsamiq.mockups::TextInput" x="460" y="97" w="143" h="-1" measuredW="72" measuredH="28" zOrder="5" locked="false" isInGroup="123">
364 |           <controlProperties>
365 |             <size>14</size>
366 |             <text>255%209%2067</text>
367 |           </controlProperties>
368 |         </control>
369 |         <control controlID="6" controlTypeID="com.balsamiq.mockups::Label" x="611" y="155" w="-1" h="-1" measuredW="38" measuredH="21" zOrder="6" locked="false" isInGroup="123">
370 |           <controlProperties>
371 |             <text>CMYK</text>
372 |           </controlProperties>
373 |         </control>
374 |         <control controlID="7" controlTypeID="com.balsamiq.mockups::TextInput" x="460" y="155" w="143" h="-1" measuredW="100" measuredH="28" zOrder="7" locked="false" isInGroup="123">
375 |           <controlProperties>
376 |             <size>14</size>
377 |             <text>98%20100%2056%2032</text>
378 |           </controlProperties>
379 |         </control>
380 |         <control controlID="8" controlTypeID="com.balsamiq.mockups::Label" x="611" y="212" w="-1" h="-1" measuredW="23" measuredH="21" zOrder="8" locked="false" isInGroup="123">
381 |           <controlProperties>
382 |             <text>Hex</text>
383 |           </controlProperties>
384 |         </control>
385 |         <control controlID="9" controlTypeID="com.balsamiq.mockups::TextInput" x="460" y="212" w="143" h="-1" measuredW="64" measuredH="28" zOrder="9" locked="false" isInGroup="123">
386 |           <controlProperties>
387 |             <backgroundAlpha>1</backgroundAlpha>
388 |             <size>14</size>
389 |             <text>a86d52</text>
390 |           </controlProperties>
391 |         </control>
392 |         <control controlID="10" controlTypeID="com.balsamiq.mockups::Button" x="352" y="39" w="93" h="35" measuredW="53" measuredH="27" zOrder="10" locked="false" isInGroup="123">
393 |           <controlProperties>
394 |             <text>Copy</text>
395 |           </controlProperties>
396 |         </control>
397 |         <control controlID="11" controlTypeID="com.balsamiq.mockups::Button" x="352" y="96" w="93" h="35" measuredW="53" measuredH="27" zOrder="11" locked="false" isInGroup="123">
398 |           <controlProperties>
399 |             <text>Copy</text>
400 |           </controlProperties>
401 |         </control>
402 |         <control controlID="12" controlTypeID="com.balsamiq.mockups::Button" x="352" y="154" w="93" h="35" measuredW="53" measuredH="27" zOrder="12" locked="false" isInGroup="123">
403 |           <controlProperties>
404 |             <text>Copy</text>
405 |           </controlProperties>
406 |         </control>
407 |         <control controlID="13" controlTypeID="com.balsamiq.mockups::Button" x="352" y="211" w="93" h="35" measuredW="53" measuredH="27" zOrder="13" locked="false" isInGroup="123">
408 |           <controlProperties>
409 |             <text>Copy</text>
410 |           </controlProperties>
411 |         </control>
412 |         <control controlID="14" controlTypeID="com.balsamiq.mockups::Button" x="352" y="258" w="93" h="35" measuredW="65" measuredH="27" zOrder="14" locked="false" isInGroup="123">
413 |           <controlProperties>
414 |             <text>Copy%20%23</text>
415 |           </controlProperties>
416 |         </control>
417 |       </groupChildrenDescriptors>
418 |     </control>
419 |     <control controlID="124" controlTypeID="__group__" x="1407" y="496" w="618" h="439" measuredW="618" measuredH="439" zOrder="5" locked="false" isInGroup="-1">
420 |       <groupChildrenDescriptors>
421 |         <control controlID="0" controlTypeID="com.balsamiq.mockups::TitleWindow" x="0" y="0" w="618" h="439" measuredW="450" measuredH="400" zOrder="0" locked="false" isInGroup="124">
422 |           <controlProperties>
423 |             <close>true</close>
424 |             <maximizeRestore>false</maximizeRestore>
425 |             <minimize>true</minimize>
426 |             <text>QtColorPicker%20-%20Final</text>
427 |             <verticalScrollbar>false</verticalScrollbar>
428 |           </controlProperties>
429 |         </control>
430 |         <control controlID="1" controlTypeID="__group__" x="15" y="39" w="315" h="360" measuredW="315" measuredH="360" zOrder="1" locked="false" isInGroup="124">
431 |           <groupChildrenDescriptors>
432 |             <control controlID="0" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="0" w="256" h="256" measuredW="100" measuredH="70" zOrder="0" locked="false" isInGroup="1"/>
433 |             <control controlID="1" controlTypeID="com.balsamiq.mockups::Canvas" x="275" y="0" w="40" h="360" measuredW="100" measuredH="70" zOrder="1" locked="false" isInGroup="1"/>
434 |             <control controlID="2" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="287" w="256" h="73" measuredW="100" measuredH="70" zOrder="2" locked="false" isInGroup="1"/>
435 |           </groupChildrenDescriptors>
436 |         </control>
437 |         <control controlID="2" controlTypeID="__group__" x="466" y="39" w="137" h="200" measuredW="137" measuredH="200" zOrder="2" locked="false" isInGroup="124">
438 |           <groupChildrenDescriptors>
439 |             <control controlID="0" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="0" w="137" h="-1" measuredW="86" measuredH="28" zOrder="0" locked="false" isInGroup="2">
440 |               <controlProperties>
441 |                 <size>14</size>
442 |                 <text>257%2036%20185</text>
443 |               </controlProperties>
444 |             </control>
445 |             <control controlID="1" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="57" w="137" h="-1" measuredW="72" measuredH="28" zOrder="1" locked="false" isInGroup="2">
446 |               <controlProperties>
447 |                 <size>14</size>
448 |                 <text>255%209%2067</text>
449 |               </controlProperties>
450 |             </control>
451 |             <control controlID="2" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="115" w="137" h="-1" measuredW="100" measuredH="28" zOrder="2" locked="false" isInGroup="2">
452 |               <controlProperties>
453 |                 <size>14</size>
454 |                 <text>98%20100%2056%2032</text>
455 |               </controlProperties>
456 |             </control>
457 |             <control controlID="3" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="172" w="137" h="-1" measuredW="64" measuredH="28" zOrder="3" locked="false" isInGroup="2">
458 |               <controlProperties>
459 |                 <backgroundAlpha>1</backgroundAlpha>
460 |                 <size>14</size>
461 |                 <text>a86d52</text>
462 |               </controlProperties>
463 |             </control>
464 |           </groupChildrenDescriptors>
465 |         </control>
466 |         <control controlID="3" controlTypeID="com.balsamiq.mockups::Button" x="350" y="39" w="104" h="35" measuredW="49" measuredH="27" zOrder="3" locked="false" isInGroup="124">
467 |           <controlProperties>
468 |             <text>HSV</text>
469 |           </controlProperties>
470 |         </control>
471 |         <control controlID="4" controlTypeID="com.balsamiq.mockups::Button" x="350" y="96" w="104" h="35" measuredW="49" measuredH="27" zOrder="4" locked="false" isInGroup="124">
472 |           <controlProperties>
473 |             <text>RGB</text>
474 |           </controlProperties>
475 |         </control>
476 |         <control controlID="5" controlTypeID="com.balsamiq.mockups::Button" x="350" y="154" w="104" h="35" measuredW="60" measuredH="27" zOrder="5" locked="false" isInGroup="124">
477 |           <controlProperties>
478 |             <text>CMYK</text>
479 |           </controlProperties>
480 |         </control>
481 |         <control controlID="6" controlTypeID="com.balsamiq.mockups::Button" x="350" y="211" w="104" h="35" measuredW="45" measuredH="27" zOrder="6" locked="false" isInGroup="124">
482 |           <controlProperties>
483 |             <text>Hex</text>
484 |           </controlProperties>
485 |         </control>
486 |         <control controlID="7" controlTypeID="com.balsamiq.mockups::Button" x="350" y="258" w="104" h="35" measuredW="57" measuredH="27" zOrder="7" locked="false" isInGroup="124">
487 |           <controlProperties>
488 |             <text>Hex%20%23</text>
489 |           </controlProperties>
490 |         </control>
491 |       </groupChildrenDescriptors>
492 |     </control>
493 |     <control controlID="125" controlTypeID="__group__" x="1407" y="10" w="664" h="439" measuredW="664" measuredH="439" zOrder="4" locked="false" isInGroup="-1">
494 |       <groupChildrenDescriptors>
495 |         <control controlID="0" controlTypeID="com.balsamiq.mockups::TitleWindow" x="0" y="0" w="664" h="439" measuredW="450" measuredH="400" zOrder="0" locked="false" isInGroup="125">
496 |           <controlProperties>
497 |             <close>true</close>
498 |             <maximizeRestore>false</maximizeRestore>
499 |             <minimize>true</minimize>
500 |             <text>QtColorPicker</text>
501 |             <verticalScrollbar>false</verticalScrollbar>
502 |           </controlProperties>
503 |         </control>
504 |         <control controlID="1" controlTypeID="__group__" x="15" y="39" w="315" h="360" measuredW="315" measuredH="360" zOrder="1" locked="false" isInGroup="125">
505 |           <groupChildrenDescriptors>
506 |             <control controlID="0" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="0" w="256" h="256" measuredW="100" measuredH="70" zOrder="0" locked="false" isInGroup="1"/>
507 |             <control controlID="1" controlTypeID="com.balsamiq.mockups::Canvas" x="275" y="0" w="40" h="360" measuredW="100" measuredH="70" zOrder="1" locked="false" isInGroup="1"/>
508 |             <control controlID="2" controlTypeID="com.balsamiq.mockups::Canvas" x="0" y="287" w="256" h="73" measuredW="100" measuredH="70" zOrder="2" locked="false" isInGroup="1"/>
509 |           </groupChildrenDescriptors>
510 |         </control>
511 |         <control controlID="2" controlTypeID="com.balsamiq.mockups::Label" x="456" y="42" w="-1" h="-1" measuredW="27" measuredH="21" zOrder="2" locked="false" isInGroup="125">
512 |           <controlProperties>
513 |             <text>HSV</text>
514 |           </controlProperties>
515 |         </control>
516 |         <control controlID="3" controlTypeID="com.balsamiq.mockups::Label" x="456" y="98" w="-1" h="-1" measuredW="27" measuredH="21" zOrder="3" locked="false" isInGroup="125">
517 |           <controlProperties>
518 |             <text>RGB</text>
519 |           </controlProperties>
520 |         </control>
521 |         <control controlID="4" controlTypeID="com.balsamiq.mockups::Label" x="456" y="156" w="-1" h="-1" measuredW="38" measuredH="21" zOrder="4" locked="false" isInGroup="125">
522 |           <controlProperties>
523 |             <text>CMYK</text>
524 |           </controlProperties>
525 |         </control>
526 |         <control controlID="5" controlTypeID="com.balsamiq.mockups::Label" x="456" y="213" w="-1" h="-1" measuredW="23" measuredH="21" zOrder="5" locked="false" isInGroup="125">
527 |           <controlProperties>
528 |             <text>Hex</text>
529 |           </controlProperties>
530 |         </control>
531 |         <control controlID="6" controlTypeID="__group__" x="502" y="40" w="143" h="200" measuredW="143" measuredH="200" zOrder="6" locked="false" isInGroup="125">
532 |           <groupChildrenDescriptors>
533 |             <control controlID="0" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="0" w="143" h="-1" measuredW="86" measuredH="28" zOrder="0" locked="false" isInGroup="6">
534 |               <controlProperties>
535 |                 <size>14</size>
536 |                 <text>257%2036%20185</text>
537 |               </controlProperties>
538 |             </control>
539 |             <control controlID="1" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="57" w="143" h="-1" measuredW="72" measuredH="28" zOrder="1" locked="false" isInGroup="6">
540 |               <controlProperties>
541 |                 <size>14</size>
542 |                 <text>255%209%2067</text>
543 |               </controlProperties>
544 |             </control>
545 |             <control controlID="2" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="115" w="143" h="-1" measuredW="100" measuredH="28" zOrder="2" locked="false" isInGroup="6">
546 |               <controlProperties>
547 |                 <size>14</size>
548 |                 <text>98%20100%2056%2032</text>
549 |               </controlProperties>
550 |             </control>
551 |             <control controlID="3" controlTypeID="com.balsamiq.mockups::TextInput" x="0" y="172" w="143" h="-1" measuredW="64" measuredH="28" zOrder="3" locked="false" isInGroup="6">
552 |               <controlProperties>
553 |                 <backgroundAlpha>1</backgroundAlpha>
554 |                 <size>14</size>
555 |                 <text>a86d52</text>
556 |               </controlProperties>
557 |             </control>
558 |           </groupChildrenDescriptors>
559 |         </control>
560 |         <control controlID="7" controlTypeID="com.balsamiq.mockups::Button" x="352" y="39" w="93" h="35" measuredW="53" measuredH="27" zOrder="7" locked="false" isInGroup="125">
561 |           <controlProperties>
562 |             <text>Copy</text>
563 |           </controlProperties>
564 |         </control>
565 |         <control controlID="8" controlTypeID="com.balsamiq.mockups::Button" x="352" y="96" w="93" h="35" measuredW="53" measuredH="27" zOrder="8" locked="false" isInGroup="125">
566 |           <controlProperties>
567 |             <text>Copy</text>
568 |           </controlProperties>
569 |         </control>
570 |         <control controlID="9" controlTypeID="com.balsamiq.mockups::Button" x="352" y="154" w="93" h="35" measuredW="53" measuredH="27" zOrder="9" locked="false" isInGroup="125">
571 |           <controlProperties>
572 |             <text>Copy</text>
573 |           </controlProperties>
574 |         </control>
575 |         <control controlID="10" controlTypeID="com.balsamiq.mockups::Button" x="352" y="211" w="93" h="35" measuredW="53" measuredH="27" zOrder="10" locked="false" isInGroup="125">
576 |           <controlProperties>
577 |             <text>Copy</text>
578 |           </controlProperties>
579 |         </control>
580 |         <control controlID="11" controlTypeID="com.balsamiq.mockups::Button" x="352" y="258" w="93" h="35" measuredW="65" measuredH="27" zOrder="11" locked="false" isInGroup="125">
581 |           <controlProperties>
582 |             <text>Copy%20%23</text>
583 |           </controlProperties>
584 |         </control>
585 |       </groupChildrenDescriptors>
586 |     </control>
587 |   </controls>
588 | </mockup>


--------------------------------------------------------------------------------