source/frontend/widgets/pixmapdial.cpp

   1 /*
   2  * Pixmap Dial, a custom Qt4 widget
   3  * Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16  */
  17
  18 #include "pixmapdial.hpp"
  19
  20 #include <cmath>
  21
  22 #include <QtCore/QTimer>
  23 #include <QtGui/QPainter>
  24 #include <QtGui/QPaintEvent>
  25
  26 PixmapDial::PixmapDial(QWidget* parent)
  27     : QDial(parent),
  28       fPixmap(":/bitmaps/dial_01d.png"),
  29       fPixmapNum("01"),
  30       fCustomPaint(CUSTOM_PAINT_NULL),
  31       fOrientation(fPixmap.width() > fPixmap.height() ? HORIZONTAL : VERTICAL),
  32       fHovered(false),
  33       fHoverStep(HOVER_MIN),
  34       fLabel(""),
  35       fLabelPos(0.0f, 0.0f),
  36       fLabelWidth(0),
  37       fLabelHeight(0),
  38       fLabelGradient(0, 0, 0, 1)
  39 {
  40     fLabelFont.setPointSize(6);
  41
  42     if (palette().window().color().lightness() > 100)
  43     {
  44         // Light background
  45         const QColor c(palette().dark().color());
  46         fColor1    = c;
  47         fColor2    = QColor(c.red(), c.green(), c.blue(), 0);
  48         fColorT[0] = palette().buttonText().color();
  49         fColorT[1] = palette().mid().color();
  50     }
  51     else
  52     {
  53         // Dark background
  54         fColor1    = QColor(0, 0, 0, 255);
  55         fColor2    = QColor(0, 0, 0, 0);
  56         fColorT[0] = Qt::white;
  57         fColorT[1] = Qt::darkGray;
  58     }
  59
  60     updateSizes();
  61 }
  62
  63 int PixmapDial::getSize() const
  64 {
  65     return fSize;
  66 }
  67
  68 void PixmapDial::setCustomPaint(CustomPaint paint)
  69 {
  70     fCustomPaint = paint;
  71     fLabelPos.setY(fSize + fLabelHeight/2);
  72     update();
  73 }
  74
  75 void PixmapDial::setEnabled(bool enabled)
  76 {
  77     if (isEnabled() != enabled)
  78     {
  79         fPixmap.load(QString(":/bitmaps/dial_%1%2.png").arg(fPixmapNum).arg(enabled ? "" : "d"));
  80         updateSizes();
  81         update();
  82     }
  83     QDial::setEnabled(enabled);
  84 }
  85
  86 void PixmapDial::setLabel(QString label)
  87 {
  88     fLabel = label;
  89
  90     fLabelWidth  = QFontMetrics(font()).width(label);
  91     fLabelHeight = QFontMetrics(font()).height();
  92
  93     fLabelPos.setX(float(fSize)/2.0f - float(fLabelWidth)/2.0f);
  94     fLabelPos.setY(fSize + fLabelHeight);
  95
  96     fLabelGradient.setColorAt(0.0f, fColor1);
  97     fLabelGradient.setColorAt(0.6f, fColor1);
  98     fLabelGradient.setColorAt(1.0f, fColor2);
  99
 100     fLabelGradient.setStart(0, float(fSize)/2.0f);
 101     fLabelGradient.setFinalStop(0, fSize + fLabelHeight + 5);
 102
 103     fLabelGradientRect = QRectF(float(fSize)/8.0f, float(fSize)/2.0f, float(fSize*6)/8.0f, fSize+fLabelHeight+5);
 104     update();
 105 }
 106
 107 void PixmapDial::setPixmap(int pixmapId)
 108 {
 109     fPixmapNum.sprintf("%02i", pixmapId);
 110     fPixmap.load(QString(":/bitmaps/dial_%1%2.png").arg(fPixmapNum).arg(isEnabled() ? "" : "d"));
 111
 112     if (fPixmap.width() > fPixmap.height())
 113         fOrientation = HORIZONTAL;
 114     else
 115         fOrientation = VERTICAL;
 116
 117     updateSizes();
 118     update();
 119 }
 120
 121 QSize PixmapDial::minimumSizeHint() const
 122 {
 123     return QSize(fSize, fSize);
 124 }
 125
 126 QSize PixmapDial::sizeHint() const
 127 {
 128     return QSize(fSize, fSize);
 129 }
 130
 131 void PixmapDial::updateSizes()
 132 {
 133     fWidth  = fPixmap.width();
 134     fHeight = fPixmap.height();
 135
 136     if (fWidth < 1)
 137         fWidth = 1;
 138
 139     if (fHeight < 1)
 140         fHeight = 1;
 141
 142     if (fOrientation == HORIZONTAL)
 143     {
 144         fSize  = fHeight;
 145         fCount = fWidth/fHeight;
 146     }
 147     else
 148     {
 149         fSize  = fWidth;
 150         fCount = fHeight/fWidth;
 151     }
 152
 153     setMinimumSize(fSize, fSize + fLabelHeight + 5);
 154     setMaximumSize(fSize, fSize + fLabelHeight + 5);
 155 }
 156
 157 void PixmapDial::enterEvent(QEvent* event)
 158 {
 159     fHovered = true;
 160     if (fHoverStep == HOVER_MIN)
 161         fHoverStep = HOVER_MIN + 1;
 162     QDial::enterEvent(event);
 163 }
 164
 165 void PixmapDial::leaveEvent(QEvent* event)
 166 {
 167     fHovered = false;
 168     if (fHoverStep == HOVER_MAX)
 169         fHoverStep = HOVER_MAX - 1;
 170     QDial::leaveEvent(event);
 171 }
 172
 173 void PixmapDial::paintEvent(QPaintEvent* event)
 174 {
 175     event->accept();
 176
 177     QPainter painter(this);
 178     painter.save();
 179     painter.setRenderHint(QPainter::Antialiasing, true);
 180
 181     if (! fLabel.isEmpty())
 182     {
 183         if (fCustomPaint == CUSTOM_PAINT_NULL)
 184         {
 185             painter.setPen(fColor2);
 186             painter.setBrush(fLabelGradient);
 187             painter.drawRect(fLabelGradientRect);
 188         }
 189
 190         painter.setFont(fLabelFont);
 191         painter.setPen(fColorT[isEnabled() ? 0 : 1]);
 192         painter.drawText(fLabelPos, fLabel);
 193     }
 194
 195     if (isEnabled())
 196     {
 197         float current = value()-minimum();
 198         float divider = maximum()-minimum();
 199
 200         if (divider == 0.0f)
 201             return;
 202
 203         float value = current/divider;
 204         QRectF source, target(0.0f, 0.0f, fSize, fSize);
 205
 206         int xpos, ypos, per = (fCount-1)*value;
 207
 208         if (fOrientation == HORIZONTAL)
 209         {
 210             xpos = fSize*per;
 211             ypos = 0.0f;
 212         }
 213         else
 214         {
 215             xpos = 0.0f;
 216             ypos = fSize*per;
 217         }
 218
 219         source = QRectF(xpos, ypos, fSize, fSize);
 220         painter.drawPixmap(target, fPixmap, source);
 221
 222         // Custom knobs (Dry/Wet and Volume)
 223         if (fCustomPaint == CUSTOM_PAINT_CARLA_WET || fCustomPaint == CUSTOM_PAINT_CARLA_VOL)
 224         {
 225             // knob color
 226             QColor colorGreen(0x5D, 0xE7, 0x3D, 191 + fHoverStep*7);
 227             QColor colorBlue(0x3E, 0xB8, 0xBE, 191 + fHoverStep*7);
 228
 229             // draw small circle
 230             QRectF ballRect(8.0f, 8.0f, 15.0f, 15.0f);
 231             QPainterPath ballPath;
 232             ballPath.addEllipse(ballRect);
 233             //painter.drawRect(ballRect);
 234             float tmpValue  = (0.375f + 0.75f*value);
 235             float ballValue = tmpValue - std::floor(tmpValue);
 236             QPointF ballPoint(ballPath.pointAtPercent(ballValue));
 237
 238             // draw arc
 239             int startAngle = 216*16;
 240             int spanAngle  = -252*16*value;
 241
 242             if (fCustomPaint == CUSTOM_PAINT_CARLA_WET)
 243             {
 244                 painter.setBrush(colorBlue);
 245                 painter.setPen(QPen(colorBlue, 0));
 246                 painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2f, 2.2f));
 247
 248                 QConicalGradient gradient(15.5f, 15.5f, -45);
 249                 gradient.setColorAt(0.0f,   colorBlue);
 250                 gradient.setColorAt(0.125f, colorBlue);
 251                 gradient.setColorAt(0.625f, colorGreen);
 252                 gradient.setColorAt(0.75f,  colorGreen);
 253                 gradient.setColorAt(0.76f,  colorGreen);
 254                 gradient.setColorAt(1.0f,   colorGreen);
 255                 painter.setBrush(gradient);
 256                 painter.setPen(QPen(gradient, 3));
 257             }
 258             else
 259             {
 260                 painter.setBrush(colorBlue);
 261                 painter.setPen(QPen(colorBlue, 0));
 262                 painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2f, 2.2f));
 263
 264                 painter.setBrush(colorBlue);
 265                 painter.setPen(QPen(colorBlue, 3));
 266             }
 267
 268             painter.drawArc(4.0f, 4.0f, 26.0f, 26.0f, startAngle, spanAngle);
 269         }
 270         // Custom knobs (L and R)
 271         else if (fCustomPaint == CUSTOM_PAINT_CARLA_L || fCustomPaint == CUSTOM_PAINT_CARLA_R)
 272         {
 273             // knob color
 274             QColor color(0xAD + fHoverStep*5, 0xD5 + fHoverStep*4, 0x4B + fHoverStep*5);
 275
 276             // draw small circle
 277             QRectF ballRect(7.0f, 8.0f, 11.0f, 12.0f);
 278             QPainterPath ballPath;
 279             ballPath.addEllipse(ballRect);
 280             //painter.drawRect(ballRect);
 281             float tmpValue  = (0.375f + 0.75f*value);
 282             float ballValue = tmpValue - std::floor(tmpValue);
 283             QPointF ballPoint(ballPath.pointAtPercent(ballValue));
 284
 285             painter.setBrush(color);
 286             painter.setPen(QPen(color, 0));
 287             painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.0f, 2.0f));
 288
 289             int startAngle, spanAngle;
 290
 291             // draw arc
 292             if (fCustomPaint == CUSTOM_PAINT_CARLA_L)
 293             {
 294                 startAngle = 216*16;
 295                 spanAngle  = -252.0*16*value;
 296             }
 297             else if (fCustomPaint == CUSTOM_PAINT_CARLA_R)
 298             {
 299                 startAngle = 324.0*16;
 300                 spanAngle  = 252.0*16*(1.0-value);
 301             }
 302             else
 303                 return;
 304
 305             painter.setPen(QPen(color, 2));
 306             painter.drawArc(3.5f, 4.5f, 22.0f, 22.0f, startAngle, spanAngle);
 307
 308             if (HOVER_MIN < fHoverStep && fHoverStep < HOVER_MAX)
 309             {
 310                 fHoverStep += fHovered ? 1 : -1;
 311                 QTimer::singleShot(20, this, SLOT(update()));
 312             }
 313         }
 314
 315         if (HOVER_MIN < fHoverStep && fHoverStep < HOVER_MAX)
 316         {
 317             fHoverStep += fHovered ? 1 : -1;
 318             QTimer::singleShot(20, this, SLOT(update()));
 319         }
 320     }
 321     else
 322     {
 323         QRectF target(0.0f, 0.0f, fSize, fSize);
 324         painter.drawPixmap(target, fPixmap, target);
 325     }
 326
 327     painter.restore();
 328 }
 329
 330 void PixmapDial::resizeEvent(QResizeEvent* event)
 331 {
 332     updateSizes();
 333     QDial::resizeEvent(event);
 334 }