+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+

+#include <Swift/QtUI/Whiteboard/ColorWidget.h>

+#include <QPainter>

+ ColorWidget::ColorWidget(QWidget* parent) : QWidget(parent) {

+ setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));

+ }

+

+ QSize ColorWidget::sizeHint() const {

+ return QSize(20, 20);

+ }

+

+ void ColorWidget::setColor(QColor color) {

+ this->color = color;

+ update();

+ }

+

+ void ColorWidget::paintEvent(QPaintEvent* /*event*/) {

+ QPainter painter(this);

+ painter.fillRect(0, 0, 20, 20, color);

+ }

+

+ void ColorWidget::mouseReleaseEvent(QMouseEvent* event) {

+ if (event->button() == Qt::LeftButton) {

+ emit clicked();

+ }

+ }

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+ class ColorWidget : public QWidget {

+ Q_OBJECT

+ public:

+ ColorWidget(QWidget* parent = nullptr);

+ QSize sizeHint() const;

+ public slots:

+ void setColor(QColor color);

+ private:

+ QColor color;

+ protected:

+ void paintEvent(QPaintEvent* /*event*/);

+ void mouseReleaseEvent(QMouseEvent* event);

+ signals:

+ void clicked();

+ };

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+#include <Swift/QtUI/Whiteboard/FreehandLineItem.h>

+ FreehandLineItem::FreehandLineItem(QGraphicsItem* parent) : QGraphicsItem(parent) {

+ }

+ QRectF FreehandLineItem::boundingRect() const

+ {

+ return boundRect;

+ }

+ void FreehandLineItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)

+ {

+ painter->setPen(pen_);

+ if (points_.size() > 0) {

+ QVector<QPointF>::const_iterator it = points_.begin();

+ QPointF previous = *it;

+ ++it;

+ for (; it != points_.end(); ++it) {

+ painter->drawLine(previous, *it);

+ previous = *it;

+ }

+ }

+ }

+ void FreehandLineItem::setStartPoint(QPointF point)

+ {

+ points_.clear();

+ points_.append(point);

+ QRectF rect(point, point);

+ prepareGeometryChange();

+ boundRect = rect;

+ }

+ void FreehandLineItem::lineTo(QPointF point)

+ {

+ qreal x1, x2, y1, y2;

+ x1 = points_.last().x();

+ x2 = point.x();

+ y1 = points_.last().y();

+ y2 = point.y();

+ if (x1 > x2) {

+ qreal temp = x1;

+ x1 = x2;

+ x2 = temp;

+ }

+ if (y1 > y2) {

+ qreal temp = y1;

+ y1 = y2;

+ y2 = temp;

+ }

+ QRectF rect(x1-1, y1-1, x2+1-x1, y2+1-y1);

+ points_.append(point);

+ prepareGeometryChange();

+ boundRect |= rect;

+ }

+ bool FreehandLineItem::collidesWithPath(const QPainterPath& path, Qt::ItemSelectionMode /*mode*/) const

+ {

+ QVector<QPointF>::const_iterator it;

+ QSizeF size(1,1);

+ for (it = points_.begin(); it != points_.end(); ++it) {

+ if (path.intersects(QRectF(*it, size))) {

+ return true;

+ }

+ }

+ return false;

+ }

+ void FreehandLineItem::setPen(const QPen& pen)

+ {

+ pen_ = pen;

+ update(boundRect);

+ }

+ QPen FreehandLineItem::pen() const

+ {

+ return pen_;

+ }

+ const QVector<QPointF>& FreehandLineItem::points() const {

+ return points_;

+ }

+ int FreehandLineItem::type() const {

+ return Type;

+ }

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <iostream>

+

+ class FreehandLineItem : public QGraphicsItem {

+ public:

+ enum {Type = UserType + 1};

+ FreehandLineItem(QGraphicsItem* parent = nullptr);

+ QRectF boundingRect() const;

+ void paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/ = nullptr);

+ void setStartPoint(QPointF point);

+ void lineTo(QPointF point);

+ bool collidesWithPath(const QPainterPath& path, Qt::ItemSelectionMode /*mode*/ = Qt::IntersectsItemShape) const;

+ void setPen(const QPen& pen);

+ QPen pen() const;

+ const QVector<QPointF>& points() const;

+ int type() const;

+ private:

+ QPen pen_;

+ QVector<QPointF> points_;

+ QRectF boundRect;

+ };

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/Whiteboard/GView.h>

+

+#include <Swift/QtUI/QtSwiftUtil.h>

+ GView::GView(QGraphicsScene* scene, QWidget* parent) : QGraphicsView(scene, parent), zValue(0), mousePressed(false), brush(QColor(Qt::white)), defaultBrush(QColor(Qt::white)), mode(GView::Select), lastItem(nullptr), selectionRect(nullptr), textDialog(nullptr) {

+ }

+

+ void GView::setLineWidth(int i) {

+ pen.setWidth(i);

+ if (selectionRect) {

+ QGraphicsItem* item = selectionRect->data(1).value<QGraphicsItem*>();

+ changePenAndBrush(selectionRect->data(1).value<QGraphicsItem*>(), pen, brush);

+ lastItemChanged(item, items_.indexOf(item)+1, Update);

+ } else {

+ defaultPen.setWidth(i);

+ }

+ }

+

+ void GView::setLineColor(QColor color) {

+ pen.setColor(color);

+ if (selectionRect) {

+ QGraphicsItem* item = selectionRect->data(1).value<QGraphicsItem*>();

+ changePenAndBrush(selectionRect->data(1).value<QGraphicsItem*>(), pen, brush);

+ lastItemChanged(item, items_.indexOf(item)+1, Update);

+ } else {

+ defaultPen.setColor(color);

+ }

+ lineColorChanged(color);

+ }

+

+ QColor GView::getLineColor() {

+ return pen.color();

+ }

+

+ void GView::setBrushColor(QColor color) {

+ brush.setColor(color);

+ if (selectionRect) {

+ QGraphicsItem* item = selectionRect->data(1).value<QGraphicsItem*>();

+ changePenAndBrush(selectionRect->data(1).value<QGraphicsItem*>(), pen, brush);

+ lastItemChanged(item, items_.indexOf(item)+1, Update);

+ } else {

+ defaultBrush.setColor(color);

+ }

+ brushColorChanged(color);

+ }

+

+ QColor GView::getBrushColor() {

+ return brush.color();

+ }

+

+ void GView::setMode(Mode mode) {

+ this->mode = mode;

+ lastItem = nullptr;

+ deselect();

+ }

+

+ void GView::addItem(QGraphicsItem* item, QString id, int pos) {

+ itemsMap_.insert(id, item);

+ if (pos > items_.size()) {

+ item->setZValue(zValue++);

+ scene()->addItem(item);

+ items_.append(item);

+ } else {

+ QGraphicsItem* temp = items_.at(pos-1);

+ item->setZValue(temp->zValue());

+ scene()->addItem(item);

+ item->stackBefore(temp);

+ items_.insert(pos-1, item);

+ }

+ }

+

+ void GView::clear() {

+ scene()->clear();

+ items_.clear();

+ itemsMap_.clear();

+ lastItem = nullptr;

+ selectionRect = nullptr;

+ brush = QBrush(QColor(Qt::white));

+ defaultBrush = QBrush(QColor(Qt::white));

+ pen = QPen();

+ pen.setWidth(1);

+ defaultPen = pen;

+ lineWidthChanged(1);

+ lineColorChanged(pen.color());

+ brushColorChanged(brush.color());

+ }

+

+ QGraphicsItem* GView::getItem(QString id) {

+ return itemsMap_.value(id);

+ }

+

+ void GView::deleteItem(QString id) {

+ deselect(id);

+ QGraphicsItem* item = itemsMap_.value(id);

+ items_.removeOne(item);

+ itemsMap_.remove(id);

+ scene()->removeItem(item);

+ delete item;

+ }

+

+ QString GView::getNewID() {

+ return P2QSTRING(idGenerator.generateID());

+ }

+

+ void GView::mouseMoveEvent(QMouseEvent* event)

+ {

+ if (!mousePressed) {

+ return;

+ }

+

+ if (mode == Line) {

+ QGraphicsLineItem* item = qgraphicsitem_cast<QGraphicsLineItem*>(lastItem);

+ if(item != nullptr) {

+ QLineF line = item->line();

+ line.setP1(this->mapToScene(event->pos()));

+ item->setLine(line);

+

+ }

+ }

+ else if (mode == Rect) {

+ QGraphicsRectItem* item = qgraphicsitem_cast<QGraphicsRectItem*>(lastItem);

+ if (item != nullptr) {

+ QPointF beginPoint = item->data(0).toPointF();

+ QPointF newPoint = this->mapToScene(event->pos());

+ QRectF rect = item->rect();

+ if (beginPoint.x() <= newPoint.x() && beginPoint.y() <= newPoint.y()) {

+ rect.setTopLeft(beginPoint);

+ rect.setBottomRight(newPoint);

+ }

+ else if (beginPoint.x() > newPoint.x() && beginPoint.y() <= newPoint.y()) {

+ rect.setTopRight(beginPoint);

+ rect.setBottomLeft(newPoint);

+ }

+ else if (beginPoint.x() <= newPoint.x() && beginPoint.y() > newPoint.y()) {

+ rect.setBottomLeft(beginPoint);

+ rect.setTopRight(newPoint);

+ }

+ else if (beginPoint.x() > newPoint.x() && beginPoint.y() > newPoint.y()) {

+ rect.setBottomRight(beginPoint);

+ rect.setTopLeft(newPoint);

+ }

+ item->setRect(rect);

+ }

+ }

+ else if (mode == Circle) {

+ QGraphicsEllipseItem* item = qgraphicsitem_cast<QGraphicsEllipseItem*>(lastItem);

+ QPainterPath path;

+ QPointF beginPoint = item->data(0).toPointF();

+ QPointF newPoint = this->mapToScene(event->pos());

+ QRectF rect = item->rect();

+ if (beginPoint.x() <= newPoint.x() && beginPoint.y() <= newPoint.y()) {

+ rect.setTopLeft(beginPoint);

+ rect.setBottomRight(newPoint);

+ }

+ else if (beginPoint.x() > newPoint.x() && beginPoint.y() <= newPoint.y()) {

+ rect.setTopRight(beginPoint);

+ rect.setBottomLeft(newPoint);

+ }

+ else if (beginPoint.x() <= newPoint.x() && beginPoint.y() > newPoint.y()) {

+ rect.setBottomLeft(beginPoint);

+ rect.setTopRight(newPoint);

+ }

+ else if (beginPoint.x() > newPoint.x() && beginPoint.y() > newPoint.y()) {

+ rect.setBottomRight(beginPoint);

+ rect.setTopLeft(newPoint);

+ }

+

+ item->setRect(rect);

+ }

+ else if (mode == HandLine) {

+ FreehandLineItem* item = qgraphicsitem_cast<FreehandLineItem*>(lastItem);

+ if (item != nullptr) {

+ QPointF newPoint = this->mapToScene(event->pos());

+ item->lineTo(newPoint);

+ }

+ }

+ else if (mode == Polygon) {

+ QGraphicsPolygonItem* item = qgraphicsitem_cast<QGraphicsPolygonItem*>(lastItem);

+ QPointF newPoint = this->mapToScene(event->pos());

+ QPolygonF polygon = item->polygon();

+ polygon.erase(polygon.end()-1);

+ polygon.append(newPoint);

+ item->setPolygon(polygon);

+ }

+ else if (mode == Select) {

+ QGraphicsItem* item = selectionRect->data(1).value<QGraphicsItem*>();

+ if (item != nullptr) {

+ QPainterPath path;

+ QPointF beginPoint = selectionRect->data(0).toPointF();

+ QPointF newPoint = this->mapToScene(event->pos());

+ item->setPos(beginPoint + newPoint);

+ selectionRect->setPos(beginPoint + newPoint);

+ }

+ }

+ }

+

+ void GView::mousePressEvent(QMouseEvent *event)

+ {

+ mousePressed = true;

+ deselect();

+ if (mode == Line) {

+ QPointF point = this->mapToScene(event->pos());

+ QGraphicsItem* item = scene()->addLine(point.x(), point.y(), point.x(), point.y(), pen);

+ QString id = getNewID();

+ item->setZValue(10000000);

+ item->setData(100, id);

+ item->setData(101, items_.size());

+ lastItem = item;

+ }

+ else if (mode == Rect) {

+ QPointF point = this->mapToScene(event->pos());

+ QGraphicsRectItem* item = scene()->addRect(point.x(), point.y(), 0, 0, pen, brush);

+ QString id = getNewID();

+ item->setZValue(10000000);

+ item->setData(0, point);

+ item->setData(100, id);

+ item->setData(101, items_.size());

+ lastItem = item;

+ }

+ else if (mode == Rubber) {

+ QPointF point = this->mapToScene(event->pos());

+ int w = pen.width();

+ QRectF rect(point.x()-w, point.y()-w, w*2, w*2);

+ QList<QGraphicsItem*> list = scene()->items(rect);

+ if (!list.isEmpty())

+ {

+ QGraphicsItem* item = scene()->items(rect).first();

+ QString id = item->data(100).toString();

+ int pos = items_.indexOf(item)+1;

+ itemDeleted(id, pos);

+ deleteItem(id);

+ }

+ }

+ else if (mode == Circle) {

+ QPointF point = this->mapToScene(event->pos());

+ QGraphicsEllipseItem* item = scene()->addEllipse(point.x(), point.y(), 0, 0, pen, brush);

+ QString id = getNewID();

+ item->setZValue(10000000);

+ item->setData(0, point);

+ item->setData(100, id);

+ item->setData(101, items_.size());

+ lastItem = item;

+ }

+ else if (mode == HandLine) {

+ QPointF point = this->mapToScene(event->pos());

+ FreehandLineItem* item = new FreehandLineItem;

+ QString id = getNewID();

+ item->setPen(pen);

+ item->setStartPoint(point);

+ item->setZValue(10000000);

+ item->setData(100, id);

+ item->setData(101, items_.size());

+ scene()->addItem(item);

+ lastItem = item;

+ }

+ else if (mode == Text) {

+ QPointF point = this->mapToScene(event->pos());

+ QGraphicsTextItem* item = scene()->addText("");

+ QString id = getNewID();

+ item->setData(100, id);

+ item->setData(101, items_.size());

+ item->setDefaultTextColor(pen.color());

+ textDialog = new TextDialog(item, this);

+ connect(textDialog, SIGNAL(accepted(QGraphicsTextItem*)), this, SLOT(handleTextItemModified(QGraphicsTextItem*)));

+ textDialog->setAttribute(Qt::WA_DeleteOnClose);

+ textDialog->show();

+ item->setPos(point);

+ lastItem = item;

+ }

+ else if (mode == Polygon) {

+ QPointF point = this->mapToScene(event->pos());

+ QGraphicsPolygonItem* item = dynamic_cast<QGraphicsPolygonItem*>(lastItem);

+ if (item == nullptr) {

+ QPolygonF polygon;

+ polygon.append(point);

+ polygon.append(point);

+ item = scene()->addPolygon(polygon, pen, brush);

+ QString id = getNewID();

+ item->setZValue(10000000);

+ item->setData(100, id);

+ item->setData(101, items_.size());

+ lastItem = item;

+ }

+ else {

+ QPolygonF polygon;

+ polygon = item->polygon();

+ polygon.append(point);

+ item->setPolygon(polygon);

+ }

+ }

+ else if (mode == Select) {

+ QPointF point = this->mapToScene(event->pos());

+ int w = pen.width();

+ if (w == 0) {

+ w = 1;

+ }

+ QRectF rect(point.x()-w, point.y()-w, w*2, w*2);

+ QList<QGraphicsItem*> list = scene()->items(rect);

+ if (!list.isEmpty()) {

+ QPen pen;

+ pen.setColor(QColor(Qt::gray));

+ pen.setStyle(Qt::DashLine);

+ QGraphicsItem *item = scene()->items(rect).first();

+ selectionRect = scene()->addRect(item->boundingRect(), pen);

+ selectionRect->setZValue(1000000);

+ selectionRect->setData(0, item->pos()-point);

+ selectionRect->setPos(item->pos());

+ QVariant var(QVariant::UserType);

+ var.setValue(item);

+ selectionRect->setData(1, var);

+ setActualPenAndBrushFromItem(item);

+ }

+ }

+ }

+

+ void GView::mouseReleaseEvent(QMouseEvent* /*event*/)

+ {

+ mousePressed = false;

+ QGraphicsPolygonItem* polygon = dynamic_cast<QGraphicsPolygonItem*>(lastItem);

+ if (polygon && polygon->polygon().size() >= 3) {

+ lastItemChanged(polygon, items_.indexOf(polygon)+1, Update);

+ } else if (lastItem) {

+ zValue++;

+ lastItem->setZValue(zValue++);

+ items_.append(lastItem);

+ itemsMap_.insert(lastItem->data(100).toString(), lastItem);

+

+ lastItemChanged(lastItem, items_.size(), New);

+ } else if (selectionRect){

+ QGraphicsItem* item = selectionRect->data(1).value<QGraphicsItem*>();

+ lastItemChanged(item, items_.indexOf(item)+1, Update);

+ }

+ }

+

+

+ void GView::handleTextItemModified(QGraphicsTextItem* item) {

+ lastItemChanged(item, item->data(101).toInt(), Update);

+ }

+

+ void GView::moveUpSelectedItem()

+ {

+ if (selectionRect) {

+ QGraphicsItem* item = selectionRect->data(1).value<QGraphicsItem*>();

+ int pos = items_.indexOf(item);

+ if (pos < items_.size()-1) {

+ lastItemChanged(item, pos+1, MoveUp);

+ move(item, pos+2);

+ }

+ }

+ }

+

+ void GView::moveDownSelectedItem()

+ {

+ if (selectionRect) {

+ QGraphicsItem* item = selectionRect->data(1).value<QGraphicsItem*>();

+ int pos = items_.indexOf(item);

+ if (pos > 0) {

+ lastItemChanged(item, pos+1, MoveDown);

+ move(item, pos);

+ }

+ }

+ }

+

+ void GView::move(QGraphicsItem* item, int npos) {

+ int pos = items_.indexOf(item);

+ QGraphicsItem* itemAfter = nullptr;

+ if (npos-1 > pos) {

+ if (npos == items_.size()) {

+ item->setZValue(zValue++);

+ } else {

+ itemAfter = items_.at(npos);

+ }

+

+ items_.insert(npos, item);

+ items_.removeAt(pos);

+ } else if (npos-1 < pos) {

+ itemAfter = items_.at(npos-1);

+ items_.insert(npos-1, item);

+ items_.removeAt(pos+1);

+ }

+ if (itemAfter) {

+ item->setZValue(itemAfter->zValue());

+ item->stackBefore(itemAfter);

+ }

+ }

+

+ void GView::changePenAndBrush(QGraphicsItem* item, QPen pen, QBrush brush) {

+ QGraphicsLineItem* lineItem = qgraphicsitem_cast<QGraphicsLineItem*>(item);

+ if (lineItem) {

+ lineItem->setPen(pen);

+ }

+

+ FreehandLineItem* handLineItem = qgraphicsitem_cast<FreehandLineItem*>(item);

+ if (handLineItem) {

+ handLineItem->setPen(pen);

+ }

+

+ QGraphicsRectItem* rectItem = qgraphicsitem_cast<QGraphicsRectItem*>(item);

+ if (rectItem) {

+ rectItem->setPen(pen);

+ rectItem->setBrush(brush);

+ }

+

+ QGraphicsTextItem* textItem = qgraphicsitem_cast<QGraphicsTextItem*>(item);

+ if (textItem) {

+ textItem->setDefaultTextColor(pen.color());

+ }

+

+ QGraphicsPolygonItem* polygonItem = qgraphicsitem_cast<QGraphicsPolygonItem*>(item);

+ if (polygonItem) {

+ polygonItem->setPen(pen);

+ polygonItem->setBrush(brush);

+ }

+

+ QGraphicsEllipseItem* ellipseItem = qgraphicsitem_cast<QGraphicsEllipseItem*>(item);

+ if (ellipseItem) {

+ ellipseItem->setPen(pen);

+ ellipseItem->setBrush(brush);

+ }

+ lineColorChanged(pen.color());

+ brushColorChanged(brush.color());

+ }

+

+ void GView::setActualPenAndBrushFromItem(QGraphicsItem* item) {

+ QGraphicsLineItem* lineItem = qgraphicsitem_cast<QGraphicsLineItem*>(item);

+ if (lineItem) {

+ pen = lineItem->pen();

+ }

+

+ FreehandLineItem* handLineItem = qgraphicsitem_cast<FreehandLineItem*>(item);

+ if (handLineItem) {

+ pen = handLineItem->pen();

+ }

+

+ QGraphicsRectItem* rectItem = qgraphicsitem_cast<QGraphicsRectItem*>(item);

+ if (rectItem) {

+ pen = rectItem->pen();

+ brush = rectItem->brush();

+ }

+

+ QGraphicsTextItem* textItem = qgraphicsitem_cast<QGraphicsTextItem*>(item);

+ if (textItem) {

+ pen.setColor(textItem->defaultTextColor());

+ }

+

+ QGraphicsPolygonItem* polygonItem = qgraphicsitem_cast<QGraphicsPolygonItem*>(item);

+ if (polygonItem) {

+ pen = polygonItem->pen();

+ brush = polygonItem->brush();

+ }

+

+ QGraphicsEllipseItem* ellipseItem = qgraphicsitem_cast<QGraphicsEllipseItem*>(item);

+ if (ellipseItem) {

+ pen = ellipseItem->pen();

+ brush = ellipseItem->brush();

+ }

+ lineWidthChanged(pen.width());

+ lineColorChanged(pen.color());

+ brushColorChanged(brush.color());

+ }

+

+ void GView::deselect() {

+ if (selectionRect != nullptr) {

+ pen = defaultPen;

+ brush = defaultBrush;

+ scene()->removeItem(selectionRect);

+ delete selectionRect;

+ selectionRect = nullptr;

+ lineWidthChanged(pen.width());

+ lineColorChanged(pen.color());

+ brushColorChanged(brush.color());

+ }

+ }

+

+ void GView::deselect(QString id) {

+ if (selectionRect != nullptr) {

+ QGraphicsItem* item = getItem(id);

+ if (item && selectionRect->data(1).value<QGraphicsItem*>() == item) {

+ pen = defaultPen;

+ brush = defaultBrush;

+ scene()->removeItem(selectionRect);

+ delete selectionRect;

+ selectionRect = nullptr;

+ lineWidthChanged(pen.width());

+ lineColorChanged(pen.color());

+ brushColorChanged(brush.color());

+ }

+ }

+ }

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <iostream>

+

+#include <QGraphicsView>

+

+#include <Swift/QtUI/Whiteboard/FreehandLineItem.h>

+#include <Swift/QtUI/Whiteboard/TextDialog.h>

+ class GView : public QGraphicsView {

+ Q_OBJECT

+ public:

+ enum Mode { Rubber, Line, Rect, Circle, HandLine, Text, Polygon, Select };

+ enum Type { New, Update, MoveUp, MoveDown };

+ GView(QGraphicsScene* scene, QWidget* parent = nullptr);

+ void setLineWidth(int i);

+ void setLineColor(QColor color);

+ QColor getLineColor();

+ void setBrushColor(QColor color);

+ QColor getBrushColor();

+ void setMode(Mode mode);

+ void mouseMoveEvent(QMouseEvent* event);

+ void mousePressEvent(QMouseEvent* event);

+ void mouseReleaseEvent(QMouseEvent* /*event*/);

+ void addItem(QGraphicsItem* item, QString id, int pos);

+ void clear();

+ QGraphicsItem* getItem(QString id);

+ void deleteItem(QString id);

+ QString getNewID();

+ void move(QGraphicsItem* item, int npos);

+ void deselect(QString id);

+ signals:

+ void lastItemChanged(QGraphicsItem* item, int pos, GView::Type type);

+ void itemDeleted(QString id, int pos);

+ void lineWidthChanged(int i);

+ void lineColorChanged(QColor color);

+ void brushColorChanged(QColor color);

+ public slots:

+ void moveUpSelectedItem();

+ void moveDownSelectedItem();

+ private slots:

+ void handleTextItemModified(QGraphicsTextItem*);

+ private:

+ void changePenAndBrush(QGraphicsItem* item, QPen pen, QBrush brush);

+ void setActualPenAndBrushFromItem(QGraphicsItem* item);

+ void deselect();

+ int zValue;

+ bool mousePressed;

+ QPen pen;

+ QBrush brush;

+ QPen defaultPen;

+ QBrush defaultBrush;

+ Mode mode;

+ QGraphicsItem* lastItem;

+ QGraphicsRectItem* selectionRect;

+ TextDialog* textDialog;

+ QMap<QString, QGraphicsItem*> itemsMap_;

+ QList<QGraphicsItem*> items_;

+ IDGenerator idGenerator;

+ };

+ * Copyright (c) 2015-2016 Isode Limited.

+#include <Swift/QtUI/Whiteboard/QtWhiteboardWindow.h>

+#include <memory>

+ QtWhiteboardWindow::QtWhiteboardWindow(WhiteboardSession::ref whiteboardSession) : QWidget() {

+ setWindowIcon(QIcon(":/logo-icon-16-win.png"));

+ setWindowIcon(QIcon(":/logo-icon-16.png"));

+ layout = new QVBoxLayout(this);

+ hLayout = new QHBoxLayout;

+ sidebarLayout = new QVBoxLayout;

+ toolboxLayout = new QGridLayout;

+

+ scene = new QGraphicsScene(this);

+ scene->setSceneRect(0, 0, 400, 400);

+

+ graphicsView = new GView(scene, this);

+ graphicsView->setMode(GView::Line);

+ connect(graphicsView, SIGNAL(lastItemChanged(QGraphicsItem*, int, GView::Type)), this, SLOT(handleLastItemChanged(QGraphicsItem*, int, GView::Type)));

+ connect(graphicsView, SIGNAL(itemDeleted(QString, int)), this, SLOT(handleItemDeleted(QString, int)));

+

+ widthBox = new QSpinBox(this);

+ connect(widthBox, SIGNAL(valueChanged(int)), this, SLOT(changeLineWidth(int)));

+ connect(graphicsView, SIGNAL(lineWidthChanged(int)), widthBox, SLOT(setValue(int)));

+ widthBox->setValue(1);

+

+ moveUpButton = new QPushButton("Move Up", this);

+ connect(moveUpButton, SIGNAL(clicked()), graphicsView, SLOT(moveUpSelectedItem()));

+

+ moveDownButton = new QPushButton("Move Down", this);

+ connect(moveDownButton, SIGNAL(clicked()), graphicsView, SLOT(moveDownSelectedItem()));

+

+ strokeLayout = new QHBoxLayout;

+ strokeColor = new ColorWidget;

+ strokeLayout->addWidget(new QLabel("Stroke:"));

+ strokeLayout->addWidget(strokeColor);

+ connect(strokeColor, SIGNAL(clicked()), this, SLOT(showColorDialog()));

+ connect(graphicsView, SIGNAL(lineColorChanged(QColor)), strokeColor, SLOT(setColor(QColor)));

+

+ fillLayout = new QHBoxLayout;

+ fillColor = new ColorWidget;

+ fillLayout->addWidget(new QLabel("Fill:"));

+ fillLayout->addWidget(fillColor);

+ connect(fillColor, SIGNAL(clicked()), this, SLOT(showBrushColorDialog()));

+ connect(graphicsView, SIGNAL(brushColorChanged(QColor)), fillColor, SLOT(setColor(QColor)));

+

+ rubberButton = new QToolButton(this);

+ rubberButton->setIcon(QIcon(":/icons/eraser.png"));

+ rubberButton->setCheckable(true);

+ rubberButton->setAutoExclusive(true);

+ connect(rubberButton, SIGNAL(clicked()), this, SLOT(setRubberMode()));

+

+ lineButton = new QToolButton(this);

+ lineButton->setIcon(QIcon(":/icons/line.png"));

+ lineButton->setCheckable(true);

+ lineButton->setAutoExclusive(true);

+ lineButton->setChecked(true);

+ connect(lineButton, SIGNAL(clicked()), this, SLOT(setLineMode()));

+

+ rectButton = new QToolButton(this);

+ rectButton->setIcon(QIcon(":/icons/rect.png"));

+ rectButton->setCheckable(true);

+ rectButton->setAutoExclusive(true);

+ connect(rectButton, SIGNAL(clicked()), this, SLOT(setRectMode()));

+

+ circleButton = new QToolButton(this);

+ circleButton->setIcon(QIcon(":/icons/circle.png"));

+ circleButton->setCheckable(true);

+ circleButton->setAutoExclusive(true);

+ connect(circleButton, SIGNAL(clicked()), this, SLOT(setCircleMode()));

+

+ handLineButton = new QToolButton(this);

+ handLineButton->setIcon(QIcon(":/icons/handline.png"));

+ handLineButton->setCheckable(true);

+ handLineButton->setAutoExclusive(true);

+ connect(handLineButton, SIGNAL(clicked()), this, SLOT(setHandLineMode()));

+

+ textButton = new QToolButton(this);

+ textButton->setIcon(QIcon(":/icons/text.png"));

+ textButton->setCheckable(true);

+ textButton->setAutoExclusive(true);

+ connect(textButton, SIGNAL(clicked()), this, SLOT(setTextMode()));

+

+ polygonButton = new QToolButton(this);

+ polygonButton->setIcon(QIcon(":/icons/polygon.png"));

+ polygonButton->setCheckable(true);

+ polygonButton->setAutoExclusive(true);

+ connect(polygonButton, SIGNAL(clicked()), this, SLOT(setPolygonMode()));

+

+ selectButton = new QToolButton(this);

+ selectButton->setIcon(QIcon(":/icons/cursor.png"));

+ selectButton->setCheckable(true);

+ selectButton->setAutoExclusive(true);

+ connect(selectButton, SIGNAL(clicked()), this, SLOT(setSelectMode()));

+

+ toolboxLayout->addWidget(rubberButton, 0, 0);

+ toolboxLayout->addWidget(selectButton, 0, 1);

+ toolboxLayout->addWidget(lineButton, 0, 2);

+ toolboxLayout->addWidget(circleButton, 1, 0);

+ toolboxLayout->addWidget(handLineButton, 1, 1);

+ toolboxLayout->addWidget(rectButton, 1, 2);

+ toolboxLayout->addWidget(textButton, 2, 0);

+ toolboxLayout->addWidget(polygonButton, 2, 1);

+

+ sidebarLayout->addLayout(toolboxLayout);

+ sidebarLayout->addSpacing(30);

+ sidebarLayout->addWidget(moveUpButton);

+ sidebarLayout->addWidget(moveDownButton);

+ sidebarLayout->addSpacing(40);

+ sidebarLayout->addWidget(widthBox);

+ sidebarLayout->addLayout(strokeLayout);

+ sidebarLayout->addLayout(fillLayout);

+ sidebarLayout->addStretch();

+ hLayout->addWidget(graphicsView);

+ hLayout->addLayout(sidebarLayout);

+ layout->addLayout(hLayout);

+ this->setLayout(layout);

+

+ setSession(whiteboardSession);

+ }

+

+ void QtWhiteboardWindow::handleWhiteboardOperationReceive(const WhiteboardOperation::ref operation) {

+ WhiteboardInsertOperation::ref insertOp = std::dynamic_pointer_cast<WhiteboardInsertOperation>(operation);

+ if (insertOp) {

+ WhiteboardElementDrawingVisitor visitor(graphicsView, operation->getPos(), GView::New);

+ insertOp->getElement()->accept(visitor);

+ }

+

+ WhiteboardUpdateOperation::ref updateOp = std::dynamic_pointer_cast<WhiteboardUpdateOperation>(operation);

+ if (updateOp) {

+ WhiteboardElementDrawingVisitor visitor(graphicsView, operation->getPos(), GView::Update);

+ updateOp->getElement()->accept(visitor);

+ if (updateOp->getPos() != updateOp->getNewPos()) {

+ graphicsView->move(graphicsView->getItem(P2QSTRING(updateOp->getElement()->getID())), updateOp->getNewPos());

+ }

+ }

+

+ WhiteboardDeleteOperation::ref deleteOp = std::dynamic_pointer_cast<WhiteboardDeleteOperation>(operation);

+ if (deleteOp) {

+ graphicsView->deleteItem(P2QSTRING(deleteOp->getElementID()));

+ }

+ }

+

+ void QtWhiteboardWindow::changeLineWidth(int i)

+ {

+ graphicsView->setLineWidth(i);

+ }

+

+ void QtWhiteboardWindow::showColorDialog()

+ {

+ QColor color = QColorDialog::getColor(graphicsView->getLineColor(), nullptr, "Select pen color", QColorDialog::ShowAlphaChannel);

+ if(color.isValid())

+ graphicsView->setLineColor(color);

+ }

+

+ void QtWhiteboardWindow::showBrushColorDialog()

+ {

+ QColor color = QColorDialog::getColor(graphicsView->getBrushColor(), nullptr, "Select brush color", QColorDialog::ShowAlphaChannel);

+ if(color.isValid())

+ graphicsView->setBrushColor(color);

+ }

+

+ void QtWhiteboardWindow::setRubberMode()

+ {

+ graphicsView->setMode(GView::Rubber);

+ }

+

+ void QtWhiteboardWindow::setLineMode()

+ {

+ graphicsView->setMode(GView::Line);

+ }

+

+ void QtWhiteboardWindow::setRectMode()

+ {

+ graphicsView->setMode(GView::Rect);

+ }

+

+ void QtWhiteboardWindow::setCircleMode()

+ {

+ graphicsView->setMode(GView::Circle);

+ }

+

+ void QtWhiteboardWindow::setHandLineMode()

+ {

+ graphicsView->setMode(GView::HandLine);

+ }

+

+ void QtWhiteboardWindow::setTextMode()

+ {

+ graphicsView->setMode(GView::Text);

+ }

+

+ void QtWhiteboardWindow::setPolygonMode()

+ {

+ graphicsView->setMode(GView::Polygon);

+ }

+

+ void QtWhiteboardWindow::setSelectMode()

+ {

+ graphicsView->setMode(GView::Select);

+ }

+

+ void QtWhiteboardWindow::show()

+ {

+ QWidget::show();

+ }

+

+ void QtWhiteboardWindow::setSession(WhiteboardSession::ref session) {

+ graphicsView->clear();

+ whiteboardSession_ = session;

+ whiteboardSession_->onOperationReceived.connect(boost::bind(&QtWhiteboardWindow::handleWhiteboardOperationReceive, this, _1));

+ whiteboardSession_->onRequestAccepted.connect(boost::bind(&QWidget::show, this));

+ whiteboardSession_->onSessionTerminated.connect(boost::bind(&QtWhiteboardWindow::handleSessionTerminate, this));

+ }

+

+ void QtWhiteboardWindow::activateWindow() {

+ QWidget::activateWindow();

+ }

+

+ void QtWhiteboardWindow::setName(const std::string& name) {

+ setWindowTitle(P2QSTRING(name));

+ }

+

+ void QtWhiteboardWindow::handleLastItemChanged(QGraphicsItem* item, int pos, GView::Type type) {

+ WhiteboardElement::ref el;

+ QGraphicsLineItem* lineItem = qgraphicsitem_cast<QGraphicsLineItem*>(item);

+ if (lineItem != nullptr) {

+ QLine line = lineItem->line().toLine();

+ QColor color = lineItem->pen().color();

+ WhiteboardLineElement::ref element = std::make_shared<WhiteboardLineElement>(line.x1()+lineItem->pos().x(), line.y1()+lineItem->pos().y(), line.x2()+lineItem->pos().x(), line.y2()+lineItem->pos().y());

+ element->setColor(WhiteboardColor(color.red(), color.green(), color.blue(), color.alpha()));

+ element->setPenWidth(lineItem->pen().width());

+

+ element->setID(lineItem->data(100).toString().toStdString());

+ el = element;

+ }

+

+ FreehandLineItem* freehandLineItem = qgraphicsitem_cast<FreehandLineItem*>(item);

+ if (freehandLineItem != nullptr) {

+ WhiteboardFreehandPathElement::ref element = std::make_shared<WhiteboardFreehandPathElement>();

+ QColor color = freehandLineItem->pen().color();

+ std::vector<std::pair<int, int> > points;

+ QVector<QPointF>::const_iterator it = freehandLineItem->points().constBegin();

+ for ( ; it != freehandLineItem->points().constEnd(); ++it) {

+ points.push_back(std::pair<int, int>(

+ boost::numeric_cast<int>(it->x()+item->pos().x()),

+ boost::numeric_cast<int>(it->y()+item->pos().y())));

+ }

+

+ element->setColor(WhiteboardColor(color.red(), color.green(), color.blue(), color.alpha()));

+ element->setPenWidth(freehandLineItem->pen().width());

+ element->setPoints(points);

+

+ element->setID(freehandLineItem->data(100).toString().toStdString());

+ el = element;

+ }

+

+ QGraphicsRectItem* rectItem = qgraphicsitem_cast<QGraphicsRectItem*>(item);

+ if (rectItem != nullptr) {

+ QRectF rect = rectItem->rect();

+ WhiteboardRectElement::ref element = std::make_shared<WhiteboardRectElement>(rect.x()+item->pos().x(), rect.y()+item->pos().y(), rect.width(), rect.height());

+ QColor penColor = rectItem->pen().color();

+ QColor brushColor = rectItem->brush().color();

+

+ element->setBrushColor(WhiteboardColor(brushColor.red(), brushColor.green(), brushColor.blue(), brushColor.alpha()));

+ element->setPenColor(WhiteboardColor(penColor.red(), penColor.green(), penColor.blue(), penColor.alpha()));

+ element->setPenWidth(rectItem->pen().width());

+

+ element->setID(rectItem->data(100).toString().toStdString());

+ el = element;

+ }

+

+ QGraphicsTextItem* textItem = qgraphicsitem_cast<QGraphicsTextItem*>(item);

+ if (textItem != nullptr) {

+ QPointF point = textItem->pos();

+ WhiteboardTextElement::ref element = std::make_shared<WhiteboardTextElement>(point.x(), point.y());

+ element->setText(textItem->toPlainText().toStdString());

+ element->setSize(textItem->font().pointSize());

+ QColor color = textItem->defaultTextColor();

+ element->setColor(WhiteboardColor(color.red(), color.green(), color.blue(), color.alpha()));

+

+ element->setID(textItem->data(100).toString().toStdString());

+ el = element;

+ }

+

+ QGraphicsPolygonItem* polygonItem = qgraphicsitem_cast<QGraphicsPolygonItem*>(item);

+ if (polygonItem) {

+ WhiteboardPolygonElement::ref element = std::make_shared<WhiteboardPolygonElement>();

+ QPolygonF polygon = polygonItem->polygon();

+ std::vector<std::pair<int, int> > points;

+ QVector<QPointF>::const_iterator it = polygon.begin();

+ for (; it != polygon.end(); ++it) {

+ points.push_back(std::pair<int, int>(

+ boost::numeric_cast<int>(it->x()+item->pos().x()),

+ boost::numeric_cast<int>(it->y()+item->pos().y())));

+ }

+

+ element->setPoints(points);

+

+ QColor penColor = polygonItem->pen().color();

+ QColor brushColor = polygonItem->brush().color();

+ element->setPenColor(WhiteboardColor(penColor.red(), penColor.green(), penColor.blue(), penColor.alpha()));

+ element->setBrushColor(WhiteboardColor(brushColor.red(), brushColor.green(), brushColor.blue(), brushColor.alpha()));

+ element->setPenWidth(polygonItem->pen().width());

+

+ element->setID(polygonItem->data(100).toString().toStdString());

+ el = element;

+ }

+

+ QGraphicsEllipseItem* ellipseItem = qgraphicsitem_cast<QGraphicsEllipseItem*>(item);

+ if (ellipseItem) {

+ QRectF rect = ellipseItem->rect();

+ int cx = boost::numeric_cast<int>(rect.x()+rect.width()/2 + item->pos().x());

+ int cy = boost::numeric_cast<int>(rect.y()+rect.height()/2 + item->pos().y());

+ int rx = boost::numeric_cast<int>(rect.width()/2);

+ int ry = boost::numeric_cast<int>(rect.height()/2);

+ WhiteboardEllipseElement::ref element = std::make_shared<WhiteboardEllipseElement>(cx, cy, rx, ry);

+

+ QColor penColor = ellipseItem->pen().color();

+ QColor brushColor = ellipseItem->brush().color();

+ element->setPenColor(WhiteboardColor(penColor.red(), penColor.green(), penColor.blue(), penColor.alpha()));

+ element->setBrushColor(WhiteboardColor(brushColor.red(), brushColor.green(), brushColor.blue(), brushColor.alpha()));

+ element->setPenWidth(ellipseItem->pen().width());

+

+ element->setID(ellipseItem->data(100).toString().toStdString());

+ el = element;

+ }

+

+ if (type == GView::New) {

+ WhiteboardInsertOperation::ref insertOp = std::make_shared<WhiteboardInsertOperation>();

+ insertOp->setPos(pos);

+ insertOp->setElement(el);

+ whiteboardSession_->sendOperation(insertOp);

+ } else {

+ WhiteboardUpdateOperation::ref updateOp = std::make_shared<WhiteboardUpdateOperation>();

+ updateOp->setPos(pos);

+ if (type == GView::Update) {

+ updateOp->setNewPos(pos);

+ } else if (type == GView::MoveUp) {

+ updateOp->setNewPos(pos+1);

+ } else if (type == GView::MoveDown) {

+ updateOp->setNewPos(pos-1);

+ }

+ updateOp->setElement(el);

+ whiteboardSession_->sendOperation(updateOp);

+ }

+ }

+

+ void QtWhiteboardWindow::handleItemDeleted(QString id, int pos) {

+ WhiteboardDeleteOperation::ref deleteOp = std::make_shared<WhiteboardDeleteOperation>();

+ deleteOp->setElementID(Q2PSTRING(id));

+ deleteOp->setPos(pos);

+ whiteboardSession_->sendOperation(deleteOp);

+ }

+

+ void QtWhiteboardWindow::handleSessionTerminate() {

+ hide();

+ }

+

+ void QtWhiteboardWindow::closeEvent(QCloseEvent* event) {

+ QMessageBox box(this);

+ box.setText(tr("Closing window is equivalent closing the session. Are you sure you want to do this?"));

+ box.setStandardButtons(QMessageBox::Yes | QMessageBox::No);

+ box.setIcon(QMessageBox::Question);

+ if (box.exec() == QMessageBox::Yes) {

+ whiteboardSession_->cancel();

+ } else {

+ event->ignore();

+ }

+ }

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+#pragma once

+#include <QCloseEvent>

+#include <QColorDialog>

+#include <QGraphicsView>

+#include <QHBoxLayout>

+#include <QVBoxLayout>

+#include <QWidget>

+

+#include <Swiften/Elements/Message.h>

+#include <Swiften/Elements/Whiteboard/WhiteboardElement.h>

+#include <Swiften/Whiteboard/WhiteboardSession.h>

+

+#include <Swift/Controllers/UIInterfaces/WhiteboardWindow.h>

+#include <Swift/QtUI/Whiteboard/ColorWidget.h>

+#include <Swift/QtUI/Whiteboard/GView.h>

+ class QtWhiteboardWindow : public QWidget, public WhiteboardWindow

+ {

+ Q_OBJECT

+ public:

+ QtWhiteboardWindow(WhiteboardSession::ref whiteboardSession);

+ void show();

+ void setSession(WhiteboardSession::ref session);

+ void activateWindow();

+ void setName(const std::string& name);

+ private slots:

+ void changeLineWidth(int i);

+ void showColorDialog();

+ void showBrushColorDialog();

+ void setRubberMode();

+ void setLineMode();

+ void setRectMode();

+ void setCircleMode();

+ void setHandLineMode();

+ void setTextMode();

+ void setPolygonMode();

+ void setSelectMode();

+ void handleLastItemChanged(QGraphicsItem* item, int pos, GView::Type type);

+ void handleItemDeleted(QString id, int pos);

+ private:

+ void handleSessionTerminate();

+ void handleWhiteboardOperationReceive(const WhiteboardOperation::ref operation);

+ void closeEvent(QCloseEvent* event);

+ private:

+ QGraphicsScene* scene;

+ GView* graphicsView;

+ QVBoxLayout* layout;

+ QVBoxLayout* sidebarLayout;

+ QHBoxLayout* hLayout;

+ QGridLayout* toolboxLayout;

+ QHBoxLayout* strokeLayout;

+ QHBoxLayout* fillLayout;

+ ColorWidget* strokeColor;

+ ColorWidget* fillColor;

+ QPushButton* moveUpButton;

+ QPushButton* moveDownButton;

+ QSpinBox* widthBox;

+ QToolButton* rubberButton;

+ QToolButton* lineButton;

+ QToolButton* rectButton;

+ QToolButton* circleButton;

+ QToolButton* handLineButton;

+ QToolButton* textButton;

+ QToolButton* polygonButton;

+ QToolButton* selectButton;

+ std::string lastOpID;

+ WhiteboardSession::ref whiteboardSession_;

+ };

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/Whiteboard/TextDialog.h>

+ TextDialog::TextDialog(QGraphicsTextItem* item, QWidget* parent) : QDialog(parent)

+ {

+ this->item = item;

+

+ layout = new QVBoxLayout(this);

+ hLayout = new QHBoxLayout;

+

+ editor = new QLineEdit(this);

+ connect(editor, SIGNAL(textChanged(const QString&)), this, SLOT(changeItemText(const QString&)));

+

+ fontSizeBox = new QSpinBox(this);

+ fontSizeBox->setMinimum(1);

+ connect(fontSizeBox, SIGNAL(valueChanged(int)), this, SLOT(changeItemFontSize(int)));

+ fontSizeBox->setValue(13);

+

+

+ buttonBox = new QDialogButtonBox(this);

+ buttonBox->setStandardButtons(QDialogButtonBox::Ok);

+ connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));

+

+ hLayout->addWidget(editor);

+ hLayout->addWidget(fontSizeBox);

+ layout->addLayout(hLayout);

+ layout->addWidget(buttonBox);

+ }

+

+ void TextDialog::changeItemText(const QString &text)

+ {

+ item->setPlainText(text);

+ }

+

+ void TextDialog::changeItemFontSize(int i)

+ {

+ QFont font = item->font();

+ font.setPointSize(i);

+ item->setFont(font);

+ }

+

+ void TextDialog::accept() {

+ emit accepted(item);

+ done(QDialog::Accepted);

+ }

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <iostream>

+

+#include <QHBoxLayout>

+#include <QLineEdit>

+#include <QVBoxLayout>

+ class TextDialog : public QDialog

+ {

+ Q_OBJECT

+ public:

+ TextDialog(QGraphicsTextItem* item, QWidget* parent = nullptr);

+

+ private:

+ QGraphicsTextItem* item;

+ QLineEdit* editor;

+ QDialogButtonBox* buttonBox;

+ QVBoxLayout* layout;

+ QHBoxLayout* hLayout;

+ QSpinBox* fontSizeBox;

+

+ signals:

+ void accepted(QGraphicsTextItem* item);

+

+ private slots:

+ void accept();

+ void changeItemText(const QString &text);

+ void changeItemFontSize(int i);

+ };

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swiften/Elements/Whiteboard/WhiteboardEllipseElement.h>

+#include <Swiften/Elements/Whiteboard/WhiteboardFreehandPathElement.h>

+#include <Swiften/Elements/Whiteboard/WhiteboardRectElement.h>

+

+#include <Swift/QtUI/QtSwiftUtil.h>

+ class WhiteboardElementDrawingVisitor : public WhiteboardElementVisitor {

+ public:

+ WhiteboardElementDrawingVisitor(GView* graphicsView, int pos, GView::Type type) : graphicsView_(graphicsView), pos_(pos), type_(type) {}

+

+ void visit(WhiteboardLineElement& element) {

+ QGraphicsLineItem *item;

+ if (type_ == GView::New) {

+ item = new QGraphicsLineItem(element.x1(), element.y1(), element.x2(), element.y2());

+ graphicsView_->addItem(item, P2QSTRING(element.getID()), pos_);

+ } else {

+ item = qgraphicsitem_cast<QGraphicsLineItem*>(graphicsView_->getItem(P2QSTRING(element.getID())));

+ QLineF line(element.x1(), element.y1(), element.x2(), element.y2());

+ item->setLine(line);

+ item->setPos(0,0);

+ graphicsView_->deselect(P2QSTRING(element.getID()));

+ }

+ if (item) {

+ QPen pen;

+ WhiteboardColor color = element.getColor();

+ pen.setColor(QColor(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha()));

+ pen.setWidth(element.getPenWidth());

+ item->setPen(pen);

+ QString id = P2QSTRING(element.getID());

+ item->setData(100, id);

+ }

+ }

+

+ void visit(WhiteboardFreehandPathElement& element) {

+ FreehandLineItem *item;

+ if (type_ == GView::New) {

+ item = new FreehandLineItem;

+ } else {

+ item = qgraphicsitem_cast<FreehandLineItem*>(graphicsView_->getItem(P2QSTRING(element.getID())));

+ item->setPos(0,0);

+ graphicsView_->deselect(P2QSTRING(element.getID()));

+ }

+

+ if (item) {

+ QPen pen;

+ WhiteboardColor color = element.getColor();

+ pen.setColor(QColor(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha()));

+ pen.setWidth(element.getPenWidth());

+ item->setPen(pen);

+

+ std::vector<std::pair<int, int> >::const_iterator it = element.getPoints().begin();

+ item->setStartPoint(QPointF(it->first, it->second));

+ for (++it; it != element.getPoints().end(); ++it) {

+ item->lineTo(QPointF(it->first, it->second));

+ }

+

+ QString id = P2QSTRING(element.getID());

+ item->setData(100, id);

+ }

+ if (type_ == GView::New) {

+ graphicsView_->addItem(item, P2QSTRING(element.getID()), pos_);

+ }

+ }

+

+ void visit(WhiteboardRectElement& element) {

+ QGraphicsRectItem* item;

+ if (type_ == GView::New) {

+ item = new QGraphicsRectItem(element.getX(), element.getY(), element.getWidth(), element.getHeight());

+ graphicsView_->addItem(item, P2QSTRING(element.getID()), pos_);

+ } else {

+ item = qgraphicsitem_cast<QGraphicsRectItem*>(graphicsView_->getItem(P2QSTRING(element.getID())));

+ QRectF rect(element.getX(), element.getY(), element.getWidth(), element.getHeight());

+ item->setRect(rect);

+ item->setPos(0,0);

+ graphicsView_->deselect(P2QSTRING(element.getID()));

+ }

+

+ if (item) {

+ QPen pen;

+ QBrush brush(Qt::SolidPattern);

+ WhiteboardColor penColor = element.getPenColor();

+ WhiteboardColor brushColor = element.getBrushColor();

+ pen.setColor(QColor(penColor.getRed(), penColor.getGreen(), penColor.getBlue(), penColor.getAlpha()));

+ pen.setWidth(element.getPenWidth());

+ brush.setColor(QColor(brushColor.getRed(), brushColor.getGreen(), brushColor.getBlue(), brushColor.getAlpha()));

+ item->setPen(pen);

+ item->setBrush(brush);

+ QString id = P2QSTRING(element.getID());

+ item->setData(100, id);

+ }

+ }

+

+ void visit(WhiteboardPolygonElement& element) {

+ QGraphicsPolygonItem* item = qgraphicsitem_cast<QGraphicsPolygonItem*>(graphicsView_->getItem(P2QSTRING(element.getID())));

+ if (item == nullptr && type_ == GView::New) {

+ item = new QGraphicsPolygonItem();

+ QString id = P2QSTRING(element.getID());

+ item->setData(100, id);

+ graphicsView_->addItem(item, id, pos_);

+ }

+ graphicsView_->deselect(P2QSTRING(element.getID()));

+ QPen pen;

+ QBrush brush(Qt::SolidPattern);

+ WhiteboardColor penColor = element.getPenColor();

+ WhiteboardColor brushColor = element.getBrushColor();

+ pen.setColor(QColor(penColor.getRed(), penColor.getGreen(), penColor.getBlue(), penColor.getAlpha()));

+ pen.setWidth(element.getPenWidth());

+ brush.setColor(QColor(brushColor.getRed(), brushColor.getGreen(), brushColor.getBlue(), brushColor.getAlpha()));

+ item->setPen(pen);

+ item->setBrush(brush);

+

+ item->setPos(0,0);

+ QPolygonF polygon;

+ std::vector<std::pair<int, int> >::const_iterator it = element.getPoints().begin();

+ for (; it != element.getPoints().end(); ++it) {

+ polygon.append(QPointF(it->first, it->second));

+ }

+ item->setPolygon(polygon);

+ }

+

+ void visit(WhiteboardTextElement& element) {

+ QGraphicsTextItem* item;

+ QString id = P2QSTRING(element.getID());

+ if (type_ == GView::New) {

+ item = new QGraphicsTextItem;

+ graphicsView_->addItem(item, id, pos_);

+ } else {

+ item = qgraphicsitem_cast<QGraphicsTextItem*>(graphicsView_->getItem(id));

+ graphicsView_->deselect(P2QSTRING(element.getID()));

+ }

+ if (item) {

+ item->setPlainText(P2QSTRING(element.getText()));

+ item->setPos(QPointF(element.getX(), element.getY()));

+ QFont font = item->font();

+ font.setPointSize(element.getSize());

+ item->setFont(font);

+ WhiteboardColor color = element.getColor();

+ item->setDefaultTextColor(QColor(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha()));

+ item->setData(100, id);

+ }

+ }

+

+ void visit(WhiteboardEllipseElement& element) {

+ QRectF rect;

+ QGraphicsEllipseItem* item;

+ QString id = P2QSTRING(element.getID());

+ rect.setTopLeft(QPointF(element.getCX()-element.getRX(), element.getCY()-element.getRY()));

+ rect.setBottomRight(QPointF(element.getCX()+element.getRX(), element.getCY()+element.getRY()));

+ if (type_ == GView::New) {

+ item = new QGraphicsEllipseItem(rect);

+ graphicsView_->addItem(item, id, pos_);

+ } else {

+ item = qgraphicsitem_cast<QGraphicsEllipseItem*>(graphicsView_->getItem(id));

+ item->setRect(rect);

+ item->setPos(0,0);

+ graphicsView_->deselect(P2QSTRING(element.getID()));

+ }

+ QPen pen;

+ QBrush brush(Qt::SolidPattern);

+ WhiteboardColor penColor = element.getPenColor();

+ WhiteboardColor brushColor = element.getBrushColor();

+ pen.setColor(QColor(penColor.getRed(), penColor.getGreen(), penColor.getBlue(), penColor.getAlpha()));

+ pen.setWidth(element.getPenWidth());

+ brush.setColor(QColor(brushColor.getRed(), brushColor.getGreen(), brushColor.getBlue(), brushColor.getAlpha()));

+ item->setPen(pen);

+ item->setBrush(brush);

+ item->setData(100, id);

+ }

+

+ private:

+ GView* graphicsView_;

+ int pos_;

+ GView::Type type_;

+ };