1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the demonstration applications of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtCore>

    43 #include <QtGui>

    44 

    45 #include "flickable.h"

    46 

    47 // Returns a list of two-word color names

    48 static QStringList colorPairs(int max)

    49 {

    50     // capitalize the first letter

    51     QStringList colors = QColor::colorNames();

    52     colors.removeAll("transparent");

    53     int num = colors.count();

    54     for (int c = 0; c < num; ++c)

    55         colors[c] = colors[c][0].toUpper() + colors[c].mid(1);

    56 

    57     // combine two colors, e.g. "lime skyblue"

    58     QStringList combinedColors;

    59     for (int i = 0; i < num; ++i)

    60         for (int j = 0; j < num; ++j)

    61             combinedColors << QString("%1 %2").arg(colors[i]).arg(colors[j]);

    62 

    63     // randomize it

    64     colors.clear();

    65     while (combinedColors.count()) {

    66         int i = qrand() % combinedColors.count();

    67         colors << combinedColors[i];

    68         combinedColors.removeAt(i);

    69         if (colors.count() == max)

    70             break;

    71     }

    72 

    73     return colors;

    74 }

    75 

    76 class ColorList : public QWidget, public Flickable

    77 {

    78     Q_OBJECT

    79 

    80 public:

    81     ColorList(QWidget *parent = 0)

    82             : QWidget(parent) {

    83         m_offset = 0;

    84         m_height = QFontMetrics(font()).height() + 5;

    85         m_highlight = -1;

    86         m_selected = -1;

    87 

    88         QStringList colors = colorPairs(999);

    89         for (int i = 0; i < colors.count(); ++i) {

    90             QString c = colors[i];

    91             QString str;

    92             str.sprintf("%4d", i + 1);

    93             m_colorNames << (str + "   " + c);

    94 

    95             QStringList duet = c.split(' ');

    96             m_firstColor << duet[0];

    97             m_secondColor << duet[1];

    98         }

    99 

   100         setAttribute(Qt::WA_OpaquePaintEvent, true);

   101         setAttribute(Qt::WA_NoSystemBackground, true);

   102 

   103         setMouseTracking(true);

   104         Flickable::setAcceptMouseClick(this);

   105     }

   106 

   107 protected:

   108     // reimplement from Flickable

   109     virtual QPoint scrollOffset() const {

   110         return QPoint(0, m_offset);

   111     }

   112 

   113     // reimplement from Flickable

   114     virtual void setScrollOffset(const QPoint &offset) {

   115         int yy = offset.y();

   116         if (yy != m_offset) {

   117             m_offset = qBound(0, yy, m_height * m_colorNames.count() - height());

   118             update();

   119         }

   120     }

   121 

   122 protected:

   123     void paintEvent(QPaintEvent *event) {

   124         QPainter p(this);

   125         p.fillRect(event->rect(), Qt::white);

   126         int start = m_offset / m_height;

   127         int y = start * m_height - m_offset;

   128         if (m_offset <= 0) {

   129             start = 0;

   130             y = -m_offset;

   131         }

   132         int end = start + height() / m_height + 1;

   133         if (end > m_colorNames.count() - 1)

   134             end = m_colorNames.count() - 1;

   135         for (int i = start; i <= end; ++i, y += m_height) {

   136 

   137             p.setBrush(Qt::NoBrush);

   138             p.setPen(Qt::black);

   139             if (i == m_highlight) {

   140                 p.fillRect(0, y, width(), m_height, QColor(0, 64, 128));

   141                 p.setPen(Qt::white);

   142             }

   143             if (i == m_selected) {

   144                 p.fillRect(0, y, width(), m_height, QColor(0, 128, 240));

   145                 p.setPen(Qt::white);

   146             }

   147 

   148             p.drawText(m_height + 2, y, width(), m_height, Qt::AlignVCenter, m_colorNames[i]);

   149 

   150             p.setPen(Qt::NoPen);

   151             p.setBrush(m_firstColor[i]);

   152             p.drawRect(1, y + 1, m_height - 2, m_height - 2);

   153             p.setBrush(m_secondColor[i]);

   154             p.drawRect(5, y + 5, m_height - 11, m_height - 11);

   155         }

   156         p.end();

   157     }

   158 

   159     void keyReleaseEvent(QKeyEvent *event) {

   160         if (event->key() == Qt::Key_Down) {

   161             m_offset += 20;

   162             event->accept();

   163             update();

   164             return;

   165         }

   166         if (event->key() == Qt::Key_Up) {

   167             m_offset -= 20;

   168             event->accept();

   169             update();

   170             return;

   171         }

   172     }

   173 

   174     void mousePressEvent(QMouseEvent *event) {

   175         Flickable::handleMousePress(event);

   176         if (event->isAccepted())

   177             return;

   178 

   179         if (event->button() == Qt::LeftButton) {

   180             int y = event->pos().y() + m_offset;

   181             int i = y / m_height;

   182             if (i != m_highlight) {

   183                 m_highlight = i;

   184                 m_selected = -1;

   185                 update();

   186             }

   187             event->accept();

   188         }

   189     }

   190 

   191     void mouseMoveEvent(QMouseEvent *event) {

   192         Flickable::handleMouseMove(event);

   193     }

   194 

   195     void mouseReleaseEvent(QMouseEvent *event) {

   196         Flickable::handleMouseRelease(event);

   197         if (event->isAccepted())

   198             return;

   199 

   200         if (event->button() == Qt::LeftButton) {

   201             m_selected = m_highlight;

   202             event->accept();

   203             update();

   204         }

   205     }

   206 

   207 private:

   208     int m_offset;

   209     int m_height;

   210     int m_highlight;

   211     int m_selected;

   212     QStringList m_colorNames;

   213     QList<QColor> m_firstColor;

   214     QList<QColor> m_secondColor;

   215 };

   216 

   217 #include "main.moc"

   218 

   219 int main(int argc, char *argv[])

   220 {

   221     QApplication app(argc, argv);

   222 

   223     ColorList list;

   224     list.setWindowTitle("Kinetic Scrolling");

   225 #if defined(Q_OS_SYMBIAN) || defined(Q_OS_WINCE_WM)

   226     list.showMaximized();

   227 #else

   228     list.resize(320, 320);

   229     list.show();

   230 #endif

   231 

   232     return app.exec();

   233 }