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 QtGui 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 /*!

    43     \class QGraphicsGridLayout

    44     \brief The QGraphicsGridLayout class provides a grid layout for managing

    45     widgets in Graphics View.

    46     \since 4.4

    47 

    48     \ingroup graphicsview-api

    49 

    50     The most common way to use QGraphicsGridLayout is to construct an object

    51     on the heap with no parent, add widgets and layouts by calling addItem(),

    52     and finally assign the layout to a widget by calling

    53     QGraphicsWidget::setLayout(). QGraphicsGridLayout automatically computes

    54     the dimensions of the grid as you add items.

    55 

    56     \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsgridlayout.cpp 0

    57 

    58     The layout takes ownership of the items. In some cases when the layout

    59     item also inherits from QGraphicsItem (such as QGraphicsWidget) there will be a

    60     ambiguity in ownership because the layout item belongs to two ownership hierarchies.

    61     See the documentation of QGraphicsLayoutItem::setOwnedByLayout() how to handle

    62     this.

    63     You can access each item in the layout by calling count() and itemAt(). Calling

    64     removeAt() will remove an item from the layout, without

    65     destroying it.

    66 

    67     \sa QGraphicsLinearLayout, QGraphicsWidget

    68 */

    69 

    70 #include "qglobal.h"

    71 

    72 #ifndef QT_NO_GRAPHICSVIEW

    73 

    74 #include "qapplication.h"

    75 #include "qwidget.h"

    76 #include "qgraphicslayout_p.h"

    77 #include "qgraphicslayoutitem.h"

    78 #include "qgraphicsgridlayout.h"

    79 #include "qgraphicswidget.h"

    80 #include "qgridlayoutengine_p.h"

    81 #include <QtCore/qdebug.h>

    82 

    83 QT_BEGIN_NAMESPACE

    84 

    85 class QGraphicsGridLayoutPrivate : public QGraphicsLayoutPrivate

    86 {

    87 public:

    88     QGraphicsGridLayoutPrivate() { }

    89     QLayoutStyleInfo styleInfo() const;

    90 

    91     QGridLayoutEngine engine;

    92 #ifdef QT_DEBUG

    93     void dump(int indent) const;

    94 #endif

    95 };

    96 

    97 QLayoutStyleInfo QGraphicsGridLayoutPrivate::styleInfo() const

    98 {

    99     static QWidget *wid = 0;

   100     if (!wid)

   101         wid = new QWidget;

   102     QGraphicsItem *item = parentItem();

   103     QStyle *style = (item && item->isWidget()) ? static_cast<QGraphicsWidget*>(item)->style() : QApplication::style();

   104     return QLayoutStyleInfo(style, wid);

   105 }

   106 

   107 /*!

   108     Constructs a QGraphicsGridLayout instance.  \a parent is passed to

   109     QGraphicsLayout's constructor.

   110 */

   111 QGraphicsGridLayout::QGraphicsGridLayout(QGraphicsLayoutItem *parent)

   112     : QGraphicsLayout(*new QGraphicsGridLayoutPrivate(), parent)

   113 {

   114 }

   115 

   116 /*!

   117     Destroys the QGraphicsGridLayout object.

   118 */

   119 QGraphicsGridLayout::~QGraphicsGridLayout()

   120 {

   121     for (int i = count() - 1; i >= 0; --i) {

   122         QGraphicsLayoutItem *item = itemAt(i);

   123         // The following lines can be removed, but this removes the item

   124         // from the layout more efficiently than the implementation of

   125         // ~QGraphicsLayoutItem.

   126         removeAt(i);

   127         if (item) {

   128             item->setParentLayoutItem(0);

   129             if (item->ownedByLayout())

   130                 delete item;

   131         }

   132     }

   133 }

   134 

   135 /*!

   136     Adds \a item to the grid on \a row and \a column. You can specify a

   137     \a rowSpan and \a columnSpan and an optional \a alignment.

   138 */

   139 void QGraphicsGridLayout::addItem(QGraphicsLayoutItem *item, int row, int column,

   140                                   int rowSpan, int columnSpan, Qt::Alignment alignment)

   141 {

   142     Q_D(QGraphicsGridLayout);

   143     if (row < 0 || column < 0) {

   144         qWarning("QGraphicsGridLayout::addItem: invalid row/column: %d",

   145                  row < 0 ? row : column);

   146         return;

   147     }

   148     if (columnSpan < 1 || rowSpan < 1) {

   149         qWarning("QGraphicsGridLayout::addItem: invalid row span/column span: %d",

   150                  rowSpan < 1 ? rowSpan : columnSpan);

   151         return;

   152     }

   153     if (!item) {

   154         qWarning("QGraphicsGridLayout::addItem: cannot add null item");

   155         return;

   156     }

   157     if (item == this) {

   158         qWarning("QGraphicsGridLayout::addItem: cannot insert itself");

   159         return;

   160     }

   161 

   162     d->addChildLayoutItem(item);

   163 

   164     new QGridLayoutItem(&d->engine, item, row, column, rowSpan, columnSpan, alignment);

   165     invalidate();

   166 }

   167 

   168 /*!

   169     \fn QGraphicsGridLayout::addItem(QGraphicsLayoutItem *item, int row, int column, Qt::Alignment alignment = 0)

   170 

   171     Adds \a item to the grid on \a row and \a column. You can specify

   172     an optional \a alignment for \a item.

   173 */

   174 

   175 /*!

   176     Sets the default horizontal spacing for the grid layout to \a spacing.

   177 */

   178 void QGraphicsGridLayout::setHorizontalSpacing(qreal spacing)

   179 {

   180     Q_D(QGraphicsGridLayout);

   181     d->engine.setSpacing(spacing, Qt::Horizontal);

   182     invalidate();

   183 }

   184 

   185 /*!

   186     Returns the default horizontal spacing for the grid layout.

   187 */

   188 qreal QGraphicsGridLayout::horizontalSpacing() const

   189 {

   190     Q_D(const QGraphicsGridLayout);

   191     return d->engine.spacing(d->styleInfo(), Qt::Horizontal);

   192 }

   193 

   194 /*!

   195     Sets the default vertical spacing for the grid layout to \a spacing.

   196 */

   197 void QGraphicsGridLayout::setVerticalSpacing(qreal spacing)

   198 {

   199     Q_D(QGraphicsGridLayout);

   200     d->engine.setSpacing(spacing, Qt::Vertical);

   201     invalidate();

   202 }

   203 

   204 /*!

   205     Returns the default vertical spacing for the grid layout.

   206 */

   207 qreal QGraphicsGridLayout::verticalSpacing() const

   208 {

   209     Q_D(const QGraphicsGridLayout);

   210     return d->engine.spacing(d->styleInfo(), Qt::Vertical);

   211 }

   212 

   213 /*!

   214     Sets the grid layout's default spacing, both vertical and

   215     horizontal, to \a spacing.

   216 

   217     \sa rowSpacing(), columnSpacing()

   218 */

   219 void QGraphicsGridLayout::setSpacing(qreal spacing)

   220 {

   221     Q_D(QGraphicsGridLayout);

   222     d->engine.setSpacing(spacing, Qt::Horizontal | Qt::Vertical);

   223     invalidate();

   224 }

   225 

   226 /*!

   227     Sets the spacing for \a row to \a spacing.

   228 */

   229 void QGraphicsGridLayout::setRowSpacing(int row, qreal spacing)

   230 {

   231     Q_D(QGraphicsGridLayout);

   232     d->engine.setRowSpacing(row, spacing, Qt::Vertical);

   233     invalidate();

   234 }

   235 

   236 /*!

   237     Returns the row spacing for \a row.

   238 */

   239 qreal QGraphicsGridLayout::rowSpacing(int row) const

   240 {

   241     Q_D(const QGraphicsGridLayout);

   242     return d->engine.rowSpacing(row, Qt::Vertical);

   243 }

   244 

   245 /*!

   246     Sets the spacing for \a column to \a spacing.

   247 */

   248 void QGraphicsGridLayout::setColumnSpacing(int column, qreal spacing)

   249 {

   250     Q_D(QGraphicsGridLayout);

   251     d->engine.setRowSpacing(column, spacing, Qt::Horizontal);

   252     invalidate();

   253 }

   254 

   255 /*!

   256     Returns the column spacing for \a column.

   257 */

   258 qreal QGraphicsGridLayout::columnSpacing(int column) const

   259 {

   260     Q_D(const QGraphicsGridLayout);

   261     return d->engine.rowSpacing(column, Qt::Horizontal);

   262 }

   263 

   264 /*!

   265     Sets the stretch factor for \a row to \a stretch.

   266 */

   267 void QGraphicsGridLayout::setRowStretchFactor(int row, int stretch)

   268 {

   269     Q_D(QGraphicsGridLayout);

   270     d->engine.setRowStretchFactor(row, stretch, Qt::Vertical);

   271     invalidate();

   272 }

   273 

   274 /*!

   275     Returns the stretch factor for \a row.

   276 */

   277 int QGraphicsGridLayout::rowStretchFactor(int row) const

   278 {

   279     Q_D(const QGraphicsGridLayout);

   280     return d->engine.rowStretchFactor(row, Qt::Vertical);

   281 }

   282 

   283 /*!

   284     Sets the stretch factor for \a column to \a stretch.

   285 */

   286 void QGraphicsGridLayout::setColumnStretchFactor(int column, int stretch)

   287 {

   288     Q_D(QGraphicsGridLayout);

   289     d->engine.setRowStretchFactor(column, stretch, Qt::Horizontal);

   290     invalidate();

   291 }

   292 

   293 /*!

   294     Returns the stretch factor for \a column.

   295 */

   296 int QGraphicsGridLayout::columnStretchFactor(int column) const

   297 {

   298     Q_D(const QGraphicsGridLayout);

   299     return d->engine.rowStretchFactor(column, Qt::Horizontal);

   300 }

   301 

   302 /*!

   303     Sets the minimum height for row, \a row, to \a height.

   304 */

   305 void QGraphicsGridLayout::setRowMinimumHeight(int row, qreal height)

   306 {

   307     Q_D(QGraphicsGridLayout);

   308     d->engine.setRowSizeHint(Qt::MinimumSize, row, height, Qt::Vertical);

   309     invalidate();

   310 }

   311 

   312 /*!

   313     Returns the minimum height for row, \a row.

   314 */

   315 qreal QGraphicsGridLayout::rowMinimumHeight(int row) const

   316 {

   317     Q_D(const QGraphicsGridLayout);

   318     return d->engine.rowSizeHint(Qt::MinimumSize, row, Qt::Vertical);

   319 }

   320 

   321 /*!

   322     Sets the preferred height for row, \a row, to \a height.

   323 */

   324 void QGraphicsGridLayout::setRowPreferredHeight(int row, qreal height)

   325 {

   326     Q_D(QGraphicsGridLayout);

   327     d->engine.setRowSizeHint(Qt::PreferredSize, row, height, Qt::Vertical);

   328     invalidate();

   329 }

   330 

   331 /*!

   332     Returns the preferred height for row, \a row.

   333 */

   334 qreal QGraphicsGridLayout::rowPreferredHeight(int row) const

   335 {

   336     Q_D(const QGraphicsGridLayout);

   337     return d->engine.rowSizeHint(Qt::PreferredSize, row, Qt::Vertical);

   338 }

   339 

   340 /*!

   341     Sets the maximum height for row, \a row, to \a height.

   342 */

   343 void QGraphicsGridLayout::setRowMaximumHeight(int row, qreal height)

   344 {

   345     Q_D(QGraphicsGridLayout);

   346     d->engine.setRowSizeHint(Qt::MaximumSize, row, height, Qt::Vertical);

   347     invalidate();

   348 }

   349 

   350 /*!

   351     Returns the maximum height for row, \a row.

   352 */

   353 qreal QGraphicsGridLayout::rowMaximumHeight(int row) const

   354 {

   355     Q_D(const QGraphicsGridLayout);

   356     return d->engine.rowSizeHint(Qt::MaximumSize, row, Qt::Vertical);

   357 }

   358 

   359 /*!

   360     Sets the fixed height for row, \a row, to \a height.

   361 */

   362 void QGraphicsGridLayout::setRowFixedHeight(int row, qreal height)

   363 {

   364     Q_D(QGraphicsGridLayout);

   365     d->engine.setRowSizeHint(Qt::MinimumSize, row, height, Qt::Vertical);

   366     d->engine.setRowSizeHint(Qt::MaximumSize, row, height, Qt::Vertical);

   367     invalidate();

   368 }

   369 

   370 /*!

   371     Sets the minimum width for \a column to \a width.

   372 */

   373 void QGraphicsGridLayout::setColumnMinimumWidth(int column, qreal width)

   374 {

   375     Q_D(QGraphicsGridLayout);

   376     d->engine.setRowSizeHint(Qt::MinimumSize, column, width, Qt::Horizontal);

   377     invalidate();

   378 }

   379 

   380 /*!

   381     Returns the minimum width for \a column.

   382 */

   383 qreal QGraphicsGridLayout::columnMinimumWidth(int column) const

   384 {

   385     Q_D(const QGraphicsGridLayout);

   386     return d->engine.rowSizeHint(Qt::MinimumSize, column, Qt::Horizontal);

   387 }

   388 

   389 /*!

   390     Sets the preferred width for \a column to \a width.

   391 */

   392 void QGraphicsGridLayout::setColumnPreferredWidth(int column, qreal width)

   393 {

   394     Q_D(QGraphicsGridLayout);

   395     d->engine.setRowSizeHint(Qt::PreferredSize, column, width, Qt::Horizontal);

   396     invalidate();

   397 }

   398 

   399 /*!

   400     Returns the preferred width for \a column.

   401 */

   402 qreal QGraphicsGridLayout::columnPreferredWidth(int column) const

   403 {

   404     Q_D(const QGraphicsGridLayout);

   405     return d->engine.rowSizeHint(Qt::PreferredSize, column, Qt::Horizontal);

   406 }

   407 

   408 /*!

   409     Sets the maximum width of \a column to \a width.

   410 */

   411 void QGraphicsGridLayout::setColumnMaximumWidth(int column, qreal width)

   412 {

   413     Q_D(QGraphicsGridLayout);

   414     d->engine.setRowSizeHint(Qt::MaximumSize, column, width, Qt::Horizontal);

   415     invalidate();

   416 }

   417 

   418 /*!

   419     Returns the maximum width for \a column.

   420 */

   421 qreal QGraphicsGridLayout::columnMaximumWidth(int column) const

   422 {

   423     Q_D(const QGraphicsGridLayout);

   424     return d->engine.rowSizeHint(Qt::MaximumSize, column, Qt::Horizontal);

   425 }

   426 

   427 /*!

   428     Sets the fixed width of \a column to \a width.

   429 */

   430 void QGraphicsGridLayout::setColumnFixedWidth(int column, qreal width)

   431 {

   432     Q_D(QGraphicsGridLayout);

   433     d->engine.setRowSizeHint(Qt::MinimumSize, column, width, Qt::Horizontal);

   434     d->engine.setRowSizeHint(Qt::MaximumSize, column, width, Qt::Horizontal);

   435     invalidate();

   436 }

   437 

   438 /*!

   439     Sets the alignment of \a row to \a alignment.

   440 */

   441 void QGraphicsGridLayout::setRowAlignment(int row, Qt::Alignment alignment)

   442 {

   443     Q_D(QGraphicsGridLayout);

   444     d->engine.setRowAlignment(row, alignment, Qt::Vertical);

   445     invalidate();

   446 }

   447 

   448 /*!

   449     Returns the alignment of \a row.

   450 */

   451 Qt::Alignment QGraphicsGridLayout::rowAlignment(int row) const

   452 {

   453     Q_D(const QGraphicsGridLayout);

   454     return d->engine.rowAlignment(row, Qt::Vertical);

   455 }

   456 

   457 /*!

   458     Sets the alignment for \a column to \a alignment.

   459 */

   460 void QGraphicsGridLayout::setColumnAlignment(int column, Qt::Alignment alignment)

   461 {

   462     Q_D(QGraphicsGridLayout);

   463     d->engine.setRowAlignment(column, alignment, Qt::Horizontal);

   464     invalidate();

   465 }

   466 

   467 /*!

   468     Returns the alignment for \a column.

   469 */

   470 Qt::Alignment QGraphicsGridLayout::columnAlignment(int column) const

   471 {

   472     Q_D(const QGraphicsGridLayout);

   473     return d->engine.rowAlignment(column, Qt::Horizontal);

   474 }

   475 

   476 /*!

   477     Sets the alignment for \a item to \a alignment.

   478 */

   479 void QGraphicsGridLayout::setAlignment(QGraphicsLayoutItem *item, Qt::Alignment alignment)

   480 {

   481     Q_D(QGraphicsGridLayout);

   482     d->engine.setAlignment(item, alignment);

   483     invalidate();

   484 }

   485 

   486 /*!

   487     Returns the alignment for \a item.

   488 */

   489 Qt::Alignment QGraphicsGridLayout::alignment(QGraphicsLayoutItem *item) const

   490 {

   491     Q_D(const QGraphicsGridLayout);

   492     return d->engine.alignment(item);

   493 }

   494 

   495 /*!

   496     Returns the number of rows in the grid layout. This is always one more

   497     than the index of the last row that is occupied by a layout item (empty

   498     rows are counted except for those at the end).

   499 */

   500 int QGraphicsGridLayout::rowCount() const

   501 {

   502     Q_D(const QGraphicsGridLayout);

   503     return d->engine.effectiveLastRow(Qt::Vertical) + 1;

   504 }

   505 

   506 /*!

   507     Returns the number of columns in the grid layout. This is always one more

   508     than the index of  the last column that is occupied by a layout item (empty

   509     columns are counted except for those at the end).

   510 */

   511 int QGraphicsGridLayout::columnCount() const

   512 {

   513     Q_D(const QGraphicsGridLayout);

   514     return d->engine.effectiveLastRow(Qt::Horizontal) + 1;

   515 }

   516 

   517 /*!

   518     Returns a pointer to the layout item at (\a row, \a column).

   519 */

   520 QGraphicsLayoutItem *QGraphicsGridLayout::itemAt(int row, int column) const

   521 {

   522     Q_D(const QGraphicsGridLayout);

   523     if (row < 0 || row >= rowCount() || column < 0 || column >= columnCount()) {

   524         qWarning("QGraphicsGridLayout::itemAt: invalid row, column %d, %d", row, column);

   525         return 0;

   526     }

   527     if (QGridLayoutItem *item = d->engine.itemAt(row, column))

   528         return item->layoutItem();

   529     return 0;

   530 }

   531 

   532 /*!

   533     Returns the number of layout items in this grid layout.

   534 */

   535 int QGraphicsGridLayout::count() const

   536 {

   537     Q_D(const QGraphicsGridLayout);

   538     return d->engine.itemCount();

   539 }

   540 

   541 /*!

   542     Returns the layout item at \a index, or 0 if there is no layout item at

   543     this index.

   544 */

   545 QGraphicsLayoutItem *QGraphicsGridLayout::itemAt(int index) const

   546 {

   547     Q_D(const QGraphicsGridLayout);

   548     if (index < 0 || index >= d->engine.itemCount()) {

   549         qWarning("QGraphicsGridLayout::itemAt: invalid index %d", index);

   550         return 0;

   551     }

   552     QGraphicsLayoutItem *item = 0;

   553     if (QGridLayoutItem *gridItem = d->engine.itemAt(index))

   554         item = gridItem->layoutItem();

   555     return item;

   556 }

   557 

   558 /*!

   559     Removes the layout item at \a index without destroying it. Ownership of

   560     the item is transferred to the caller.

   561 

   562     \sa addItem()

   563 */

   564 void QGraphicsGridLayout::removeAt(int index)

   565 {

   566     Q_D(QGraphicsGridLayout);

   567     if (index < 0 || index >= d->engine.itemCount()) {

   568         qWarning("QGraphicsGridLayout::removeAt: invalid index %d", index);

   569         return;

   570     }

   571     if (QGridLayoutItem *gridItem = d->engine.itemAt(index)) {

   572         if (QGraphicsLayoutItem *layoutItem = gridItem->layoutItem())

   573             layoutItem->setParentLayoutItem(0);

   574         d->engine.removeItem(gridItem);

   575         delete gridItem;

   576         invalidate();

   577     }

   578 }

   579 

   580 /*!

   581     \reimp

   582 */

   583 void QGraphicsGridLayout::invalidate()

   584 {

   585     Q_D(QGraphicsGridLayout);

   586     d->engine.invalidate();

   587     QGraphicsLayout::invalidate();

   588 }

   589 

   590 #ifdef QT_DEBUG

   591 void QGraphicsGridLayoutPrivate::dump(int indent) const

   592 {

   593     if (qt_graphicsLayoutDebug()) {

   594         engine.dump(indent + 1);

   595     }

   596 }

   597 #endif

   598 

   599 /*!

   600     Sets the bounding geometry of the grid layout to \a rect.

   601 */

   602 void QGraphicsGridLayout::setGeometry(const QRectF &rect)

   603 {

   604     Q_D(QGraphicsGridLayout);

   605     QGraphicsLayout::setGeometry(rect);

   606     QRectF effectiveRect = geometry();

   607     qreal left, top, right, bottom;

   608     getContentsMargins(&left, &top, &right, &bottom);

   609     Qt::LayoutDirection visualDir = d->visualDirection();

   610     d->engine.setVisualDirection(visualDir);

   611     if (visualDir == Qt::RightToLeft)

   612         qSwap(left, right);

   613     effectiveRect.adjust(+left, +top, -right, -bottom);

   614     d->engine.setGeometries(d->styleInfo(), effectiveRect);

   615 #ifdef QT_DEBUG

   616     if (qt_graphicsLayoutDebug()) {

   617         static int counter = 0;

   618         qDebug("==== BEGIN DUMP OF QGraphicsGridLayout (%d)====", counter++);

   619         d->dump(1);

   620         qDebug("==== END DUMP OF QGraphicsGridLayout ====");

   621     }

   622 #endif

   623 }

   624 

   625 /*!

   626     \reimp

   627 */

   628 QSizeF QGraphicsGridLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const

   629 {

   630     Q_D(const QGraphicsGridLayout);

   631     qreal left, top, right, bottom;

   632     getContentsMargins(&left, &top, &right, &bottom);

   633     return d->engine.sizeHint(d->styleInfo(), which , constraint) + QSizeF(left + right, top + bottom);

   634 }

   635 

   636 

   637 #if 0

   638 // ### kill? (implement and kill?)

   639 QRect QGraphicsGridLayout::cellRect(int row, int column, int rowSpan, int columnSpan) const

   640 {

   641     Q_D(const QGraphicsGridLayout);

   642     return QRect();

   643 //    return d->engine.cellRect(parentLayoutable(), contentsGeometry(), row, column, rowSpan, columnSpan);

   644 }

   645 

   646 QSizePolicy::ControlTypes QGraphicsGridLayout::controlTypes(LayoutSide side) const

   647 {

   648     Q_D(const QGraphicsGridLayout);

   649     return d->engine.controlTypes(side);

   650 }

   651 #endif

   652 

   653 QT_END_NAMESPACE

   654 

   655 #endif //QT_NO_GRAPHICSVIEW