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

     2 **

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

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (developer.feedback@nokia.com)

     6 **

     7 ** This file is part of the HbWidgets module of the UI Extensions for Mobile.

     8 **

     9 ** GNU Lesser General Public License Usage

    10 ** This file may be used under the terms of the GNU Lesser General Public

    11 ** License version 2.1 as published by the Free Software Foundation and

    12 ** appearing in the file LICENSE.LGPL included in the packaging of this file.

    13 ** Please review the following information to ensure the GNU Lesser General

    14 ** Public License version 2.1 requirements will be met:

    15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    16 **

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

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

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

    20 **

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

    22 ** Nokia at developer.feedback@nokia.com.

    23 **

    24 ****************************************************************************/

    25 

    26 #include "hbslidertickmarks_p.h"

    27 #include "hbwidget_p.h"

    28 #include "hbslidercontrol_p.h"

    29 #include "hbsliderhandle_p.h"

    30 #include <hbstyle.h>

    31 #include <hbstyleoptionslider.h>

    32 #include <hbstyle.h>

    33 #include <hbapplication.h>

    34 #include <hbiconitem.h>

    35 #include <QList>

    36 

    37 

    38 

    39 

    40 

    41 

    42 class HbSliderTickmarksPrivate : public HbWidgetPrivate

    43 {

    44     Q_DECLARE_PUBLIC( HbSliderTickmarks )

    45 

    46 public:

    47     HbSliderTickmarksPrivate();

    48     void createTicks( );

    49     void updateTickSize( );

    50     HbStyleOptionSlider sliderOption;

    51     QList<QGraphicsWidget *> tickmarkmajorIcons;

    52     QList<QGraphicsWidget *> tickmarkminorIcons;

    53     HbSliderControl *sliderControl;

    54     Hb::SliderTickPositions tickPosition;

    55     bool createIcons;

    56     int majorTickWidth;

    57     int minorTickWidth;

    58     int majorTickHeight;

    59     int minorTickHeight;

    60 };

    61 

    62 

    63  HbSliderTickmarksPrivate::HbSliderTickmarksPrivate() :HbWidgetPrivate(){

    64     tickmarkmajorIcons.clear();

    65     tickmarkminorIcons.clear();

    66     sliderControl = 0;

    67     tickPosition = Hb::NoSliderTicks;

    68     createIcons = true;

    69     majorTickWidth = 0;

    70     minorTickWidth = 0;

    71     majorTickHeight = 0;

    72     minorTickHeight = 0;

    73 }

    74 

    75 

    76 void  HbSliderTickmarksPrivate::createTicks(  )

    77 {

    78     Q_Q ( HbSliderTickmarks );

    79     if(!createIcons){

    80         return;

    81     }

    82     int minimum = sliderControl->minimum();

    83     int maximum = sliderControl->maximum();

    84     int majorTickInterval = sliderControl->majorTickInterval ( );

    85     int minorTickInterval = sliderControl->minorTickInterval ( );

    86     if (majorTickInterval) {

    87         int totalMajorTicks = ((maximum-minimum)/majorTickInterval)+1;

    88         int majorIconListLength =  tickmarkmajorIcons.length();

    89         for (int i=majorIconListLength;i<totalMajorTicks;i++) {

    90             QGraphicsItem *iconItem = q->style()->createPrimitive(HbStyle::P_SliderTickMark_majoricon, q);

    91             Q_ASSERT(iconItem->isWidget());

    92             tickmarkmajorIcons.append(static_cast<QGraphicsWidget *>(iconItem));//add newly defind primitive

    93         }

    94         while ( totalMajorTicks < tickmarkmajorIcons.length() ) {

    95             QGraphicsWidget *iconItem = tickmarkmajorIcons.at(totalMajorTicks);

    96             tickmarkmajorIcons.removeAll(iconItem);

    97             delete iconItem;

    98         }

    99     }

   100     if ( minorTickInterval > 0) {

   101         int totalMinorTicks = ((maximum-minimum)/minorTickInterval)+1;

   102         if ( majorTickInterval ) {

   103             int maximumMinorTicks = totalMinorTicks;

   104             for (int i=0;i< maximumMinorTicks;i++ ) {

   105                 if ((i*minorTickInterval)%majorTickInterval==0) {

   106                     totalMinorTicks--;

   107                 }

   108             }

   109         }

   110         int minorIconListLength =  tickmarkminorIcons.length();

   111         for (int i=minorIconListLength;i<totalMinorTicks;i++) {

   112             QGraphicsItem *iconItem =  q->style()->createPrimitive(HbStyle::P_SliderTickMark_minoricon, q);

   113             Q_ASSERT(iconItem->isWidget());

   114             tickmarkminorIcons.append(static_cast<QGraphicsWidget *>(iconItem));//add newly defind primitive

   115         }

   116         while (totalMinorTicks < tickmarkminorIcons.length() ){

   117             QGraphicsWidget *iconItem = tickmarkminorIcons.at(totalMinorTicks);

   118             tickmarkminorIcons.removeAll(iconItem);

   119             delete iconItem;

   120         }

   121     } else {

   122         while (tickmarkminorIcons.length() > 0 ){

   123             QGraphicsWidget *iconItem = tickmarkminorIcons.at(0);

   124             tickmarkminorIcons.removeAll(iconItem);

   125             delete iconItem;

   126         }

   127     }

   128     q->setProperty("state", "normal"); 

   129 }

   130 

   131 void HbSliderTickmarksPrivate::updateTickSize()

   132 {

   133     for(int i=0;i<tickmarkmajorIcons.length();i++) {

   134         tickmarkmajorIcons.at(i)->setMinimumSize(majorTickWidth,majorTickHeight);

   135         tickmarkmajorIcons.at(i)->setMaximumSize(majorTickWidth,majorTickHeight);

   136     }

   137     for(int i=0;i<tickmarkminorIcons.length();i++) {

   138         tickmarkminorIcons.at(i)->setMinimumSize(minorTickWidth,minorTickHeight);

   139         tickmarkminorIcons.at(i)->setMaximumSize(minorTickWidth,minorTickHeight);

   140     }

   141 

   142 

   143 }

   144 

   145 void HbSliderTickmarks::resizeEvent(QGraphicsSceneResizeEvent *event)

   146 {

   147     Q_UNUSED (event);

   148     HbWidget::resizeEvent( event );

   149     repolish();

   150 }

   151 

   152 

   153 /*!

   154     This class is internal to slider ,

   155     this creates ticks mark widget in slider

   156 */

   157 

   158 /*!

   159     constructor

   160 */

   161 HbSliderTickmarks::HbSliderTickmarks( QGraphicsItem *parent )

   162     : HbWidget( *new HbSliderTickmarksPrivate, parent )

   163 {

   164     Q_D( HbSliderTickmarks );

   165     d->q_ptr = this;

   166     d->sliderControl=dynamic_cast<HbSliderControl*>( parentItem() );

   167     d->createTicks();

   168 }

   169 

   170 /*!

   171     destructor

   172 */

   173 HbSliderTickmarks::~HbSliderTickmarks()

   174 {

   175 }

   176 

   177 void HbSliderTickmarks::createIcons( bool create ) 

   178 {

   179 

   180     Q_D(HbSliderTickmarks);

   181     d->createIcons = create;

   182     if (!create) {

   183         while ( d->tickmarkmajorIcons.length() > 0) {

   184             QGraphicsWidget *iconItem = d->tickmarkmajorIcons.at(0);

   185             d->tickmarkmajorIcons.removeAll(iconItem);

   186             delete iconItem;

   187         }

   188         while ( d->tickmarkminorIcons.length() > 0) {

   189             QGraphicsWidget *iconItem = d->tickmarkminorIcons.at(0);

   190             d->tickmarkminorIcons.removeAll(iconItem);

   191             delete iconItem;

   192         }

   193     } else {

   194         d->createTicks();

   195     }

   196  }

   197 /*!

   198     updates the ticks whenever there is change in position or number of ticks

   199 */

   200 

   201 void HbSliderTickmarks::updateTicks( )

   202 {

   203     Q_D ( HbSliderTickmarks );

   204     if(!d->createIcons) {

   205         return;

   206     }

   207     d->createTicks();

   208     d->updateTickSize();

   209     int minimum = d->sliderControl->minimum();

   210     int maximum = d->sliderControl->maximum();

   211     int majorTickInterval = d->sliderControl->majorTickInterval ( );

   212     int minorTickInterval = d->sliderControl->minorTickInterval ( );

   213     qreal span = 0;

   214     bool rtlLayout = (((d->sliderControl->orientation()!=Qt::Vertical)&&

   215         (HbApplication::layoutDirection() == Qt::LeftToRight))?false:true);

   216     HbSliderHandle *handle = dynamic_cast <HbSliderHandle *> (d->sliderControl->primitive (HbStyle::P_Slider_thumb));

   217     if ( d->sliderControl->orientation() == Qt::Horizontal) {

   218         span = d->sliderControl->size().width();

   219         span-=handle->size().width();

   220     }

   221     if ( d->sliderControl->orientation() == Qt::Vertical) {

   222         span = d->sliderControl->size().height();

   223         span-=handle->size().height();

   224     }

   225     if (majorTickInterval) {

   226         int totalMajorTicks = ((maximum-minimum)/majorTickInterval)+1;

   227         for (int i=0;i<totalMajorTicks;i++) {

   228              QGraphicsWidget *iconItem = d->tickmarkmajorIcons.at ( i);

   229              HbStyleOptionSlider opt;

   230              initStyleOption(&opt);

   231              opt.orientation = d->sliderControl->orientation();

   232              style()->updatePrimitive(iconItem,HbStyle::P_SliderTickMark_majoricon,&opt);

   233             int pos = QStyle::sliderPositionFromValue( minimum, maximum,

   234                 minimum+majorTickInterval*i,static_cast<int>( span ), rtlLayout );

   235 

   236             if ( d->sliderControl->orientation() == Qt::Horizontal) {

   237                 qreal correctedPosX = handle->size().width()/2+pos; 

   238                 qreal correctedPosY = 0;

   239                 iconItem->setPos ( correctedPosX,correctedPosY );

   240                 iconItem->update();

   241             } else {

   242                 qreal correctedPosY = handle->size().height()/2+pos;

   243                 qreal correctedPosX =0;

   244                 iconItem->setPos ( correctedPosX,correctedPosY );

   245                 iconItem->update();

   246             }

   247         }

   248     }

   249     if (minorTickInterval) {

   250         int totalminorTicks = ((maximum-minimum)/minorTickInterval)+1;

   251         int minorIndex = 0;

   252         for (int i=0;i<totalminorTicks;i++) {

   253             if (majorTickInterval ) {

   254                 if (i*minorTickInterval%majorTickInterval== 0) {

   255                     continue;

   256                 }

   257             }

   258             QGraphicsWidget *iconItem = d->tickmarkminorIcons.at ( minorIndex);

   259             minorIndex++;

   260             HbStyleOptionSlider opt;

   261             initStyleOption(&opt);

   262             opt.orientation = d->sliderControl->orientation();

   263             style()->updatePrimitive(iconItem,HbStyle::P_SliderTickMark_minoricon,&opt);

   264             int pos = QStyle::sliderPositionFromValue( minimum, maximum,

   265                 minimum+minorTickInterval*i,static_cast<int>( span ), rtlLayout );

   266  

   267             if ( d->sliderControl->orientation() == Qt::Horizontal) {

   268                 qreal correctedPosX = handle->size().width()/2+pos; 

   269                 qreal correctedPosY = 0;

   270                 iconItem->setPos ( correctedPosX,correctedPosY );

   271                 iconItem->update();

   272 

   273             } else {

   274                 qreal correctedPosY = handle->size().height()/2+pos;

   275                 qreal correctedPosX =0;

   276                 iconItem->setPos ( correctedPosX,correctedPosY );

   277                 iconItem->update();

   278 

   279             }

   280         }

   281     }

   282  }

   283 

   284 /* !

   285     Sets the position of current tick

   286 */

   287 

   288 void HbSliderTickmarks::setTickPosition(Hb::SliderTickPositions position)

   289 {

   290     Q_D(HbSliderTickmarks);

   291     d->tickPosition = position;

   292 }

   293 

   294 

   295 /*!

   296     \reimp

   297 

   298     This api update the primitive when ever item enable has changed

   299  */

   300 QVariant HbSliderTickmarks::itemChange( GraphicsItemChange change, const QVariant &value )

   301 {

   302     switch( change )

   303     {

   304         case ItemChildAddedChange:

   305         case ItemChildRemovedChange:

   306             repolish();

   307             break;

   308         default:

   309             break;

   310     }

   311     return HbWidget::itemChange( change, value );

   312 }

   313 

   314 

   315 

   316 void HbSliderTickmarks::polish( HbStyleParameters& params )

   317 {

   318     Q_D (HbSliderTickmarks);

   319     params.addParameter("fixed-width-major");

   320     params.addParameter("fixed-height-major");

   321     params.addParameter("fixed-width-minor");

   322     params.addParameter("fixed-height-minor");

   323     HbWidget::polish(params);

   324     d->majorTickWidth = params.value("fixed-width-major").toInt();

   325     d->majorTickHeight = params.value("fixed-height-major").toInt();

   326     d->minorTickWidth = params.value("fixed-width-minor").toInt();

   327     d->minorTickHeight = params.value("fixed-height-minor").toInt();

   328     updateTicks();

   329 }

   330 

   331  //end of file

   332