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 Qt3Support module 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 "q3header.h"

    43 #ifndef QT_NO_HEADER

    44 #include "qapplication.h"

    45 #include "qbitarray.h"

    46 #include "qcursor.h"

    47 #include "qdrawutil.h"

    48 #include "qevent.h"

    49 #include "qpainter.h"

    50 #include "qpixmap.h"

    51 #include "qstyle.h"

    52 #include "qstyleoption.h"

    53 #include "qvector.h"

    54 

    55 QT_BEGIN_NAMESPACE

    56 

    57 class Q3HeaderData

    58 {

    59 public:

    60     Q3HeaderData(int n)

    61     {

    62         count = n;

    63         sizes.resize(n);

    64         positions.resize(n);

    65         labels.resize(n);

    66         nullStringLabels.resize(n);

    67         icons.resize(n);

    68         i2s.resize(n);

    69         s2i.resize(n);

    70         clicks.resize(n);

    71         resize.resize(n);

    72         int p =0;

    73         for (int i = 0; i < n; i ++) {

    74             sizes[i] = 88;

    75             i2s[i] = i;

    76             s2i[i] = i;

    77             positions[i] = p;

    78             p += sizes[i];

    79         }

    80         clicks_default = true;

    81         resize_default = true;

    82         clicks.fill(clicks_default);

    83         resize.fill(resize_default);

    84         move = true;

    85         sortSection = -1;

    86         sortDirection = true;

    87         positionsDirty = true;

    88         lastPos = 0;

    89         fullSize = -2;

    90         pos_dirty = false;

    91         is_a_table_header = false;

    92         focusIdx = 0;

    93     }

    94     ~Q3HeaderData()

    95     {

    96         for (int i = 0; i < icons.size(); ++i)

    97             delete icons.at(i);

    98     }

    99 

   100 

   101     QVector<int>        sizes;

   102     int height; // we abuse the heights as widths for vertical layout

   103     bool heightDirty;

   104     QVector<int>        positions; // sorted by index

   105     QVector<QString>        labels;

   106     QVector<QIcon *> icons;

   107     QVector<int>                i2s;

   108     QVector<int>                s2i;

   109 

   110     QBitArray           clicks;

   111     QBitArray           resize;

   112     QBitArray           nullStringLabels;

   113     uint move : 1;

   114     uint clicks_default : 1; // default value for new clicks bits

   115     uint resize_default : 1; // default value for new resize bits

   116     uint pos_dirty : 1;

   117     uint is_a_table_header : 1;

   118     bool sortDirection;

   119     bool positionsDirty;

   120     int sortSection;

   121     int count;

   122     int lastPos;

   123     int fullSize;

   124     int focusIdx;

   125     int pressDelta;

   126 

   127     int sectionAt(int pos) {

   128         // positions is sorted by index, not by section

   129         if (!count)

   130             return -1;

   131         int l = 0;

   132         int r = count - 1;

   133         int i = ((l+r+1) / 2);

   134         while (r - l) {

   135             if (positions[i] > pos)

   136                 r = i -1;

   137             else

   138                 l = i;

   139             i = ((l+r+1) / 2);

   140         }

   141         if (positions[i] <= pos && pos <= positions[i] + sizes[i2s[i]])

   142             return i2s[i];

   143         return -1;

   144     }

   145 };

   146 

   147 static QStyleOptionHeader getStyleOption(const Q3Header *header, int section)

   148 {

   149     QStyleOptionHeader opt;

   150     opt.init(header);

   151     opt.section = section;

   152     opt.textAlignment = Qt::AlignVCenter;

   153     opt.iconAlignment = Qt::AlignVCenter;

   154     if (header->iconSet(section))

   155         opt.icon = *header->iconSet(section);

   156     opt.text = header->label(section);

   157     if (header->orientation() == Qt::Horizontal)

   158         opt.state = QStyle::State_Horizontal;

   159     return opt;

   160 }

   161 

   162 bool qt_get_null_label_bit(Q3HeaderData *data, int section)

   163 {

   164     return data->nullStringLabels.testBit(section);

   165 }

   166 

   167 void qt_set_null_label_bit(Q3HeaderData *data, int section, bool b)

   168 {

   169     data->nullStringLabels.setBit(section, b);

   170 }

   171 

   172 /*!

   173     \class Q3Header

   174     \brief The Q3Header class provides a header row or column, e.g. for

   175     tables and listviews.

   176 

   177     \compat

   178 

   179     This class provides a header, e.g. a vertical header to display

   180     row labels, or a horizontal header to display column labels. It is

   181     used by Q3Table and Q3ListView for example.

   182 

   183     A header is composed of one or more \e sections, each of which can

   184     display a text label and an \link QIcon icon\endlink. A sort

   185     indicator (an arrow) can also be displayed using

   186     setSortIndicator().

   187 

   188     Sections are added with addLabel() and removed with removeLabel().

   189     The label and icon are set in addLabel() and can be changed

   190     later with setLabel(). Use count() to retrieve the number of

   191     sections in the header.

   192 

   193     The orientation of the header is set with setOrientation(). If

   194     setStretchEnabled() is true, the sections will expand to take up

   195     the full width (height for vertical headers) of the header. The

   196     user can resize the sections manually if setResizeEnabled() is

   197     true. Call adjustHeaderSize() to have the sections resize to

   198     occupy the full width (or height).

   199 

   200     A section can be moved with moveSection(). If setMovingEnabled()

   201     is true (the default)the user may drag a section from one position

   202     to another. If a section is moved, the index positions at which

   203     sections were added (with addLabel()), may not be the same after the

   204     move. You don't have to worry about this in practice because the

   205     Q3Header API works in terms of section numbers, so it doesn't matter

   206     where a particular section has been moved to.

   207 

   208     If you want the current index position of a section call

   209     mapToIndex() giving it the section number. (This is the number

   210     returned by the addLabel() call which created the section.) If you

   211     want to get the section number of a section at a particular index

   212     position call mapToSection() giving it the index number.

   213 

   214     Here's an example to clarify mapToSection() and mapToIndex():

   215 

   216     \table

   217     \header \i41 Index positions

   218     \row \i 0 \i 1 \i 2 \i 3

   219     \header \i41 Original section ordering

   220     \row \i Sect 0 \i Sect 1 \i Sect 2 \i Sect 3

   221     \header \i41 Ordering after the user moves a section

   222     \row \i Sect 0 \i Sect 2 \i Sect 3 \i Sect 1

   223     \endtable

   224 

   225     \table

   226     \header \i \e k \i mapToSection(\e k) \i mapToIndex(\e k)

   227     \row \i 0 \i 0 \i 0

   228     \row \i 1 \i 2 \i 3

   229     \row \i 2 \i 3 \i 1

   230     \row \i 3 \i 1 \i 2

   231     \endtable

   232 

   233     In the example above, if we wanted to find out which section is at

   234     index position 3 we'd call mapToSection(3) and get a section

   235     number of 1 since section 1 was moved. Similarly, if we wanted to

   236     know which index position section 2 occupied we'd call

   237     mapToIndex(2) and get an index of 1.

   238 

   239     Q3Header provides the clicked(), pressed() and released() signals.

   240     If the user changes the size of a section, the sizeChange() signal

   241     is emitted. If you want to have a sizeChange() signal emitted

   242     continuously whilst the user is resizing (rather than just after

   243     the resizing is finished), use setTracking(). If the user moves a

   244     section the indexChange() signal is emitted.

   245 

   246     \sa Q3ListView Q3Table

   247 */

   248 

   249 

   250 

   251 /*!

   252     Constructs a horizontal header called \a name, with parent \a

   253     parent.

   254 */

   255 

   256 Q3Header::Q3Header(QWidget *parent, const char *name)

   257     : QWidget(parent, name, Qt::WStaticContents)

   258 {

   259     orient = Qt::Horizontal;

   260     init(0);

   261 }

   262 

   263 /*!

   264     Constructs a horizontal header called \a name, with \a n sections

   265     and parent \a parent.

   266 */

   267 

   268 Q3Header::Q3Header(int n, QWidget *parent, const char *name)

   269     : QWidget(parent, name, Qt::WStaticContents)

   270 {

   271     orient = Qt::Horizontal;

   272     init(n);

   273 }

   274 

   275 /*!

   276     Destroys the header and all its sections.

   277 */

   278 

   279 Q3Header::~Q3Header()

   280 {

   281     delete d;

   282     d = 0;

   283 }

   284 

   285 /*! \reimp

   286  */

   287 

   288 void Q3Header::showEvent(QShowEvent *e)

   289 {

   290     calculatePositions();

   291     QWidget::showEvent(e);

   292 }

   293 

   294 /*!

   295     \fn void Q3Header::sizeChange(int section, int oldSize, int newSize)

   296 

   297     This signal is emitted when the user has changed the size of a \a

   298     section from \a oldSize to \a newSize. This signal is typically

   299     connected to a slot that repaints the table or list that contains

   300     the header.

   301 */

   302 

   303 /*!

   304     \fn void Q3Header::clicked(int section)

   305 

   306     If isClickEnabled() is true, this signal is emitted when the user

   307     clicks section \a section.

   308 

   309     \sa pressed(), released()

   310 */

   311 

   312 /*!

   313     \fn void Q3Header::pressed(int section)

   314 

   315     This signal is emitted when the user presses section \a section

   316     down.

   317 

   318     \sa released()

   319 */

   320 

   321 /*!

   322     \fn void Q3Header::released(int section)

   323 

   324     This signal is emitted when section \a section is released.

   325 

   326     \sa pressed()

   327 */

   328 

   329 

   330 /*!

   331     \fn void Q3Header::indexChange(int section, int fromIndex, int toIndex)

   332 

   333     This signal is emitted when the user moves section \a section from

   334     index position \a fromIndex, to index position \a toIndex.

   335 */

   336 

   337 /*!

   338   \fn void Q3Header::moved(int fromIndex, int toIndex)

   339 

   340   Use indexChange() instead.

   341 

   342   This signal is emitted when the user has moved the section which

   343   is displayed at the index \a fromIndex to the index \a toIndex.

   344 */

   345 

   346 /*!

   347   \fn void Q3Header::sectionClicked(int index)

   348 

   349   Use clicked() instead.

   350 

   351   This signal is emitted when a part of the header is clicked. \a

   352   index is the index at which the section is displayed.

   353 

   354   In a list view this signal would typically be connected to a slot

   355   that sorts the specified column (or row).

   356 */

   357 

   358 /*! \fn int Q3Header::cellSize(int) const

   359 

   360   Use sectionSize() instead.

   361 

   362   Returns the size in pixels of the section that is displayed at

   363   the index \a i.

   364 */

   365 

   366 /*!

   367     \fn void Q3Header::sectionHandleDoubleClicked(int section)

   368 

   369     This signal is emitted when the user doubleclicks on the edge

   370     (handle) of section \a section.

   371 */

   372 

   373 /*!

   374 

   375   Use sectionPos() instead.

   376 

   377   Returns the position in pixels of the section that is displayed at the

   378   index \a i. The  position is measured from the start of the header.

   379 */

   380 

   381 int Q3Header::cellPos(int i) const

   382 {

   383     if (i == count() && i > 0)

   384         return  d->positions[i-1] + d->sizes[d->i2s[i-1]]; // compatibility

   385     return sectionPos(mapToSection(i));

   386 }

   387 

   388 

   389 /*!

   390     \property Q3Header::count

   391     \brief the number of sections in the header

   392 */

   393 

   394 int Q3Header::count() const

   395 {

   396     return d->count;

   397 }

   398 

   399 

   400 /*!

   401     \property Q3Header::tracking

   402     \brief whether the sizeChange() signal is emitted continuously

   403 

   404     If tracking is on, the sizeChange() signal is emitted continuously

   405     while the mouse is moved (i.e. when the header is resized),

   406     otherwise it is only emitted when the mouse button is released at

   407     the end of resizing.

   408 

   409     Tracking defaults to false.

   410 */

   411 

   412 

   413 /*

   414     Initializes with \a n columns.

   415 */

   416 void Q3Header::init(int n)

   417 {

   418     state = Idle;

   419     cachedPos = 0; // unused

   420     d = new Q3HeaderData(n);

   421     d->height = 0;

   422     d->heightDirty = true;

   423     offs = 0;

   424     if(reverse())

   425         offs = d->lastPos - width();

   426     oldHandleIdx = oldHIdxSize = handleIdx = 0;

   427 

   428     setMouseTracking(true);

   429     trackingIsOn = false;

   430     setBackgroundRole(QPalette::Button);

   431     setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));

   432     setAttribute(Qt::WA_PaintOutsidePaintEvent);

   433 }

   434 

   435 /*!

   436     \property Q3Header::orientation

   437     \brief the header's orientation

   438 

   439     The orientation is either Qt::Vertical or Qt::Horizontal (the

   440     default).

   441 

   442     Call setOrientation() before adding labels if you don't provide a

   443     size parameter otherwise the sizes will be incorrect.

   444 */

   445 

   446 void Q3Header::setOrientation(Qt::Orientation orientation)

   447 {

   448     if (orient == orientation)

   449         return;

   450     orient = orientation;

   451     if (orient == Qt::Horizontal)

   452         setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));

   453     else

   454         setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred));

   455     update();

   456     updateGeometry();

   457 }

   458 

   459 

   460 /*

   461     Paints a rectangle starting at \a p, with length \s.

   462 */

   463 void Q3Header::paintRect(int p, int s)

   464 {

   465     QPainter paint(this);

   466     paint.setPen(QPen(Qt::black, 1, Qt::DotLine));

   467     if (reverse())

   468         paint.drawRect(p - s, 3, s, height() - 5);

   469     else if (orient == Qt::Horizontal)

   470         paint.drawRect(p, 3, s, height() - 5);

   471     else

   472         paint.drawRect(3, p, height() - 5, s);

   473 }

   474 

   475 /*

   476   Marks the division line at \a idx.

   477 */

   478 void Q3Header::markLine(int idx)

   479 {

   480     QPainter paint(this);

   481     paint.setPen(QPen(Qt::black, 1, Qt::DotLine));

   482     int MARKSIZE = style()->pixelMetric(QStyle::PM_HeaderMarkSize);

   483     int p = pPos(idx);

   484     int x = p - MARKSIZE/2;

   485     int y = 2;

   486     int x2 = p + MARKSIZE/2;

   487     int y2 = height() - 3;

   488     if (orient == Qt::Vertical) {

   489         int t = x; x = y; y = t;

   490         t = x2; x2 = y2; y2 = t;

   491     }

   492 

   493     paint.drawLine(x, y, x2, y);

   494     paint.drawLine(x, y+1, x2, y+1);

   495 

   496     paint.drawLine(x, y2, x2, y2);

   497     paint.drawLine(x, y2-1, x2, y2-1);

   498 

   499     paint.drawLine(x, y, x, y2);

   500     paint.drawLine(x+1, y, x+1, y2);

   501 

   502     paint.drawLine(x2, y, x2, y2);

   503     paint.drawLine(x2-1, y, x2-1, y2);

   504 }

   505 

   506 /*

   507   Removes the mark at the division line at \a idx.

   508 */

   509 void Q3Header::unMarkLine(int idx)

   510 {

   511     if (idx < 0)

   512         return;

   513     int MARKSIZE = style()->pixelMetric(QStyle::PM_HeaderMarkSize);

   514     int p = pPos(idx);

   515     int x = p - MARKSIZE/2;

   516     int y = 2;

   517     int x2 = p + MARKSIZE/2;

   518     int y2 = height() - 3;

   519     if (orient == Qt::Vertical) {

   520         int t = x; x = y; y = t;

   521         t = x2; x2 = y2; y2 = t;

   522     }

   523     repaint(x, y, x2-x+1, y2-y+1);

   524 }

   525 

   526 /*! \fn int Q3Header::cellAt(int) const

   527 

   528   Use sectionAt() instead.

   529 

   530   Returns the index at which the section is displayed, which contains

   531   \a pos in widget coordinates, or -1 if \a pos is outside the header

   532   sections.

   533 */

   534 

   535 /*

   536   Tries to find a line that is not a neighbor of  \c handleIdx.

   537 */

   538 int Q3Header::findLine(int c)

   539 {

   540     int i = 0;

   541     if (c > d->lastPos || (reverse() && c < 0)) {

   542         return d->count;

   543     } else {

   544         int section = sectionAt(c);

   545         if (section < 0)

   546             return handleIdx;

   547         i = d->s2i[section];

   548     }

   549     int MARKSIZE = style()->pixelMetric(QStyle::PM_HeaderMarkSize);

   550     if (i == handleIdx)

   551         return i;

   552     if (i == handleIdx - 1 &&  pPos(handleIdx) - c > MARKSIZE/2)

   553         return i;

   554     if (i == handleIdx + 1 && c - pPos(i) > MARKSIZE/2)

   555         return i + 1;

   556     if (c - pPos(i) > pSize(i) / 2)

   557         return i + 1;

   558     else

   559         return i;

   560 }

   561 

   562 /*!

   563     Returns the handle at position \a p, or -1 if there is no handle at \a p.

   564 */

   565 int Q3Header::handleAt(int p)

   566 {

   567     int section = d->sectionAt(p);

   568     if (section >= 0) {

   569         int GripMargin = (bool)d->resize[section] ?

   570             style()->pixelMetric(QStyle::PM_HeaderGripMargin) : 0;

   571         int index = d->s2i[section];

   572         if ((index > 0 && p < d->positions[index] + GripMargin) ||

   573             (p > d->positions[index] + d->sizes[section] - GripMargin)) {

   574             if (index > 0 && p < d->positions[index]  + GripMargin)

   575                 section = d->i2s[--index];

   576             // don't show icon if streaching is enabled it is at the end of the last section

   577             if (d->resize.testBit(section) && (d->fullSize == -2 || index != count() - 1)) {

   578                 return section;

   579             }

   580         }

   581     }

   582 

   583     return -1;

   584 }

   585 

   586 /*!

   587   Use moveSection() instead.

   588 

   589   Moves the section that is currently displayed at index \a fromIdx

   590   to index \a toIdx.

   591 */

   592 

   593 void Q3Header::moveCell(int fromIdx, int toIdx)

   594 {

   595     moveSection(mapToSection(fromIdx), toIdx);

   596 }

   597 

   598 

   599 

   600 /*!

   601   Move and signal and repaint.

   602  */

   603 

   604 void Q3Header::handleColumnMove(int fromIdx, int toIdx)

   605 {

   606     int s = d->i2s[fromIdx];

   607     if (fromIdx < toIdx)

   608         toIdx++; //Convert to

   609     QRect r = sRect(fromIdx);

   610     r |= sRect(toIdx);

   611     moveSection(s, toIdx);

   612     update(r);

   613     emit moved(fromIdx, toIdx);

   614     emit indexChange(s, fromIdx, toIdx);

   615 }

   616 

   617 /*!

   618   \reimp

   619 */

   620 void Q3Header::keyPressEvent(QKeyEvent *e)

   621 {

   622     int i = d->focusIdx;

   623     if (e->key() == Qt::Key_Space) {

   624         //don't do it if we're doing something with the mouse

   625         if (state == Idle && d->clicks[d->i2s[d->focusIdx] ]) {

   626             handleIdx = i;

   627             state = Pressed;

   628             repaint(sRect(handleIdx));

   629             emit pressed(d->i2s[i]);

   630         }

   631     } else if ((orientation() == Qt::Horizontal && (e->key() == Qt::Key_Right || e->key() == Qt::Key_Left))

   632                || (orientation() == Qt::Vertical && (e->key() == Qt::Key_Up || e->key() == Qt::Key_Down))) {

   633         int dir = e->key() == Qt::Key_Right || e->key() == Qt::Key_Down ? 1 : -1;

   634         int s = d->i2s[i];

   635         if (e->state() & Qt::ControlButton  && d->resize[s]) {

   636             //resize

   637             int step = e->state() & Qt::ShiftButton ? dir : 10*dir;

   638             int c = d->positions[i] + d->sizes[s] +  step;

   639             handleColumnResize(i, c, true);

   640         } else         if (e->state() & (Qt::AltButton|Qt::MetaButton) && d->move) {

   641             //move section

   642             int i2 = (i + count() + dir) % count();

   643             d->focusIdx = i2;

   644             handleColumnMove(i, i2);

   645         } else {

   646             //focus on different section

   647             QRect r = sRect(d->focusIdx);

   648             d->focusIdx = (d->focusIdx + count() + dir) % count();

   649             r |= sRect(d->focusIdx);

   650             update(r);

   651         }

   652     } else {

   653         e->ignore();

   654     }

   655 }

   656 

   657 /*!

   658   \reimp

   659 */

   660 void Q3Header::keyReleaseEvent(QKeyEvent *e)

   661 {

   662     switch (e->key()) {

   663     case Qt::Key_Space:

   664         //double check that this wasn't started with the mouse

   665         if (state == Pressed && handleIdx == d->focusIdx) {

   666             repaint(sRect(handleIdx));

   667             int section = d->i2s[d->focusIdx];

   668             emit released(section);

   669             emit sectionClicked(handleIdx);

   670             emit clicked(section);

   671             state = Idle;

   672             handleIdx = -1;

   673         }

   674         break;

   675     default:

   676         e->ignore();

   677     }

   678 }

   679 

   680 

   681 /*!

   682   \reimp

   683 */

   684 void Q3Header::mousePressEvent(QMouseEvent *e)

   685 {

   686     if (e->button() != Qt::LeftButton || state != Idle)

   687         return;

   688     oldHIdxSize = handleIdx;

   689     handleIdx = 0;

   690     int c = orient == Qt::Horizontal ? e->pos().x() : e->pos().y();

   691     c += offset();

   692     if (reverse())

   693         c = d->lastPos - c;

   694 

   695     int section = d->sectionAt(c);

   696     if (section < 0)

   697         return;

   698     int GripMargin = (bool)d->resize[section] ?

   699         style()->pixelMetric(QStyle::PM_HeaderGripMargin) : 0;

   700     int index = d->s2i[section];

   701 

   702     if ((index > 0 && c < d->positions[index] + GripMargin) ||

   703          (c > d->positions[index] + d->sizes[section] - GripMargin)) {

   704         if (c < d->positions[index] + GripMargin)

   705             handleIdx = index-1;

   706         else

   707             handleIdx = index;

   708         if (d->lastPos <= (orient == Qt::Horizontal ? width() :

   709                              height()) && d->fullSize != -2 && handleIdx == count() - 1) {

   710             handleIdx = -1;

   711             return;

   712         }

   713         oldHIdxSize = d->sizes[d->i2s[handleIdx]];

   714         state = d->resize[d->i2s[handleIdx] ] ? Sliding : Blocked;

   715     } else if (index >= 0) {

   716         oldHandleIdx = handleIdx = index;

   717         moveToIdx = -1;

   718         state = d->clicks[d->i2s[handleIdx] ] ? Pressed : Blocked;

   719         clickPos = c;

   720         repaint(sRect(handleIdx));

   721         if(oldHandleIdx != handleIdx)

   722             repaint(sRect(oldHandleIdx));

   723         emit pressed(section);

   724     }

   725 

   726     d->pressDelta = c - (d->positions[handleIdx] + d->sizes[d->i2s[handleIdx]]);

   727 }

   728 

   729 /*!

   730   \reimp

   731 */

   732 void Q3Header::mouseReleaseEvent(QMouseEvent *e)

   733 {

   734     if (e->button() != Qt::LeftButton)

   735         return;

   736     int oldOldHandleIdx = oldHandleIdx;

   737     State oldState = state;

   738     state = Idle;

   739     switch (oldState) {

   740     case Pressed: {

   741         int section = d->i2s[handleIdx];

   742         emit released(section);

   743         if (sRect(handleIdx).contains(e->pos())) {

   744             oldHandleIdx = handleIdx;

   745             emit sectionClicked(handleIdx);

   746             emit clicked(section);

   747         } else {

   748             handleIdx = oldHandleIdx;

   749         }

   750         repaint(sRect(handleIdx));

   751         if (oldOldHandleIdx != handleIdx)

   752             repaint(sRect(oldOldHandleIdx));

   753         } break;

   754     case Sliding: {

   755         int c = orient == Qt::Horizontal ? e->pos().x() : e->pos().y();

   756         c += offset();

   757         if (reverse())

   758             c = d->lastPos - c;

   759         handleColumnResize(handleIdx, c - d->pressDelta, true);

   760     } break;

   761     case Moving: {

   762 #ifndef QT_NO_CURSOR

   763         unsetCursor();

   764 #endif

   765         int section = d->i2s[handleIdx];

   766         if (handleIdx != moveToIdx && moveToIdx != -1) {

   767             moveSection(section, moveToIdx);

   768             handleIdx = oldHandleIdx;

   769             emit moved(handleIdx, moveToIdx);

   770             emit indexChange(section, handleIdx, moveToIdx);

   771             emit released(section);

   772             repaint(); // a bit overkill, but removes the handle as well

   773         } else {

   774             if (sRect(handleIdx).contains(e->pos())) {

   775                 oldHandleIdx = handleIdx;

   776                 emit released(section);

   777                 emit sectionClicked(handleIdx);

   778                 emit clicked(section);

   779             } else {

   780                 handleIdx = oldHandleIdx;

   781             }

   782             repaint(sRect(handleIdx));

   783             if(oldOldHandleIdx != handleIdx)

   784                 repaint(sRect(oldOldHandleIdx));

   785         }

   786         break;

   787     }

   788     case Blocked:

   789         //nothing

   790         break;

   791     default:

   792         // empty, probably.  Idle, at any rate.

   793         break;

   794     }

   795 }

   796 

   797 /*!

   798   \reimp

   799 */

   800 void Q3Header::mouseMoveEvent(QMouseEvent *e)

   801 {

   802     int c = orient == Qt::Horizontal ? e->pos().x() : e->pos().y();

   803     c += offset();

   804 

   805     int pos = c;

   806     if(reverse())

   807         c = d->lastPos - c;

   808 

   809     switch(state) {

   810     case Idle:

   811 #ifndef QT_NO_CURSOR

   812         if (handleAt(c) < 0)

   813             unsetCursor();

   814         else if (orient == Qt::Horizontal)

   815             setCursor(Qt::splitHCursor);

   816         else

   817             setCursor(Qt::splitVCursor);

   818 #endif

   819         break;

   820     case Blocked:

   821         break;

   822     case Pressed:

   823         if (QABS(c - clickPos) > 4 && d->move) {

   824             state = Moving;

   825             moveToIdx = -1;

   826 #ifndef QT_NO_CURSOR

   827             if (orient == Qt::Horizontal)

   828                 setCursor(Qt::SizeHorCursor);

   829             else

   830                 setCursor(Qt::SizeVerCursor);

   831 #endif

   832         }

   833         break;

   834     case Sliding:

   835         handleColumnResize(handleIdx, c, false, false);

   836         break;

   837     case Moving: {

   838         int newPos = findLine(pos);

   839         if (newPos != moveToIdx) {

   840             if (moveToIdx == handleIdx || moveToIdx == handleIdx + 1)

   841                 repaint(sRect(handleIdx));

   842             else

   843                 unMarkLine(moveToIdx);

   844             moveToIdx = newPos;

   845             if (moveToIdx == handleIdx || moveToIdx == handleIdx + 1)

   846                 paintRect(pPos(handleIdx), pSize(handleIdx));

   847             else

   848                 markLine(moveToIdx);

   849         }

   850         break;

   851     }

   852     default:

   853         qWarning("Q3Header::mouseMoveEvent: (%s) unknown state", objectName().toLocal8Bit().data());

   854         break;

   855     }

   856 }

   857 

   858 /*! \reimp */

   859 

   860 void Q3Header::mouseDoubleClickEvent(QMouseEvent *e)

   861 {

   862     int p = orient == Qt::Horizontal ? e->pos().x() : e->pos().y();

   863     p += offset();

   864     if(reverse())

   865         p = d->lastPos - p;

   866 

   867     int header = handleAt(p);

   868     if (header >= 0)

   869         emit sectionHandleDoubleClicked(header);

   870 }

   871 

   872 /*

   873   Handles resizing of sections. This means it redraws the relevant parts

   874   of the header.

   875 */

   876 

   877 void Q3Header::handleColumnResize(int index, int c, bool final, bool recalcAll)

   878 {

   879     int section = d->i2s[index];

   880     int GripMargin = (bool)d->resize[section] ?

   881         style()->pixelMetric(QStyle::PM_HeaderGripMargin) : 0;

   882     int lim = d->positions[index] + 2*GripMargin;

   883     if (c == lim)

   884         return;

   885     if (c < lim)

   886         c = lim;

   887     int oldSize = d->sizes[section];

   888     int newSize = c - d->positions[index];

   889     d->sizes[section] = newSize;

   890 

   891     calculatePositions(!recalcAll, !recalcAll ? section : 0);

   892 

   893     int pos = d->positions[index]-offset();

   894     if(reverse()) // repaint the whole thing. Could be optimized (lars)

   895         repaint(0, 0, width(), height());

   896     else if (orient == Qt::Horizontal)

   897         repaint(pos, 0, width() - pos, height());

   898     else

   899         repaint(0, pos, width(), height() - pos);

   900 

   901     int os = 0, ns = 0;

   902     if (tracking() && oldSize != newSize) {

   903         os = oldSize;

   904         ns = newSize;

   905         emit sizeChange(section, oldSize, newSize);

   906     } else if (!tracking() && final && oldHIdxSize != newSize) {

   907         os = oldHIdxSize;

   908         ns = newSize;

   909         emit sizeChange(section, oldHIdxSize, newSize);

   910     }

   911 

   912     if (os != ns) {

   913         if (d->fullSize == -1) {

   914             d->fullSize = count() - 1;

   915             adjustHeaderSize();

   916             d->fullSize = -1;

   917         } else if (d->fullSize >= 0) {

   918             int old = d->fullSize;

   919             d->fullSize = count() - 1;

   920             adjustHeaderSize();

   921             d->fullSize = old;

   922         }

   923     }

   924 }

   925 

   926 /*!

   927     Returns the rectangle covered by the section at index \a index.

   928 */

   929 

   930 QRect Q3Header::sRect(int index)

   931 {

   932 

   933     int section = mapToSection(index);

   934     if (count() > 0 && index >= count()) {

   935         int s = d->positions[count() - 1] - offset() +

   936                 d->sizes[mapToSection(count() - 1)];

   937         if (orient == Qt::Horizontal)

   938             return QRect(s, 0, width() - s + 10, height());

   939         else

   940             return QRect(0, s, width(), height() - s + 10);

   941     }

   942     if (section < 0)

   943         return rect(); // ### eeeeevil

   944 

   945     if (reverse())

   946         return QRect( d->lastPos - d->positions[index] - d->sizes[section] -offset(),

   947                        0, d->sizes[section], height());

   948     else if (orient == Qt::Horizontal)

   949         return QRect( d->positions[index]-offset(), 0, d->sizes[section], height());

   950     else

   951         return QRect(0, d->positions[index]-offset(), width(), d->sizes[section]);

   952 }

   953 

   954 /*!

   955     Returns the rectangle covered by section \a section.

   956 */

   957 

   958 QRect Q3Header::sectionRect(int section) const

   959 {

   960     int index = mapToIndex(section);

   961     if (section < 0)

   962         return rect(); // ### eeeeevil

   963 

   964     if (reverse())

   965         return QRect( d->lastPos - d->positions[index] - d->sizes[section] -offset(),

   966                        0, d->sizes[section], height());

   967     else if (orient == Qt::Horizontal)

   968         return QRect( d->positions[index]-offset(), 0, d->sizes[section], height());

   969     else

   970         return QRect(0, d->positions[index]-offset(), width(), d->sizes[section]);

   971 }

   972 

   973 /*!

   974     \overload

   975 

   976     Sets the icon for section \a section to \a icon and the text to

   977     \a s. The section's width is set to \a size if \a size \>= 0;

   978     otherwise it is left unchanged.

   979 

   980     If the section does not exist, nothing happens.

   981 */

   982 

   983 void Q3Header::setLabel(int section, const QIcon& icon,

   984                         const QString &s, int size)

   985 {

   986     if (section < 0 || section >= count())

   987         return;

   988     delete d->icons[section];

   989     d->icons[section] = new QIcon(icon);

   990     setLabel(section, s, size);

   991 }

   992 

   993 /*!

   994     Sets the text of section \a section to \a s. The section's width

   995     is set to \a size if \a size \>= 0; otherwise it is left

   996     unchanged. Any icon set that has been set for this section remains

   997     unchanged.

   998 

   999     If the section does not exist, nothing happens.

  1000 */

  1001 void Q3Header::setLabel(int section, const QString &s, int size)

  1002 {

  1003     if (section < 0 || section >= count())

  1004         return;

  1005     d->labels[section] = s;

  1006     d->nullStringLabels.setBit(section, s.isNull());

  1007 

  1008     setSectionSizeAndHeight(section, size);

  1009 

  1010     if (updatesEnabled()) {

  1011         updateGeometry();

  1012         calculatePositions();

  1013         update();

  1014     }

  1015 }

  1016 

  1017 

  1018 bool qt_qheader_label_return_null_strings = false;

  1019 /*!

  1020     Returns the text for section \a section. If the section does not

  1021     exist, returns an empty string.

  1022 */

  1023 QString Q3Header::label(int section) const

  1024 {

  1025     if (section < 0 || section >= count())

  1026         return QString();

  1027     QString l = d->labels.value(section);

  1028     if (!l.isNull())

  1029         return l;

  1030     if (d->nullStringLabels.testBit(section) || qt_qheader_label_return_null_strings)

  1031         return l;

  1032     else

  1033         return QString::number(section + 1);

  1034 }

  1035 

  1036 /*!

  1037     Returns the icon set for section \a section. If the section does

  1038     not exist, 0 is returned.

  1039 */

  1040 

  1041 QIcon *Q3Header::iconSet(int section) const

  1042 {

  1043     if (section < 0 || section >= count())

  1044         return 0;

  1045     return d->icons[section];

  1046 }

  1047 

  1048 

  1049 /*!

  1050     \overload

  1051 

  1052     Adds a new section with icon \a icon and label text \a s.

  1053     Returns the index position where the section was added (at the

  1054     right for horizontal headers, at the bottom for vertical headers).

  1055     The section's width is set to \a size, unless size is negative in

  1056     which case the size is calculated taking account of the size of

  1057     the text.

  1058 */

  1059 int Q3Header::addLabel(const QIcon& icon, const QString &s, int size)

  1060 {

  1061     int n = count() + 1;

  1062     d->icons.resize(n + 1);

  1063     d->icons.insert(n - 1, new QIcon(icon));

  1064     return addLabel(s, size);

  1065 }

  1066 

  1067 /*!

  1068     Removes section \a section. If the section does not exist, nothing

  1069     happens.

  1070 */

  1071 void Q3Header::removeLabel(int section)

  1072 {

  1073     if (section < 0 || section > count() - 1)

  1074         return;

  1075 

  1076     int index = d->s2i[section];

  1077     int n = --d->count;

  1078     int i;

  1079     for (i = section; i < n; ++i) {

  1080         d->sizes[i] = d->sizes[i+1];

  1081         d->labels[i] = d->labels[i+1];

  1082         d->labels[i+1] = QString();

  1083         d->nullStringLabels[i] = d->nullStringLabels[i+1];

  1084         d->nullStringLabels[i+1] = 0;

  1085         d->icons[i] = d->icons[i+1];

  1086         d->icons[i+1] = 0;

  1087     }

  1088 

  1089     d->sizes.resize(n);

  1090     d->positions.resize(n);

  1091     d->labels.resize(n);

  1092     d->nullStringLabels.resize(n);

  1093     d->icons.resize(n);

  1094 

  1095     for (i = section; i < n; ++i)

  1096         d->s2i[i] = d->s2i[i+1];

  1097     d->s2i.resize(n);

  1098 

  1099     if (updatesEnabled()) {

  1100         for (i = 0; i < n; ++i)

  1101             if (d->s2i[i] > index)

  1102                 --d->s2i[i];

  1103     }

  1104 

  1105     for (i = index; i < n; ++i)

  1106         d->i2s[i] = d->i2s[i+1];

  1107     d->i2s.resize(n);

  1108 

  1109     if (updatesEnabled()) {

  1110         for (i = 0; i < n; ++i)

  1111             if (d->i2s[i] > section)

  1112                 --d->i2s[i];

  1113     }

  1114 

  1115     if (updatesEnabled()) {

  1116         updateGeometry();

  1117         calculatePositions();

  1118         update();

  1119     }

  1120 }

  1121 

  1122 QSize Q3Header::sectionSizeHint(int section, const QFontMetrics& fm) const

  1123 {

  1124     int iw = 0;

  1125     int ih = 0;

  1126     if (d->icons[section] != 0) {

  1127         QSize isize = d->icons[section]->pixmap(style()->pixelMetric(QStyle::PM_SmallIconSize),

  1128                                                     QIcon::Normal).size();

  1129         iw = isize.width() + 2;

  1130         ih = isize.height();

  1131     }

  1132 

  1133     QRect bound;

  1134     QString label = d->labels[section];