QTfrontend/qaspectratiolayout.cpp
changeset 4520 e7882bd1a894
parent 4477 63a21fac8bf7
equal deleted inserted replaced
4519:aee36896d46b 4520:e7882bd1a894
       
     1 /*
       
     2  * Copyright (c) 2009 Nokia Corporation.
       
     3  */
       
     4 
       
     5 #include "qaspectratiolayout.h"
       
     6 
       
     7 QAspectRatioLayout::QAspectRatioLayout(QWidget* parent, int spacing) : QLayout(parent) {
       
     8         init(spacing);
       
     9 }
       
    10 
       
    11 QAspectRatioLayout::QAspectRatioLayout(int spacing) {
       
    12         init(spacing);
       
    13 }
       
    14 
       
    15 QAspectRatioLayout::~QAspectRatioLayout() {
       
    16         delete item;
       
    17         delete lastReceivedRect;
       
    18         delete _geometry;
       
    19 }
       
    20 
       
    21 void QAspectRatioLayout::init(int spacing) {
       
    22         item = 0;
       
    23         lastReceivedRect = new QRect(0, 0, 0, 0);
       
    24         _geometry = new QRect(0, 0, 0, 0);
       
    25         setSpacing(spacing);
       
    26 }
       
    27 
       
    28 
       
    29 /* Adds item if place isn't already taken. */
       
    30 void QAspectRatioLayout::add(QLayoutItem* item) {
       
    31         if(!hasItem()) {
       
    32                 replaceItem(item);
       
    33         }
       
    34 }
       
    35 
       
    36 /* Adds item if place isn't already taken. */
       
    37 void QAspectRatioLayout::addItem(QLayoutItem* item) {
       
    38         if(!hasItem()) {
       
    39                 replaceItem(item);
       
    40         }
       
    41 }
       
    42 
       
    43 /* Adds widget if place isn't already taken. */
       
    44 void QAspectRatioLayout::addWidget(QWidget* widget) {
       
    45         if(!hasItem()) {
       
    46                 replaceItem(new QWidgetItem(widget));
       
    47         }
       
    48 }
       
    49 
       
    50 /* Returns the item pointer and dereferences it here. */
       
    51 QLayoutItem* QAspectRatioLayout::take() {
       
    52         QLayoutItem* item = 0;
       
    53         if(this->hasItem()) {
       
    54                 item = this->item;
       
    55                 this->item = 0;
       
    56         }
       
    57         return item;
       
    58 }
       
    59 
       
    60 /* Returns the item pointer and dereferences it here. */
       
    61 QLayoutItem* QAspectRatioLayout::takeAt(int index) {
       
    62         if(index != 0) {
       
    63                 return 0;
       
    64         }
       
    65         return this->take();
       
    66 }
       
    67 
       
    68 /* Returns the item pointer. */
       
    69 QLayoutItem* QAspectRatioLayout::itemAt(int index) const {
       
    70         if(index != 0) {
       
    71                 return 0;
       
    72         }
       
    73         if(hasItem()) {
       
    74                 return this->item;
       
    75         }
       
    76         return 0;
       
    77 }
       
    78 
       
    79 /* Checks if we have an item. */
       
    80 bool QAspectRatioLayout::hasItem() const {
       
    81         return this->item != 0;
       
    82 }
       
    83 
       
    84 /* Returns the count of items which can be either 0 or 1. */
       
    85 int QAspectRatioLayout::count() const {
       
    86         int returnValue = 0;
       
    87         if(hasItem()) {
       
    88                 returnValue = 1;
       
    89         }
       
    90         return returnValue;
       
    91 }
       
    92 
       
    93 /* Replaces the item with the new and returns the old. */
       
    94 QLayoutItem* QAspectRatioLayout::replaceItem(QLayoutItem* item) {
       
    95         QLayoutItem* old = 0;
       
    96         if(this->hasItem()) {
       
    97                 old = this->item;
       
    98         }
       
    99         this->item = item;
       
   100         setGeometry(*this->_geometry);
       
   101         return old;
       
   102 }
       
   103 
       
   104 /* Tells which way layout expands. */
       
   105 Qt::Orientations QAspectRatioLayout::expandingDirections() const {
       
   106         return Qt::Horizontal | Qt::Vertical;
       
   107 }
       
   108 
       
   109 /* Tells which size is preferred. */
       
   110 QSize QAspectRatioLayout::sizeHint() const {
       
   111         return this->item->minimumSize();
       
   112 }
       
   113 
       
   114 /* Tells minimum size. */
       
   115 QSize QAspectRatioLayout::minimumSize() const {
       
   116         return this->item->minimumSize();
       
   117 }
       
   118 
       
   119 /*
       
   120  * Tells if heightForWidth calculations is handled.
       
   121  * It isn't since width isn't enough to calculate
       
   122  * proper size.
       
   123  */
       
   124 bool QAspectRatioLayout::hasHeightForWidth() const {
       
   125         return false;
       
   126 }
       
   127 
       
   128 /* Replaces lastReceivedRect. */
       
   129 void QAspectRatioLayout::setLastReceivedRect(const QRect& rect) {
       
   130         QRect* oldRect = this->lastReceivedRect;
       
   131         this->lastReceivedRect = new QRect(rect.topLeft(), rect.size());
       
   132         delete oldRect;
       
   133 }
       
   134 
       
   135 /* Returns geometry */
       
   136 QRect QAspectRatioLayout::geometry() {
       
   137         return QRect(*this->_geometry);
       
   138 }
       
   139 
       
   140 /* Sets geometry to given size. */
       
   141 void QAspectRatioLayout::setGeometry(const QRect& rect) {
       
   142         /*
       
   143          * We check if the item is set and
       
   144          * if size is the same previously received.
       
   145          * If either is false nothing is done.
       
   146          */
       
   147         if(!this->hasItem() ||
       
   148            areRectsEqual(*this->lastReceivedRect, rect)) {
       
   149                 return;
       
   150         }
       
   151         /* Replace the last received rectangle. */
       
   152         setLastReceivedRect(rect);
       
   153         /* Calculate proper size for the item relative to the received size. */
       
   154         QSize properSize = calculateProperSize(rect.size());
       
   155         /* Calculate center location in the rect and with item size. */
       
   156         QPoint properLocation = calculateCenterLocation(rect.size(), properSize);
       
   157         /* Set items geometry */
       
   158         this->item->setGeometry(QRect(properLocation, properSize));
       
   159         QRect* oldRect = this->_geometry;
       
   160         /* Cache the calculated geometry. */
       
   161         this->_geometry = new QRect(properLocation, properSize);
       
   162         delete oldRect;
       
   163         /* Super classes setGeometry */
       
   164         QLayout::setGeometry(*this->_geometry);
       
   165 }
       
   166 
       
   167 /* Takes the shortest side and creates QSize
       
   168  * with the shortest side as width and height. */
       
   169 QSize QAspectRatioLayout::calculateProperSize(QSize from) const {
       
   170         QSize properSize;
       
   171         if(from.height() * 2 < from.width()) {
       
   172                 properSize.setHeight(from.height() - this->margin());
       
   173                 properSize.setWidth(from.height() * 2 - this->margin());
       
   174         }
       
   175         else {
       
   176                 properSize.setWidth(from.width() - this->margin());
       
   177                 properSize.setHeight(from.width() / 2 - this->margin());
       
   178         }
       
   179         return properSize;
       
   180 }
       
   181 
       
   182 /* Calculates center location from the given height and width for item size. */
       
   183 QPoint QAspectRatioLayout::calculateCenterLocation(QSize from,
       
   184                                                    QSize itemSize) const {
       
   185         QPoint centerLocation;
       
   186         if((from.width() - itemSize.width()) > 0) {
       
   187                 centerLocation.setX((from.width() - itemSize.width())/2);
       
   188         }
       
   189         if((from.height() - itemSize.height()) > 0) {
       
   190                 centerLocation.setY((from.height() - itemSize.height())/2);
       
   191         }
       
   192         return centerLocation;
       
   193 }
       
   194 
       
   195 /* Compares if two QRects are equal. */
       
   196 bool QAspectRatioLayout::areRectsEqual(const QRect& a,
       
   197                                        const QRect& b) const {
       
   198         bool result = false;
       
   199         if(a.x() == b.x() &&
       
   200            a.y() == b.y() &&
       
   201            a.height() == b.height() &&
       
   202            a.width() == b.width()) {
       
   203                 result = true;
       
   204         }
       
   205         return result;
       
   206 }