| /**************************************************************************** | |
| ** | |
| ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). | |
| ** All rights reserved. | |
| ** | |
| ** Contact: Nokia Corporation (qt-info@nokia.com) | |
| ** | |
| ** This file is part of a Qt Solutions component. | |
| ** | |
| ** You may use this file under the terms of the BSD license as follows: | |
| ** | |
| ** "Redistribution and use in source and binary forms, with or without | |
| ** modification, are permitted provided that the following conditions are | |
| ** met: | |
| ** * Redistributions of source code must retain the above copyright | |
| ** notice, this list of conditions and the following disclaimer. | |
| ** * Redistributions in binary form must reproduce the above copyright | |
| ** notice, this list of conditions and the following disclaimer in | |
| ** the documentation and/or other materials provided with the | |
| ** distribution. | |
| ** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor | |
| ** the names of its contributors may be used to endorse or promote | |
| ** products derived from this software without specific prior written | |
| ** permission. | |
| ** | |
| ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." | |
| ** | |
| ****************************************************************************/ | |
| #include "mainwindow.h" | |
| #include "qtvariantproperty.h" | |
| #include "qttreepropertybrowser.h" | |
| #include <QMatrix> | |
| #include <QMouseEvent> | |
| #include <QMenuBar> | |
| #include <QMenu> | |
| #include <QAction> | |
| #include <QDockWidget> | |
| void CanvasView::contentsMousePressEvent(QMouseEvent* event) | |
| { | |
| handleMouseClickEvent(event); | |
| } | |
| void CanvasView::contentsMouseDoubleClickEvent(QMouseEvent* event) | |
| { | |
| handleMouseClickEvent(event); | |
| } | |
| void CanvasView::handleMouseClickEvent(QMouseEvent* event) | |
| { | |
| QPoint p = inverseWorldMatrix().map(event->pos()); | |
| QtCanvasItemList l = canvas()->collisions(p); | |
| moving = 0; | |
| if (!l.isEmpty()) | |
| moving = l.first(); | |
| moving_start = p; | |
| emit itemClicked(moving); | |
| } | |
| void CanvasView::contentsMouseMoveEvent(QMouseEvent* event) | |
| { | |
| if (moving) { | |
| QPoint p = inverseWorldMatrix().map(event->pos()); | |
| moving->moveBy(p.x() - moving_start.x(), p.y() - moving_start.y()); | |
| moving_start = p; | |
| canvas()->update(); | |
| emit itemMoved(moving); | |
| } | |
| } | |
| MainWindow::MainWindow(QWidget *parent) | |
| : QMainWindow(parent) | |
| { | |
| QMenu *editMenu = menuBar()->addMenu(tr("Edit")); | |
| QMenu *newObjectMenu = editMenu->addMenu(tr("New Object")); | |
| QAction *newRectangleAction = new QAction(tr("Rectangle"), this); | |
| connect(newRectangleAction, SIGNAL(triggered(bool)), this, SLOT(newRectangle())); | |
| newObjectMenu->addAction(newRectangleAction); | |
| QAction *newLineAction = new QAction(tr("Line"), this); | |
| connect(newLineAction, SIGNAL(triggered(bool)), this, SLOT(newLine())); | |
| newObjectMenu->addAction(newLineAction); | |
| QAction *newEllipseAction = new QAction(tr("Ellipse"), this); | |
| connect(newEllipseAction, SIGNAL(triggered(bool)), this, SLOT(newEllipse())); | |
| newObjectMenu->addAction(newEllipseAction); | |
| QAction *newTextAction = new QAction(tr("Text"), this); | |
| connect(newTextAction, SIGNAL(triggered(bool)), this, SLOT(newText())); | |
| newObjectMenu->addAction(newTextAction); | |
| deleteAction = new QAction(tr("Delete Object"), this); | |
| connect(deleteAction, SIGNAL(triggered(bool)), this, SLOT(deleteObject())); | |
| editMenu->addAction(deleteAction); | |
| QAction *clearAction = new QAction(tr("Clear All"), this); | |
| connect(clearAction, SIGNAL(triggered(bool)), this, SLOT(clearAll())); | |
| editMenu->addAction(clearAction); | |
| QAction *fillAction = new QAction(tr("Fill View"), this); | |
| connect(fillAction, SIGNAL(triggered(bool)), this, SLOT(fillView())); | |
| editMenu->addAction(fillAction); | |
| variantManager = new QtVariantPropertyManager(this); | |
| connect(variantManager, SIGNAL(valueChanged(QtProperty *, const QVariant &)), | |
| this, SLOT(valueChanged(QtProperty *, const QVariant &))); | |
| QtVariantEditorFactory *variantFactory = new QtVariantEditorFactory(this); | |
| canvas = new QtCanvas(800, 600); | |
| canvasView = new CanvasView(canvas, this); | |
| setCentralWidget(canvasView); | |
| QDockWidget *dock = new QDockWidget(this); | |
| addDockWidget(Qt::RightDockWidgetArea, dock); | |
| propertyEditor = new QtTreePropertyBrowser(dock); | |
| propertyEditor->setFactoryForManager(variantManager, variantFactory); | |
| dock->setWidget(propertyEditor); | |
| currentItem = 0; | |
| connect(canvasView, SIGNAL(itemClicked(QtCanvasItem *)), | |
| this, SLOT(itemClicked(QtCanvasItem *))); | |
| connect(canvasView, SIGNAL(itemMoved(QtCanvasItem *)), | |
| this, SLOT(itemMoved(QtCanvasItem *))); | |
| fillView(); | |
| itemClicked(0); | |
| } | |
| void MainWindow::newRectangle() | |
| { | |
| QtCanvasItem *item = addRectangle(); | |
| canvas->update(); | |
| itemClicked(item); | |
| } | |
| void MainWindow::newEllipse() | |
| { | |
| QtCanvasItem *item = addEllipse(); | |
| canvas->update(); | |
| itemClicked(item); | |
| } | |
| void MainWindow::newLine() | |
| { | |
| QtCanvasItem *item = addLine(); | |
| canvas->update(); | |
| itemClicked(item); | |
| } | |
| void MainWindow::newText() | |
| { | |
| QtCanvasItem *item = addText(); | |
| canvas->update(); | |
| itemClicked(item); | |
| } | |
| void MainWindow::deleteObject() | |
| { | |
| if (!currentItem) | |
| return; | |
| delete currentItem; | |
| itemClicked(0); | |
| canvas->update(); | |
| } | |
| void MainWindow::clearAll() | |
| { | |
| QtCanvasItemList list = canvas->allItems(); | |
| qDeleteAll(list); | |
| itemClicked(0); | |
| canvas->update(); | |
| } | |
| void MainWindow::fillView() | |
| { | |
| for (int i = 0; i < 10; i++) { | |
| addRectangle(); | |
| addEllipse(); | |
| addLine(); | |
| addText(); | |
| } | |
| canvas->update(); | |
| } | |
| QtCanvasItem *MainWindow::addRectangle() | |
| { | |
| QtCanvasPolygonalItem *item = new QtCanvasRectangle(rand() % canvas->width(), | |
| rand() % canvas->height(), 50, 50, canvas); | |
| int z = rand() % 256; | |
| item->setBrush(QColor(rand() % 32 * 8, rand() % 32 * 8, rand() % 32 * 8)); | |
| item->setPen(QPen(QColor(rand() % 32*8, rand() % 32*8, rand() % 32*8), 4)); | |
| item->setZ(z); | |
| item->show(); | |
| return item; | |
| } | |
| QtCanvasItem *MainWindow::addEllipse() | |
| { | |
| QtCanvasPolygonalItem *item = new QtCanvasEllipse(50, 50, canvas); | |
| item->setBrush(QColor(rand() % 32 * 8, rand() % 32 * 8, rand() % 32 * 8)); | |
| item->move(rand() % canvas->width(), rand() % canvas->height()); | |
| item->setZ(rand() % 256); | |
| item->show(); | |
| return item; | |
| } | |
| QtCanvasItem *MainWindow::addLine() | |
| { | |
| QtCanvasLine *item = new QtCanvasLine(canvas); | |
| item->setPoints(0, 0, rand() % canvas->width() - canvas->width() / 2, | |
| rand() % canvas->height() - canvas->height() / 2); | |
| item->move(rand() % canvas->width(), rand() % canvas->height()); | |
| item->setPen(QPen(QColor(rand() % 32*8, rand() % 32*8, rand() % 32*8), 6)); | |
| item->setZ(rand() % 256); | |
| item->show(); | |
| return item; | |
| } | |
| QtCanvasItem *MainWindow::addText() | |
| { | |
| QtCanvasText *item = new QtCanvasText(canvas); | |
| item->setText(tr("Text")); | |
| item->setColor(QColor(rand() % 32*8, rand() % 32*8, rand() % 32*8)); | |
| item->move(rand() % canvas->width(), rand() % canvas->height()); | |
| item->setZ(rand() % 256); | |
| item->show(); | |
| return item; | |
| } | |
| void MainWindow::itemMoved(QtCanvasItem *item) | |
| { | |
| if (item != currentItem) | |
| return; | |
| variantManager->setValue(idToProperty[QLatin1String("xpos")], item->x()); | |
| variantManager->setValue(idToProperty[QLatin1String("ypos")], item->y()); | |
| variantManager->setValue(idToProperty[QLatin1String("zpos")], item->z()); | |
| } | |
| void MainWindow::updateExpandState() | |
| { | |
| QList<QtBrowserItem *> list = propertyEditor->topLevelItems(); | |
| QListIterator<QtBrowserItem *> it(list); | |
| while (it.hasNext()) { | |
| QtBrowserItem *item = it.next(); | |
| QtProperty *prop = item->property(); | |
| idToExpanded[propertyToId[prop]] = propertyEditor->isExpanded(item); | |
| } | |
| } | |
| void MainWindow::itemClicked(QtCanvasItem *item) | |
| { | |
| updateExpandState(); | |
| QMap<QtProperty *, QString>::ConstIterator itProp = propertyToId.constBegin(); | |
| while (itProp != propertyToId.constEnd()) { | |
| delete itProp.key(); | |
| itProp++; | |
| } | |
| propertyToId.clear(); | |
| idToProperty.clear(); | |
| currentItem = item; | |
| if (!currentItem) { | |
| deleteAction->setEnabled(false); | |
| return; | |
| } | |
| deleteAction->setEnabled(true); | |
| QtVariantProperty *property; | |
| property = variantManager->addProperty(QVariant::Double, tr("Position X")); | |
| property->setAttribute(QLatin1String("minimum"), 0); | |
| property->setAttribute(QLatin1String("maximum"), canvas->width()); | |
| property->setValue(item->x()); | |
| addProperty(property, QLatin1String("xpos")); | |
| property = variantManager->addProperty(QVariant::Double, tr("Position Y")); | |
| property->setAttribute(QLatin1String("minimum"), 0); | |
| property->setAttribute(QLatin1String("maximum"), canvas->height()); | |
| property->setValue(item->y()); | |
| addProperty(property, QLatin1String("ypos")); | |
| property = variantManager->addProperty(QVariant::Double, tr("Position Z")); | |
| property->setAttribute(QLatin1String("minimum"), 0); | |
| property->setAttribute(QLatin1String("maximum"), 256); | |
| property->setValue(item->z()); | |
| addProperty(property, QLatin1String("zpos")); | |
| if (item->rtti() == QtCanvasItem::Rtti_Rectangle) { | |
| QtCanvasRectangle *i = (QtCanvasRectangle *)item; | |
| property = variantManager->addProperty(QVariant::Color, tr("Brush Color")); | |
| property->setValue(i->brush().color()); | |
| addProperty(property, QLatin1String("brush")); | |
| property = variantManager->addProperty(QVariant::Color, tr("Pen Color")); | |
| property->setValue(i->pen().color()); | |
| addProperty(property, QLatin1String("pen")); | |
| property = variantManager->addProperty(QVariant::Size, tr("Size")); | |
| property->setValue(i->size()); | |
| addProperty(property, QLatin1String("size")); | |
| } else if (item->rtti() == QtCanvasItem::Rtti_Line) { | |
| QtCanvasLine *i = (QtCanvasLine *)item; | |
| property = variantManager->addProperty(QVariant::Color, tr("Pen Color")); | |
| property->setValue(i->pen().color()); | |
| addProperty(property, QLatin1String("pen")); | |
| property = variantManager->addProperty(QVariant::Point, tr("Vector")); | |
| property->setValue(i->endPoint()); | |
| addProperty(property, QLatin1String("endpoint")); | |
| } else if (item->rtti() == QtCanvasItem::Rtti_Ellipse) { | |
| QtCanvasEllipse *i = (QtCanvasEllipse *)item; | |
| property = variantManager->addProperty(QVariant::Color, tr("Brush Color")); | |
| property->setValue(i->brush().color()); | |
| addProperty(property, QLatin1String("brush")); | |
| property = variantManager->addProperty(QVariant::Size, tr("Size")); | |
| property->setValue(QSize(i->width(), i->height())); | |
| addProperty(property, QLatin1String("size")); | |
| } else if (item->rtti() == QtCanvasItem::Rtti_Text) { | |
| QtCanvasText *i = (QtCanvasText *)item; | |
| property = variantManager->addProperty(QVariant::Color, tr("Color")); | |
| property->setValue(i->color()); | |
| addProperty(property, QLatin1String("color")); | |
| property = variantManager->addProperty(QVariant::String, tr("Text")); | |
| property->setValue(i->text()); | |
| addProperty(property, QLatin1String("text")); | |
| property = variantManager->addProperty(QVariant::Font, tr("Font")); | |
| property->setValue(i->font()); | |
| addProperty(property, QLatin1String("font")); | |
| } | |
| } | |
| void MainWindow::addProperty(QtVariantProperty *property, const QString &id) | |
| { | |
| propertyToId[property] = id; | |
| idToProperty[id] = property; | |
| QtBrowserItem *item = propertyEditor->addProperty(property); | |
| if (idToExpanded.contains(id)) | |
| propertyEditor->setExpanded(item, idToExpanded[id]); | |
| } | |
| void MainWindow::valueChanged(QtProperty *property, const QVariant &value) | |
| { | |
| if (!propertyToId.contains(property)) | |
| return; | |
| if (!currentItem) | |
| return; | |
| QString id = propertyToId[property]; | |
| if (id == QLatin1String("xpos")) { | |
| currentItem->setX(value.toDouble()); | |
| } else if (id == QLatin1String("ypos")) { | |
| currentItem->setY(value.toDouble()); | |
| } else if (id == QLatin1String("zpos")) { | |
| currentItem->setZ(value.toDouble()); | |
| } else if (id == QLatin1String("text")) { | |
| if (currentItem->rtti() == QtCanvasItem::Rtti_Text) { | |
| QtCanvasText *i = (QtCanvasText *)currentItem; | |
| i->setText(value.value<QString>()); | |
| } | |
| } else if (id == QLatin1String("color")) { | |
| if (currentItem->rtti() == QtCanvasItem::Rtti_Text) { | |
| QtCanvasText *i = (QtCanvasText *)currentItem; | |
| i->setColor(value.value<QColor>()); | |
| } | |
| } else if (id == QLatin1String("brush")) { | |
| if (currentItem->rtti() == QtCanvasItem::Rtti_Rectangle || | |
| currentItem->rtti() == QtCanvasItem::Rtti_Ellipse) { | |
| QtCanvasPolygonalItem *i = (QtCanvasPolygonalItem *)currentItem; | |
| QBrush b = i->brush(); | |
| b.setColor(value.value<QColor>()); | |
| i->setBrush(b); | |
| } | |
| } else if (id == QLatin1String("pen")) { | |
| if (currentItem->rtti() == QtCanvasItem::Rtti_Rectangle || | |
| currentItem->rtti() == QtCanvasItem::Rtti_Line) { | |
| QtCanvasPolygonalItem *i = (QtCanvasPolygonalItem *)currentItem; | |
| QPen p = i->pen(); | |
| p.setColor(value.value<QColor>()); | |
| i->setPen(p); | |
| } | |
| } else if (id == QLatin1String("font")) { | |
| if (currentItem->rtti() == QtCanvasItem::Rtti_Text) { | |
| QtCanvasText *i = (QtCanvasText *)currentItem; | |
| i->setFont(value.value<QFont>()); | |
| } | |
| } else if (id == QLatin1String("endpoint")) { | |
| if (currentItem->rtti() == QtCanvasItem::Rtti_Line) { | |
| QtCanvasLine *i = (QtCanvasLine *)currentItem; | |
| QPoint p = value.value<QPoint>(); | |
| i->setPoints(i->startPoint().x(), i->startPoint().y(), p.x(), p.y()); | |
| } | |
| } else if (id == QLatin1String("size")) { | |
| if (currentItem->rtti() == QtCanvasItem::Rtti_Rectangle) { | |
| QtCanvasRectangle *i = (QtCanvasRectangle *)currentItem; | |
| QSize s = value.value<QSize>(); | |
| i->setSize(s.width(), s.height()); | |
| } else if (currentItem->rtti() == QtCanvasItem::Rtti_Ellipse) { | |
| QtCanvasEllipse *i = (QtCanvasEllipse *)currentItem; | |
| QSize s = value.value<QSize>(); | |
| i->setSize(s.width(), s.height()); | |
| } | |
| } | |
| canvas->update(); | |
| } | |