1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include <QLineF>

    19 #include <QtGlobal>

    20 #include <QPointF>

    21 #include <math.h>

    22 

    23 #include <HbInstance>

    24 

    25 

    26 #include "hswidgetpositioningonwidgetadd.h"

    27 

    28 const qreal offset = 40; //TODO: Implement this as configurable parameter

    29 

    30 

    31 /*!

    32     \class HsWidgetPositioningOnWidgetAdd

    33     \ingroup group_hsutils

    34     \brief 

    35 */

    36 

    37 /*!

    38     \class HsWidgetPositioningOnWidgetAdd

    39     \brief Defines widget positioning on widget add.

    40 

    41     Widget positioning on widget add sets positions for

    42     a set of home screen widgets added from application library.

    43 */

    44 

    45 /*!

    46     Sets the positioning \a instance as the current one.

    47     Deletes the existing instance if present.

    48 */

    49 void HsWidgetPositioningOnWidgetAdd::setInstance(

    50     HsWidgetPositioningOnWidgetAdd *instance)

    51 {

    52     if (mInstance)

    53         delete mInstance;

    54     mInstance = instance;

    55 }

    56  

    57 /*!

    58     Returns the current positioning instance.

    59 */

    60 HsWidgetPositioningOnWidgetAdd *HsWidgetPositioningOnWidgetAdd::instance()

    61 {

    62     return mInstance;

    63 }

    64 

    65 /*!

    66     Stores the current positioning instance.

    67 */

    68 HsWidgetPositioningOnWidgetAdd *HsWidgetPositioningOnWidgetAdd::mInstance = 0;

    69 

    70 /*!

    71     \class HsAnchorPointInBottomRight

    72     \brief Diagonal widget positioning algorithm.

    73     

    74     Sets widget's lower right corner to follow content area's diagonal.

    75     Widgets are positioned to certain offset to each other.

    76 */

    77 QList<QRectF> HsAnchorPointInBottomRight::convert(

    78     const QRectF &contentArea,

    79     const QList<QRectF> &existingRects,

    80     const QList<QRectF> &newRects,

    81     const QPointF &startPoint)

    82 {

    83     Q_UNUSED(existingRects);

    84 

    85     QList<QRectF> toGeometries;

    86 

    87     //Offset for widgets' bottom right position to each other

    88     qreal k = contentArea.height()/contentArea.width(); //slope of the diagonal

    89     qreal offset_x = offset/(sqrt(k + 1));

    90     qreal offset_y = k*offset_x;

    91     QPointF offsetPoint(offset_x, offset_y);

    92     

    93     QPointF anchorPoint;

    94    

    95     if(startPoint.isNull()){

    96 

    97         QLineF diagonal(contentArea.topLeft(), contentArea.bottomRight());

    98         QLineF widgetRightSide(contentArea.center().x()+ newRects.at(0).width()/2,

    99                            contentArea.top(),

   100                            contentArea.center().x()+ newRects.at(0).width()/2,

   101                            contentArea.bottom());

   102 

   103         // right side line intersection with diagonal will be bottom right position

   104         // for the first rect

   105         if(QLineF::BoundedIntersection != 

   106             diagonal.intersect(widgetRightSide, &anchorPoint)) {

   107             return newRects; //Return original since undefined error.

   108                             //In this case widget's must be wider than the content area.

   109         }

   110     }else{

   111         anchorPoint = startPoint - offsetPoint;

   112     }

   113 

   114     QRectF widgetRect;

   115     for(int i=0;i<newRects.count();++i) {

   116         widgetRect = newRects.at(i);

   117         widgetRect.moveBottomRight(anchorPoint);

   118         //if widget rect doesn't fit, try to move it

   119         if(!contentArea.contains(widgetRect)) {

   120             /*! precondition is that

   121              widget's max height < content area height

   122              widget's max widht < content area width

   123             */

   124             widgetRect.moveBottomRight(contentArea.bottomRight());

   125             // anchorPoin is always previous bottom right

   126             anchorPoint = widgetRect.bottomRight();

   127         }

   128         toGeometries << widgetRect;

   129         anchorPoint -= offsetPoint;

   130         

   131     }

   132     return toGeometries;

   133 }

   134 

   135 

   136 /*!

   137     \class HsAnchorPointInCenter

   138     \brief Diagonal widget positioning algorithm.

   139     

   140     Sets widget's center point to follow content area's diagonal.

   141     Widgets are positioned to certain offset to each other.

   142 */

   143 #ifdef COVERAGE_MEASUREMENT

   144 #pragma CTC SKIP

   145 #endif //COVERAGE_MEASUREMENT

   146 QList<QRectF> HsAnchorPointInCenter::convert(

   147     const QRectF &contentArea,

   148     const QList<QRectF> &existingRects,

   149     const QList<QRectF> &newRects,

   150     const QPointF &startPoint )

   151 {

   152     Q_UNUSED(existingRects);

   153     Q_UNUSED(startPoint)

   154 

   155     QList<QRectF> toGeometries;

   156 

   157     //Offset for widgets' centers position to each other

   158     qreal k = contentArea.height()/contentArea.width(); //slope of the diagonal

   159     qreal offset_x = offset/(sqrt(k + 1));

   160     qreal offset_y = k*offset_x;

   161     QPointF offsetPoint(offset_x, offset_y);

   162 

   163     //First widget to the center of the content area

   164     QPointF anchorPoint = contentArea.center();

   165     foreach (QRectF g, newRects) {

   166         g.moveCenter(anchorPoint);

   167         toGeometries << g;

   168         anchorPoint -= offsetPoint;

   169         if(!contentArea.contains(anchorPoint)) {

   170             anchorPoint = contentArea.bottomRight();

   171         }

   172     }

   173     return toGeometries;

   174 }

   175 

   176 /*!

   177     \class HsWidgetOrganizer

   178     \brief Advanced widget positioning algorithm.

   179     

   180     Organizes widget's starting from upper left corner towards right,

   181     and then continues the on the next line.

   182 */

   183 QList<QRectF> HsWidgetOrganizer::convert(

   184     const QRectF &contentArea,

   185     const QList<QRectF> &existingRects,

   186     const QList<QRectF> &newRects,

   187     const QPointF &startPoint)

   188 {

   189     Q_UNUSED(startPoint)

   190 

   191     // TODO: maybe we can utilize start point in some use cases / optimizations?

   192 

   193     QList<QRectF> toGeometries;

   194 

   195     // TODO: anchor distance to configuration?

   196     // TODO: optimize anchor distance based on new content amount

   197     // TODO: snap value to same as anchor distance?

   198     mAnchorDistance = 5;

   199     QList<bool> temp;

   200     mAnchors = temp;

   201 

   202     // test flag

   203 //    int test = 0;

   204 

   205     // initialize anchor network for widget positions

   206 //    if (test == 0) {

   207         initAnchors(contentArea.size());

   208 //    } else {

   209 //        mAnchorDistance = 2;

   210 //        initAnchors(QSizeF(6,6));

   211 //    }

   212 

   213     // mark existing rects (widgets) reserved

   214     foreach (QRectF rect, existingRects) {

   215         // TODO: could mStartWidthAnchorPoint, mEndWidthAnchorPoint, mEndHeightAnchorPoint be somehow refactored better way?

   216         mStartWidthAnchorPoint.setX(lenghtInAnchorPoints(rect.x() - contentArea.x()));

   217         mEndWidthAnchorPoint.setX(lenghtInAnchorPoints(rect.x() + rect.width() - contentArea.x()));

   218         mStartWidthAnchorPoint.setY(lenghtInAnchorPoints(rect.y() - contentArea.y()));

   219         mEndHeightAnchorPoint.setY(lenghtInAnchorPoints(rect.y() + rect.height() - contentArea.y()));

   220         // mark reserved anchor points

   221         markReservedAnchors();

   222         mStartWidthAnchorPoint = QPointF(0,0);

   223         mEndWidthAnchorPoint = QPointF(0,0);

   224         mEndHeightAnchorPoint = QPointF(0,0);

   225     }

   226 

   227     QList<QRectF> notOrganizedRects;

   228 

   229     // get positions for all new rects (widgets)

   230     for ( int i = 0; i < newRects.count(); i++) {

   231         bool found = false;

   232 //        if (test == 0) {

   233             // find first free anchor point for rect

   234             found = getAnchorPoint(newRects.at(i).size());

   235 //        } else {

   236 //            found = getAnchorPoint(QSizeF(2,2));

   237 //        }

   238 

   239         if (found) {

   240             // save to geometry list

   241             toGeometries << QRectF(mStartWidthAnchorPoint.x() * mAnchorDistance + contentArea.x(),

   242                                    mStartWidthAnchorPoint.y() * mAnchorDistance + contentArea.y(),

   243                                    newRects.at(i).width(), newRects.at(i).height());

   244             // mark new widgets rect reserved

   245             markReservedAnchors();

   246             // TODO: these optimizations could be used for empty page

   247             //mStartWidthAnchorPoint.setX(mEndWidthAnchorPoint.x() + 1);

   248             //mStartWidthAnchorPoint.setY(mEndWidthAnchorPoint.y());

   249         } else {

   250             // collect widgets that do not fit

   251             notOrganizedRects << newRects.at(i);

   252         }

   253         // TODO: remove these to optimize for empty page

   254         mStartWidthAnchorPoint = QPointF(0,0);

   255         mEndWidthAnchorPoint = QPointF(0,0);

   256     }

   257 

   258     // use center algorithm with offset for the rest widget that did not fit to screen

   259     if (notOrganizedRects.count() > 0) {

   260         QList<QRectF> tmpExistingRects;

   261         tmpExistingRects += newRects;

   262         tmpExistingRects += existingRects;

   263         HsAnchorPointInCenter *centerAlgorithm = new HsAnchorPointInCenter();

   264         QList<QRectF> calculatedRects =

   265             centerAlgorithm->convert(contentArea, tmpExistingRects, notOrganizedRects, QPointF());

   266         toGeometries += calculatedRects;

   267         delete centerAlgorithm;

   268     }

   269 

   270     return toGeometries;

   271 }

   272 

   273 

   274 /*!    

   275     Initializes anchor points for context area

   276 */

   277 bool HsWidgetOrganizer::initAnchors(const QSizeF &areaSize)

   278 {

   279     // mandatory check ups

   280     // TODO: these mAnchorDistance checks to earlier phase

   281     if (areaSize == QSizeF(0,0) || areaSize.width() < mAnchorDistance ||

   282         areaSize.height() < mAnchorDistance || mAnchorDistance == 0 || mAnchorDistance == 1) {

   283         return false;

   284     }

   285     mAnchorColumns = 0;

   286     mAnchorRows = 0;

   287 

   288     // TODO: can we optimize anchor amount utilizing minimum widget size

   289     mAnchorColumns = lenghtInAnchorPoints(areaSize.width());

   290     mAnchorRows = lenghtInAnchorPoints(areaSize.height());

   291 

   292     // create anchor network

   293     for (int i = 0; i < (mAnchorRows * mAnchorColumns); i++) {

   294         mAnchors << false;

   295     }

   296     // zero start points

   297     mStartWidthAnchorPoint = QPointF(0,0);

   298     mEndWidthAnchorPoint = QPointF(0,0);

   299 

   300     return true;

   301 }

   302 

   303 /*!    

   304     Finds anchor points for content size

   305 */

   306 bool HsWidgetOrganizer::getAnchorPoint(const QSizeF &contentSize)

   307 {

   308     bool anchorFound = false;

   309 

   310     while (anchorFound == false) {

   311         // if no width found for content

   312         if (!searchWidthSpace(contentSize)) {

   313             // when content organized in height order remove this line for optimization

   314             mStartWidthAnchorPoint = QPointF(0,0);

   315             mEndWidthAnchorPoint = QPointF(0,0);

   316             return false;

   317         }

   318         // search height for content

   319         int height = lenghtInAnchorPoints(contentSize.height());

   320         anchorFound = searchHeightSpace(height);

   321     }

   322     return true;

   323 }

   324 

   325 /*!    

   326     Searches anchor point width for content size

   327 */

   328 bool HsWidgetOrganizer::searchWidthSpace(const QSizeF &contentSize) 

   329 {

   330     int availableWidth = 0;    

   331     int contentWidth = lenghtInAnchorPoints(contentSize.width());

   332     // TODO: use this optimizations for empty page

   333     //int contentHeight = lenghtInAnchorPoints(contentSize.height());

   334     bool newRow = true;

   335 

   336     for (int i = getIndexForCoordinate(mStartWidthAnchorPoint); i <= mAnchors.count(); i++) {

   337         // no width left on the page

   338         if ((newRow == false) && ((i % (mAnchorColumns)) == 0)) {

   339             availableWidth = 0;

   340             // jump to new row

   341             mStartWidthAnchorPoint.setX(0);

   342             // TODO: use this optimizations for empty page

   343             //mStartWidthAnchorPoint.setY(mStartWidthAnchorPoint.y() + contentHeight + 1);

   344             mStartWidthAnchorPoint.setY(mStartWidthAnchorPoint.y() + 1);

   345             i = getIndexForCoordinate(mStartWidthAnchorPoint) - 1;

   346             // if no height found

   347             if (i < 0) {

   348                 return false;

   349             }

   350             newRow = true;

   351         } else {

   352             // if enough width found

   353             if (availableWidth == contentWidth) {

   354                 mEndWidthAnchorPoint = getAnchorCoordinates(i);

   355                 if (mEndWidthAnchorPoint == QPointF()) {

   356                     return false;

   357                 }

   358                 return true;

   359             }

   360             // if anchor reserved

   361             if (mAnchors[i] == true) {

   362                 availableWidth = 0;

   363             } else {

   364                 // update available width

   365                 availableWidth = availableWidth + 1;

   366             }

   367             newRow = false;

   368         }   

   369     }

   370     return false;

   371 }

   372 

   373 /*!    

   374     Searches anchor point area for content size

   375 */

   376 bool HsWidgetOrganizer::searchHeightSpace(int contentHeight)

   377 {

   378     mEndHeightAnchorPoint = QPointF(0,0);

   379  

   380     for (int i = mStartWidthAnchorPoint.x(); i <= mEndWidthAnchorPoint.x(); i++) {

   381         for (int j = mStartWidthAnchorPoint.y(); j <= (mStartWidthAnchorPoint.y() + contentHeight); j++) {

   382             int index = getIndexForCoordinate(QPointF(i,j));

   383             // check that index is not out of bounds

   384             if (index == -1) {

   385                 // update start width point one step

   386                 mStartWidthAnchorPoint.setX(mStartWidthAnchorPoint.x() + 1); 

   387                 return false;

   388             }

   389             // if anchor reserved

   390             if (mAnchors[index] == true) {

   391                 // update start width point one step

   392                 mStartWidthAnchorPoint.setX(mStartWidthAnchorPoint.x() + 1);

   393                 return false;

   394             }

   395         }

   396     }

   397     mEndHeightAnchorPoint = QPointF(mEndWidthAnchorPoint.x(), mEndWidthAnchorPoint.y() + contentHeight);

   398     return true;

   399 }

   400 

   401 /*!    

   402     Marks reserved anchor points based on pre-defined starting and ending points

   403 */

   404 bool HsWidgetOrganizer::markReservedAnchors()

   405 {

   406     for (int i = mStartWidthAnchorPoint.x(); i <= mEndWidthAnchorPoint.x(); i++) {

   407         for (int j = mStartWidthAnchorPoint.y(); j <= mEndHeightAnchorPoint.y(); j++) {

   408             mAnchors[getIndexForCoordinate(QPointF(i,j))] = true;

   409         }

   410     }

   411     return true;

   412 }

   413 

   414 /*!    

   415     Returns pixel coordinate based on anchor coordinate

   416 */

   417 QPointF HsWidgetOrganizer::getAnchorCoordinates(int index)

   418 {

   419     if (index < mAnchors.count()) {

   420         int x = index % mAnchorColumns;

   421         int y = (index - x) / mAnchorColumns;

   422         return QPointF(x,y);

   423     } else {

   424         return QPointF();

   425     }

   426 }

   427 

   428 /*!    

   429     Returns anchor coordinate based on pixel coordinate

   430 */

   431 int HsWidgetOrganizer::getIndexForCoordinate(QPointF position)

   432 {

   433     int index = (position.y() * mAnchorColumns) + position.x();

   434     if (index < mAnchors.count()) {

   435         return index;

   436     } else {

   437         return -1;

   438     }

   439 }

   440 

   441 /*!    

   442     Calculates pixel length as anchor points

   443 */

   444 int HsWidgetOrganizer::lenghtInAnchorPoints(QVariant length)

   445 {

   446     // check remainder

   447     int remainder = length.toInt() % mAnchorDistance;

   448     return ((length.toInt() - remainder) / mAnchorDistance);

   449 }

   450 

   451 #ifdef COVERAGE_MEASUREMENT

   452 #pragma CTC ENDSKIP

   453 #endif //COVERAGE_MEASUREMENT

   454