Convert tabs to 4 spaces for all source files

Removed trailing spaces and whitespace on empty lines in the process. Changed CheckTabs.py tool to disallow hard tabs in source files. Test-Information: Manually checked 30 random files that the conversion worked as expected. Change-Id: I874f99d617bd3d2bb55f02d58f22f58f9b094480
author: Tobias Markmann <tm@ayena.de> 2016-03-31 14:57:35 (GMT)
committer: Tobias Markmann <tm@ayena.de> 2016-03-31 14:57:35 (GMT)
commit: cfbdb43d2cadd40aa87338d41548e4bf89e146e6 (patch)
tree: 18d94153a302445196fc0c18586abf44a1ce4a38 /Swift/QtUI/Whiteboard
parent: 1d545a4a7fb877f021508094b88c1f17b30d8b4e (diff)
download: swift-cfbdb43d2cadd40aa87338d41548e4bf89e146e6.zip
swift-cfbdb43d2cadd40aa87338d41548e4bf89e146e6.tar.bz2
11 files changed, 1317 insertions, 1317 deletions
diff --git a/Swift/QtUI/Whiteboard/ColorWidget.cpp b/Swift/QtUI/Whiteboard/ColorWidget.cpp
index e12ade1..7669ecc 100644
--- a/Swift/QtUI/Whiteboard/ColorWidget.cpp
+++ b/Swift/QtUI/Whiteboard/ColorWidget.cpp
@@ -17,28 +17,28 @@
 #include <QPainter>
 
 namespace Swift {
-	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();
-		}
-	}
+    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();
+        }
+    }
 }
 
diff --git a/Swift/QtUI/Whiteboard/ColorWidget.h b/Swift/QtUI/Whiteboard/ColorWidget.h
index ae1af0f..18dc73f 100644
--- a/Swift/QtUI/Whiteboard/ColorWidget.h
+++ b/Swift/QtUI/Whiteboard/ColorWidget.h
@@ -9,25 +9,25 @@
 #include <QWidget>
 
 namespace Swift {
-	class ColorWidget : public QWidget {
-		Q_OBJECT
-	public:
-		ColorWidget(QWidget* parent = 0);
-		QSize sizeHint() const;
+    class ColorWidget : public QWidget {
+        Q_OBJECT
+    public:
+        ColorWidget(QWidget* parent = 0);
+        QSize sizeHint() const;
 
-	public slots:
-		void setColor(QColor color);
+    public slots:
+        void setColor(QColor color);
 
-	private:
-		QColor color;
+    private:
+        QColor color;
 
-	protected:
-		void paintEvent(QPaintEvent* /*event*/);
-		void mouseReleaseEvent(QMouseEvent* event);
+    protected:
+        void paintEvent(QPaintEvent* /*event*/);
+        void mouseReleaseEvent(QMouseEvent* event);
 
-	signals:
-		void clicked();
+    signals:
+        void clicked();
 
-	};
+    };
 }
 
diff --git a/Swift/QtUI/Whiteboard/FreehandLineItem.cpp b/Swift/QtUI/Whiteboard/FreehandLineItem.cpp
index f4808d6..4ac93b8 100644
--- a/Swift/QtUI/Whiteboard/FreehandLineItem.cpp
+++ b/Swift/QtUI/Whiteboard/FreehandLineItem.cpp
@@ -13,90 +13,90 @@
 #include <Swift/QtUI/Whiteboard/FreehandLineItem.h>
 
 namespace Swift {
-	FreehandLineItem::FreehandLineItem(QGraphicsItem* parent) : QGraphicsItem(parent) {
-	}
+    FreehandLineItem::FreehandLineItem(QGraphicsItem* parent) : QGraphicsItem(parent) {
+    }
 
-	QRectF FreehandLineItem::boundingRect() const
-	{
-		return boundRect;
-	}
+    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::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::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);
+    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);
+        points_.append(point);
 
-		prepareGeometryChange();
-		boundRect |= rect;
-	}
+        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;
-	}
+    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);
-	}
+    void FreehandLineItem::setPen(const QPen& pen)
+    {
+        pen_ = pen;
+        update(boundRect);
+    }
 
-	QPen FreehandLineItem::pen() const
-	{
-		return pen_;
-	}
+    QPen FreehandLineItem::pen() const
+    {
+        return pen_;
+    }
 
-	const QVector<QPointF>& FreehandLineItem::points() const {
-		return points_;
-	}
+    const QVector<QPointF>& FreehandLineItem::points() const {
+        return points_;
+    }
 
-	int FreehandLineItem::type() const {
-		return Type;
-	}
+    int FreehandLineItem::type() const {
+        return Type;
+    }
 }
diff --git a/Swift/QtUI/Whiteboard/FreehandLineItem.h b/Swift/QtUI/Whiteboard/FreehandLineItem.h
index db37460..a2dab34 100644
--- a/Swift/QtUI/Whiteboard/FreehandLineItem.h
+++ b/Swift/QtUI/Whiteboard/FreehandLineItem.h
@@ -18,23 +18,23 @@
 #include <QPainter>
 
 namespace Swift {
-	class FreehandLineItem : public QGraphicsItem {
-	public:
-		enum {Type = UserType + 1};
-		FreehandLineItem(QGraphicsItem* parent = 0);
-		QRectF boundingRect() const;
-		void paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/ = 0);
-		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;
+    class FreehandLineItem : public QGraphicsItem {
+    public:
+        enum {Type = UserType + 1};
+        FreehandLineItem(QGraphicsItem* parent = 0);
+        QRectF boundingRect() const;
+        void paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/ = 0);
+        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;
-	};
+    private:
+        QPen pen_;
+        QVector<QPointF> points_;
+        QRectF boundRect;
+    };
 }
diff --git a/Swift/QtUI/Whiteboard/GView.cpp b/Swift/QtUI/Whiteboard/GView.cpp
index 9134d58..4deaaf6 100644
--- a/Swift/QtUI/Whiteboard/GView.cpp
+++ b/Swift/QtUI/Whiteboard/GView.cpp
@@ -15,489 +15,489 @@
 #include <Swift/QtUI/QtSwiftUtil.h>
 
 namespace Swift {
-	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(NULL), selectionRect(NULL), textDialog(NULL) {
-	}
-
-	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 = 0;
-		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 = 0;
-		selectionRect = 0;
-		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 != 0) {
-				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 != 0) {
-				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 != 0) {
-				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 != 0) {
-				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 == 0) {
-				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 = NULL;
-		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 != 0)	{
-			pen = defaultPen;
-			brush = defaultBrush;
-			scene()->removeItem(selectionRect);
-			delete selectionRect;
-			selectionRect = 0;
-			lineWidthChanged(pen.width());
-			lineColorChanged(pen.color());
-			brushColorChanged(brush.color());
-		}
-	}
-
-	void GView::deselect(QString id) {
-		if (selectionRect != 0)	{
-			QGraphicsItem* item = getItem(id);
-			if (item && selectionRect->data(1).value<QGraphicsItem*>() == item) {
-				pen = defaultPen;
-				brush = defaultBrush;
-				scene()->removeItem(selectionRect);
-				delete selectionRect;
-				selectionRect = 0;
-				lineWidthChanged(pen.width());
-				lineColorChanged(pen.color());
-				brushColorChanged(brush.color());
-			}
-		}
-	}
+    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(NULL), selectionRect(NULL), textDialog(NULL) {
+    }
+
+    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 = 0;
+        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 = 0;
+        selectionRect = 0;
+        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 != 0) {
+                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 != 0) {
+                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 != 0) {
+                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 != 0) {
+                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 == 0) {
+                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 = NULL;
+        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 != 0)    {
+            pen = defaultPen;
+            brush = defaultBrush;
+            scene()->removeItem(selectionRect);
+            delete selectionRect;
+            selectionRect = 0;
+            lineWidthChanged(pen.width());
+            lineColorChanged(pen.color());
+            brushColorChanged(brush.color());
+        }
+    }
+
+    void GView::deselect(QString id) {
+        if (selectionRect != 0)    {
+            QGraphicsItem* item = getItem(id);
+            if (item && selectionRect->data(1).value<QGraphicsItem*>() == item) {
+                pen = defaultPen;
+                brush = defaultBrush;
+                scene()->removeItem(selectionRect);
+                delete selectionRect;
+                selectionRect = 0;
+                lineWidthChanged(pen.width());
+                lineColorChanged(pen.color());
+                brushColorChanged(brush.color());
+            }
+        }
+    }
 }
diff --git a/Swift/QtUI/Whiteboard/GView.h b/Swift/QtUI/Whiteboard/GView.h
index 1cf5275..396e381 100644
--- a/Swift/QtUI/Whiteboard/GView.h
+++ b/Swift/QtUI/Whiteboard/GView.h
@@ -25,60 +25,60 @@
 #include <Swift/QtUI/Whiteboard/TextDialog.h>
 
 namespace Swift {
-	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 = 0);
-		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);
+    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 = 0);
+        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);
+    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();
+    public slots:
+        void moveUpSelectedItem();
+        void moveDownSelectedItem();
 
-	private slots:
-		void handleTextItemModified(QGraphicsTextItem*);
+    private slots:
+        void handleTextItemModified(QGraphicsTextItem*);
 
-	private:
-		void changePenAndBrush(QGraphicsItem* item, QPen pen, QBrush brush);
-		void setActualPenAndBrushFromItem(QGraphicsItem* item);
-		void deselect();
+    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;
-	};
+        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;
+    };
 }
diff --git a/Swift/QtUI/Whiteboard/QtWhiteboardWindow.cpp b/Swift/QtUI/Whiteboard/QtWhiteboardWindow.cpp
index ca887d1..26887e0 100644
--- a/Swift/QtUI/Whiteboard/QtWhiteboardWindow.cpp
+++ b/Swift/QtUI/Whiteboard/QtWhiteboardWindow.cpp
@@ -32,374 +32,374 @@
 #include <Swift/QtUI/Whiteboard/WhiteboardElementDrawingVisitor.h>
 
 namespace Swift {
-	QtWhiteboardWindow::QtWhiteboardWindow(WhiteboardSession::ref whiteboardSession) : QWidget() {
+    QtWhiteboardWindow::QtWhiteboardWindow(WhiteboardSession::ref whiteboardSession) : QWidget() {
 #ifndef Q_OS_MAC
 #ifdef  Q_OS_WIN32
-	setWindowIcon(QIcon(":/logo-icon-16-win.png"));
+    setWindowIcon(QIcon(":/logo-icon-16-win.png"));
 #else
-	setWindowIcon(QIcon(":/logo-icon-16.png"));
+    setWindowIcon(QIcon(":/logo-icon-16.png"));
 #endif
 #endif
-		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 = boost::dynamic_pointer_cast<WhiteboardInsertOperation>(operation);
-		if (insertOp) {
-			WhiteboardElementDrawingVisitor visitor(graphicsView, operation->getPos(), GView::New);
-			insertOp->getElement()->accept(visitor);
-		}
-
-		WhiteboardUpdateOperation::ref updateOp = boost::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 = boost::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(), 0, "Select pen color", QColorDialog::ShowAlphaChannel);
-		if(color.isValid())
-			graphicsView->setLineColor(color);
-	}
-
-	void QtWhiteboardWindow::showBrushColorDialog()
-	{
-		QColor color = QColorDialog::getColor(graphicsView->getBrushColor(), 0, "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 != 0) {
-			QLine line = lineItem->line().toLine();
-			QColor color = lineItem->pen().color();
-			WhiteboardLineElement::ref element = boost::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 != 0) {
-			WhiteboardFreehandPathElement::ref element = boost::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 != 0) {
-			QRectF rect = rectItem->rect();
-			WhiteboardRectElement::ref element = boost::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 != 0) {
-			QPointF point = textItem->pos();
-			WhiteboardTextElement::ref element = boost::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 = boost::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 = boost::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 = boost::make_shared<WhiteboardInsertOperation>();
-			insertOp->setPos(pos);
-			insertOp->setElement(el);
-			whiteboardSession_->sendOperation(insertOp);
-		} else {
-			WhiteboardUpdateOperation::ref updateOp = boost::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 = boost::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();
-		}
-	}
+        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 = boost::dynamic_pointer_cast<WhiteboardInsertOperation>(operation);
+        if (insertOp) {
+            WhiteboardElementDrawingVisitor visitor(graphicsView, operation->getPos(), GView::New);
+            insertOp->getElement()->accept(visitor);
+        }
+
+        WhiteboardUpdateOperation::ref updateOp = boost::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 = boost::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(), 0, "Select pen color", QColorDialog::ShowAlphaChannel);
+        if(color.isValid())
+            graphicsView->setLineColor(color);
+    }
+
+    void QtWhiteboardWindow::showBrushColorDialog()
+    {
+        QColor color = QColorDialog::getColor(graphicsView->getBrushColor(), 0, "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 != 0) {
+            QLine line = lineItem->line().toLine();
+            QColor color = lineItem->pen().color();
+            WhiteboardLineElement::ref element = boost::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 != 0) {
+            WhiteboardFreehandPathElement::ref element = boost::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 != 0) {
+            QRectF rect = rectItem->rect();
+            WhiteboardRectElement::ref element = boost::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 != 0) {
+            QPointF point = textItem->pos();
+            WhiteboardTextElement::ref element = boost::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 = boost::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 = boost::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 = boost::make_shared<WhiteboardInsertOperation>();
+            insertOp->setPos(pos);
+            insertOp->setElement(el);
+            whiteboardSession_->sendOperation(insertOp);
+        } else {
+            WhiteboardUpdateOperation::ref updateOp = boost::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 = boost::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();
+        }
+    }
 }
diff --git a/Swift/QtUI/Whiteboard/QtWhiteboardWindow.h b/Swift/QtUI/Whiteboard/QtWhiteboardWindow.h
index 862ae66..3b3f74e 100644
--- a/Swift/QtUI/Whiteboard/QtWhiteboardWindow.h
+++ b/Swift/QtUI/Whiteboard/QtWhiteboardWindow.h
@@ -35,61 +35,61 @@
 #include <Swift/QtUI/Whiteboard/GView.h>
 
 namespace Swift {
-	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);
+    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 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:
+        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;
-		QWidget* widget;
-		QPushButton* moveUpButton;
-		QPushButton* moveDownButton;
-		QSpinBox* widthBox;
-		QToolButton* rubberButton;
-		QToolButton* lineButton;
-		QToolButton* rectButton;
-		QToolButton* circleButton;
-		QToolButton* handLineButton;
-		QToolButton* textButton;
-		QToolButton* polygonButton;
-		QToolButton* selectButton;
+    private:
+        QGraphicsScene* scene;
+        GView* graphicsView;
+        QVBoxLayout* layout;
+        QVBoxLayout* sidebarLayout;
+        QHBoxLayout* hLayout;
+        QGridLayout* toolboxLayout;
+        QHBoxLayout* strokeLayout;
+        QHBoxLayout* fillLayout;
+        ColorWidget* strokeColor;
+        ColorWidget* fillColor;
+        QWidget* widget;
+        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_;
-	};
+        std::string lastOpID;
+        WhiteboardSession::ref whiteboardSession_;
+    };
 }
diff --git a/Swift/QtUI/Whiteboard/TextDialog.cpp b/Swift/QtUI/Whiteboard/TextDialog.cpp
index 13d83d5..c15e7b4 100644
--- a/Swift/QtUI/Whiteboard/TextDialog.cpp
+++ b/Swift/QtUI/Whiteboard/TextDialog.cpp
@@ -13,46 +13,46 @@
 #include <Swift/QtUI/Whiteboard/TextDialog.h>
 
 namespace Swift {
-	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);
-	}
+    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);
+    }
 }
diff --git a/Swift/QtUI/Whiteboard/TextDialog.h b/Swift/QtUI/Whiteboard/TextDialog.h
index 911bd37..31bd096 100644
--- a/Swift/QtUI/Whiteboard/TextDialog.h
+++ b/Swift/QtUI/Whiteboard/TextDialog.h
@@ -23,27 +23,27 @@
 #include <QVBoxLayout>
 
 namespace Swift {
-	class TextDialog : public QDialog
-	{
-		Q_OBJECT
-	public:
-		TextDialog(QGraphicsTextItem* item, QWidget* parent = 0);
-
-	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);
-	};
+    class TextDialog : public QDialog
+    {
+        Q_OBJECT
+    public:
+        TextDialog(QGraphicsTextItem* item, QWidget* parent = 0);
+
+    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);
+    };
 }
 
diff --git a/Swift/QtUI/Whiteboard/WhiteboardElementDrawingVisitor.h b/Swift/QtUI/Whiteboard/WhiteboardElementDrawingVisitor.h
index 4d37704..719725c 100644
--- a/Swift/QtUI/Whiteboard/WhiteboardElementDrawingVisitor.h
+++ b/Swift/QtUI/Whiteboard/WhiteboardElementDrawingVisitor.h
@@ -23,172 +23,172 @@
 #include <Swift/QtUI/Whiteboard/GView.h>
 
 namespace Swift {
-	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 == 0 && 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_;
-	};
+    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 == 0 && 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_;
+    };
 }
author	Tobias Markmann <tm@ayena.de>	2016-03-31 14:57:35 (GMT)
committer	Tobias Markmann <tm@ayena.de>	2016-03-31 14:57:35 (GMT)
commit	cfbdb43d2cadd40aa87338d41548e4bf89e146e6 (patch)
tree	18d94153a302445196fc0c18586abf44a1ce4a38 /Swift/QtUI/Whiteboard
parent	1d545a4a7fb877f021508094b88c1f17b30d8b4e (diff)
download	swift-cfbdb43d2cadd40aa87338d41548e4bf89e146e6.zip swift-cfbdb43d2cadd40aa87338d41548e4bf89e146e6.tar.bz2