ganeswidgets/src/hgindexfeedback.cpp
changeset 14 645b870db620
parent 6 1cdcc61142d2
equal deleted inserted replaced
12:6c0ec0ccd2d4 14:645b870db620
    17 
    17 
    18 #include "hgindexfeedback.h"
    18 #include "hgindexfeedback.h"
    19 #include "hgindexfeedback_p.h"
    19 #include "hgindexfeedback_p.h"
    20 
    20 
    21 #include <HbScrollbar>
    21 #include <HbScrollbar>
    22 #include <HbStyleOptionIndexFeedback>
       
    23 #include <HbStyleParameters>
    22 #include <HbStyleParameters>
    24 #include <HbStyle>
    23 #include <HbStyle>
    25 #include <HbDeviceProfile>
    24 #include <HbDeviceProfile>
    26 #include <hgwidgets/hgwidgets.h>
    25 #include <hgwidgets/hgwidgets.h>
    27 #include <HbStyleLoader>
    26 #include <HbStyleLoader>
    28 
    27 
    29 #include <QEvent>
    28 #include <QEvent>
    30 #include <QObject>
    29 #include <QObject>
    31 #include <QGraphicsScene>
    30 #include <QGraphicsScene>
    32 
    31 
    33 
       
    34 /* rather than magic numbers, let's define some constants. */
    32 /* rather than magic numbers, let's define some constants. */
    35 namespace {
    33 namespace {
    36 /*
    34 /*
    37     string name from the index feedback .css for the single character height parameter.
    35     string name from the index feedback .css for the single character height parameter.
    38 */
    36 */
    56 
    54 
    57 /*!
    55 /*!
    58     Constructs a new HgIndexFeedback with a parent.
    56     Constructs a new HgIndexFeedback with a parent.
    59 */
    57 */
    60 HgIndexFeedback::HgIndexFeedback(QGraphicsItem *parent)
    58 HgIndexFeedback::HgIndexFeedback(QGraphicsItem *parent)
    61     : HbWidget( *new HgIndexFeedbackPrivate, parent, 0)
    59     : HbWidget(parent), p_ptr(new HgIndexFeedbackPrivate)
    62 
    60 
    63 {
    61 {
    64     Q_D( HgIndexFeedback );
    62     Q_D( HgIndexFeedback );
    65     d->q_ptr = this;
    63     d->q_ptr = this;
    66 
    64 
    73     Destructs the index feedback.
    71     Destructs the index feedback.
    74 */
    72 */
    75 HgIndexFeedback::~HgIndexFeedback()
    73 HgIndexFeedback::~HgIndexFeedback()
    76 {
    74 {
    77     HbStyleLoader::unregisterFilePath(":/hgindexfeedback.css");
    75     HbStyleLoader::unregisterFilePath(":/hgindexfeedback.css");
       
    76     delete p_ptr;
    78 }
    77 }
    79 
    78 
    80 /*!
    79 /*!
    81     \brief sets the index feedback policy.
    80     \brief sets the index feedback policy.
    82 
    81 
   133         return;
   132         return;
   134     }
   133     }
   135 
   134 
   136     d->connectModelToIndexFeedback(d->mWidget->selectionModel());
   135     d->connectModelToIndexFeedback(d->mWidget->selectionModel());
   137 
   136 
   138     d->connectScrollBarToIndexFeedback(d->mWidget->scrollBar());
   137     d->connectWidgetToIndexFeedback();
   139 
   138 
   140     connect(d->mWidget, SIGNAL(destroyed(QObject*)),
   139     connect(d->mWidget, SIGNAL(destroyed(QObject*)),
   141         this, SLOT(_q_itemViewDestroyed()));
   140         this, SLOT(_q_itemViewDestroyed()));
   142 
   141 
   143     if (d->mWidget->scene()) {
   142     if (d->mWidget->scene()) {
   159     Q_D( const HgIndexFeedback );
   158     Q_D( const HgIndexFeedback );
   160 
   159 
   161     return d->mWidget;
   160     return d->mWidget;
   162 }
   161 }
   163 
   162 
   164 /*!
       
   165     Returns the primitives used in HgIndexFeedback.
       
   166 
       
   167     \param primitive The primitive type requested.
       
   168 
       
   169     \return A pointer for the primitive requested.
       
   170 */
       
   171 QGraphicsItem* HgIndexFeedback::primitive(HbStyle::Primitive primitive) const
       
   172 {
       
   173     Q_D( const HgIndexFeedback );
       
   174 
       
   175     QGraphicsItem* retVal = HbWidget::primitive(primitive);
       
   176 
       
   177     switch (primitive) {
       
   178         case HbStyle::P_IndexFeedback_popup_text:
       
   179             retVal = d->mTextItem;
       
   180             break;
       
   181 
       
   182         case HbStyle::P_IndexFeedback_popup_background:
       
   183             retVal = d->mPopupItem;
       
   184             break;
       
   185 
       
   186         default:
       
   187             qt_noop();
       
   188             break;
       
   189     }
       
   190 
       
   191     return retVal;
       
   192 }
       
   193 
       
   194 
       
   195 /*
   163 /*
   196     A scene event filter.  It's purpose is to call calculatePopupRects on
   164     A scene event filter.  It's purpose is to call calculatePopupRects on
   197     a resize event for the item view.
   165     a resize event for the item view.
   198 */
   166 */
   199 bool HgIndexFeedback::sceneEventFilter(QGraphicsItem *watched, QEvent *ev)
   167 bool HgIndexFeedback::sceneEventFilter(QGraphicsItem *watched, QEvent *ev)
   200 {
   168 {
   201     Q_D( HgIndexFeedback );
   169     Q_D( HgIndexFeedback );
   202 
   170 
   203     if (ev->type() == QEvent::GraphicsSceneResize) {
   171     if (ev->type() == QEvent::GraphicsSceneResize) {
   204         d->calculatePopupRects();
   172         d->calculatePopupRects();
       
   173         d->updatePrimitives();
   205     }
   174     }
   206 
   175 
   207     return QGraphicsItem::sceneEventFilter(watched, ev);
   176     return QGraphicsItem::sceneEventFilter(watched, ev);
   208 }
   177 }
   209 
   178 
   215     this function will call the appropriate function in HgIndexFeedbackPrivate.
   184     this function will call the appropriate function in HgIndexFeedbackPrivate.
   216 */
   185 */
   217 bool HgIndexFeedback::eventFilter(QObject *obj, QEvent *ev)
   186 bool HgIndexFeedback::eventFilter(QObject *obj, QEvent *ev)
   218 {
   187 {
   219     Q_D( HgIndexFeedback );
   188     Q_D( HgIndexFeedback );
   220     HbScrollBar* scrollBar = qobject_cast<HbScrollBar*>(obj);
   189     HbScrollBar *scrollBar = qobject_cast<HbScrollBar*>(obj);
   221 
   190     HgWidget *widget = qobject_cast<HgWidget*>(obj);
   222     if (d->mIndexFeedbackPolicy != HgWidget::IndexFeedbackNone
   191     
   223         && scrollBar) {
   192     if (d->mIndexFeedbackPolicy != HgWidget::IndexFeedbackNone) {
   224         switch (ev->type()) {
   193         if (scrollBar) {
   225             case QEvent::GraphicsSceneMousePress:
   194             switch (ev->type()) {
   226             case QEvent::MouseButtonPress:
   195                 case QEvent::GraphicsSceneMousePress:
   227                 if (scrollBar->isInteractive()) {
   196                 case QEvent::MouseButtonPress:
   228                     d->scrollBarPressed();
   197                     if (scrollBar->isInteractive()) {
   229                 }
   198                         d->scrollBarPressed();
   230                 break;
   199                     }
   231 
   200                     break;
   232             case QEvent::GraphicsSceneMouseRelease:
   201     
   233             case QEvent::MouseButtonRelease:
   202                 case QEvent::GraphicsSceneMouseRelease:
   234                 if (scrollBar->isInteractive()) {
   203                 case QEvent::MouseButtonRelease:
   235                     d->scrollBarReleased();
   204                     if (scrollBar->isInteractive()) {
   236                 }
   205                         d->scrollBarReleased();
   237                 break;
   206                     }
   238 
   207                     break;
   239             case QEvent::GraphicsSceneResize:
   208                 default:
   240             case QEvent::Resize:
   209                     // do nothing, ignore other events.
   241                     d->_q_hideIndexFeedbackNow();
   210                     break;
   242                     d->calculatePopupRects();
   211             }
   243                     d->updatePrimitives();
       
   244                 break;
       
   245 
       
   246             default:
       
   247                 // do nothing, ignore other events.
       
   248                 break;
       
   249         }
   212         }
       
   213         if (widget && (ev->type() == QEvent::GraphicsSceneResize || ev->type() == QEvent::Resize)) {
       
   214             // widget size has changed and size of the popup letter box depends from it
       
   215             // so recalculate the popup rects
       
   216             d->_q_hideIndexFeedbackNow();
       
   217             d->calculatePopupRects();
       
   218             d->updatePrimitives();
       
   219         }
   250     }
   220     }
   251 
   221 
   252     return QObject::eventFilter(obj, ev);
   222     return QObject::eventFilter(obj, ev);
   253 }
       
   254 
       
   255 /*
       
   256     For use with HbStyle.
       
   257 
       
   258     Provide the correct data to use in the 'model.'
       
   259 */
       
   260 void HgIndexFeedback::initStyleOption(HbStyleOptionIndexFeedback *option) const
       
   261 {
       
   262     Q_D( const HgIndexFeedback );
       
   263 
       
   264     HbWidget::initStyleOption(option);
       
   265 
       
   266     if (!d->mWidget) {
       
   267         return;
       
   268     }
       
   269 
       
   270     HbFontSpec fontSpec;
       
   271     qreal margin = 0;
       
   272 
       
   273     style()->parameter(QLatin1String("hb-param-margin-gene-popup"), margin);
       
   274 
       
   275     switch (d->mIndexFeedbackPolicy) {
       
   276         case HgWidget::IndexFeedbackSingleCharacter:
       
   277             {
       
   278                 fontSpec = HbFontSpec(HbFontSpec::Primary);
       
   279                 fontSpec.setTextHeight(d->textHeight());
       
   280             }
       
   281             break;
       
   282 
       
   283         case HgWidget::IndexFeedbackThreeCharacter:
       
   284             {
       
   285                 fontSpec = HbFontSpec(HbFontSpec::Primary);
       
   286                 fontSpec.setTextHeight(d->textHeight());
       
   287             }
       
   288             break;
       
   289 
       
   290         case HgWidget::IndexFeedbackString:
       
   291             {
       
   292                 fontSpec = HbFontSpec(HbFontSpec::Primary);
       
   293                 qreal textPaneHeight = 0;
       
   294                 style()->parameter(QLatin1String("hb-param-text-height-primary"), textPaneHeight);
       
   295                 fontSpec.setTextHeight( textPaneHeight );
       
   296             }
       
   297             break;
       
   298 
       
   299         case HgWidget::IndexFeedbackNone:
       
   300             // leave the HbStyleOption uninitialized
       
   301             return;
       
   302     }
       
   303 
       
   304     option->text = d->mPopupContent;
       
   305     option->fontSpec = fontSpec;
       
   306     option->textRect = d->mPopupTextRect;
       
   307     option->popupRect = d->mPopupBackgroundRect;
       
   308 }
   223 }
   309 
   224 
   310 void HgIndexFeedback::polish(HbStyleParameters& params)
   225 void HgIndexFeedback::polish(HbStyleParameters& params)
   311 {
   226 {
   312     Q_D( HgIndexFeedback );
   227     Q_D( HgIndexFeedback );
   322     d->mThreeCharHeight = params.value( THREE_CHAR_HEIGHT ).toDouble();
   237     d->mThreeCharHeight = params.value( THREE_CHAR_HEIGHT ).toDouble();
   323     d->mThreeCharWidth = params.value( THREE_CHAR_WIDTH ).toDouble();
   238     d->mThreeCharWidth = params.value( THREE_CHAR_WIDTH ).toDouble();
   324     d->mStringOffset = params.value( STRING_OFFSET ).toDouble();
   239     d->mStringOffset = params.value( STRING_OFFSET ).toDouble();
   325 
   240 
   326     d->calculatePopupRects();
   241     d->calculatePopupRects();
       
   242     d->updatePrimitives();
   327 }
   243 }
   328 
   244 
   329 #include "moc_hgindexfeedback.cpp"
   245 #include "moc_hgindexfeedback.cpp"