From c4413d62a5f83200f6860ab42e63cdcf7dc6e18b Mon Sep 17 00:00:00 2001 From: TzuTa Lin Date: Thu, 17 Sep 2015 10:37:20 +0800 Subject: [PATCH] First commit --- .gitignore | 8 + Makefile | 6 + README.md | 24 + canvas.py | 549 ++++++++++++++++ colorDialog.py | 31 + contributors.txt | 2 + icons/cancel.png | Bin 0 -> 2136 bytes icons/close.png | Bin 0 -> 3111 bytes icons/color.png | Bin 0 -> 1461 bytes icons/color_line.png | Bin 0 -> 2368 bytes icons/copy.png | Bin 0 -> 646 bytes icons/delete.png | Bin 0 -> 1486 bytes icons/done.png | Bin 0 -> 2198 bytes icons/done.svg | 400 ++++++++++++ icons/edit.png | Bin 0 -> 1092 bytes icons/expert1.png | Bin 0 -> 278 bytes icons/expert2.png | Bin 0 -> 335 bytes icons/eye.png | Bin 0 -> 1264 bytes icons/feBlend-icon.png | Bin 0 -> 8059 bytes icons/file.png | Bin 0 -> 765 bytes icons/fit-width.png | Bin 0 -> 1365 bytes icons/fit-window.png | Bin 0 -> 1102 bytes icons/fit.png | Bin 0 -> 2262 bytes icons/help.png | Bin 0 -> 1587 bytes icons/labels.png | Bin 0 -> 2381 bytes icons/labels.svg | 819 ++++++++++++++++++++++++ icons/new.png | Bin 0 -> 977 bytes icons/next.png | Bin 0 -> 30288 bytes icons/objects.png | Bin 0 -> 1103 bytes icons/open.png | Bin 0 -> 2073 bytes icons/open.svg | 577 +++++++++++++++++ icons/quit.png | Bin 0 -> 1915 bytes icons/save-as.png | Bin 0 -> 2811 bytes icons/save-as.svg | 1358 ++++++++++++++++++++++++++++++++++++++++ icons/save.png | Bin 0 -> 1187 bytes icons/save.svg | 679 ++++++++++++++++++++ icons/undo-cross.png | Bin 0 -> 2004 bytes icons/undo.png | Bin 0 -> 2018 bytes icons/zoom-in.png | Bin 0 -> 1099 bytes icons/zoom-out.png | Bin 0 -> 1074 bytes icons/zoom.png | Bin 0 -> 1139 bytes labelDialog.py | 43 ++ labelFile.py | 94 +++ labelImg.py | 984 +++++++++++++++++++++++++++++ lib.py | 63 ++ piscal_voc_writer.py | 110 ++++ resources.qrc | 31 + shape.py | 179 ++++++ toolBar.py | 32 + zoomWidget.py | 20 + 50 files changed, 6009 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 README.md create mode 100644 canvas.py create mode 100644 colorDialog.py create mode 100644 contributors.txt create mode 100644 icons/cancel.png create mode 100644 icons/close.png create mode 100644 icons/color.png create mode 100644 icons/color_line.png create mode 100644 icons/copy.png create mode 100644 icons/delete.png create mode 100644 icons/done.png create mode 100644 icons/done.svg create mode 100644 icons/edit.png create mode 100644 icons/expert1.png create mode 100644 icons/expert2.png create mode 100644 icons/eye.png create mode 100644 icons/feBlend-icon.png create mode 100644 icons/file.png create mode 100644 icons/fit-width.png create mode 100644 icons/fit-window.png create mode 100644 icons/fit.png create mode 100644 icons/help.png create mode 100644 icons/labels.png create mode 100644 icons/labels.svg create mode 100644 icons/new.png create mode 100644 icons/next.png create mode 100644 icons/objects.png create mode 100644 icons/open.png create mode 100644 icons/open.svg create mode 100644 icons/quit.png create mode 100644 icons/save-as.png create mode 100644 icons/save-as.svg create mode 100644 icons/save.png create mode 100644 icons/save.svg create mode 100644 icons/undo-cross.png create mode 100644 icons/undo.png create mode 100644 icons/zoom-in.png create mode 100644 icons/zoom-out.png create mode 100644 icons/zoom.png create mode 100644 labelDialog.py create mode 100644 labelFile.py create mode 100755 labelImg.py create mode 100644 lib.py create mode 100644 piscal_voc_writer.py create mode 100644 resources.qrc create mode 100644 shape.py create mode 100644 toolBar.py create mode 100644 zoomWidget.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..767aaf52 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ + +icons/.DS_Store + +resources.py + +*.pyc +.*.swp + diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..28aa5a63 --- /dev/null +++ b/Makefile @@ -0,0 +1,6 @@ + +all: resources.py + +%.py: %.qrc + pyrcc4 -o $@ $< + diff --git a/README.md b/README.md new file mode 100644 index 00000000..517fbafd --- /dev/null +++ b/README.md @@ -0,0 +1,24 @@ +# LabelImg + +LabelImg is a graphical image annotation tool + +It is written in Python and uses Qt for its graphical interface. + +The annotation file will be saved as a XML file. The annotation format is Piscal VOC format, and the format is the same as [ImageNet](http://www.image-net.org/) + +## Dependencies +Requires at least [Python 2.6](http://www.python.org/getit/) and has been tested with [PyQt +4.8](http://www.riverbankcomputing.co.uk/software/pyqt/intro). + +In order to build the resource and assets, you need to install python-qt4 python-qt4-dev pyqt4-dev-tools ... + +## Usage +After cloning the code, you should run `make` to generate the resource file. + +You can then start annotating by running `./labelImg.py`. For usage +instructions you can view the screencast tutorial from the `Help` menu. + +At the moment annotations are saved as a XML file. The format is Piscal VOC format, and the format is the same as [ImageNet](http://www.image-net.org/) + + + diff --git a/canvas.py b/canvas.py new file mode 100644 index 00000000..356a7083 --- /dev/null +++ b/canvas.py @@ -0,0 +1,549 @@ +from PyQt4.QtGui import * +from PyQt4.QtCore import * +#from PyQt4.QtOpenGL import * + +from shape import Shape +from lib import distance + +CURSOR_DEFAULT = Qt.ArrowCursor +CURSOR_POINT = Qt.PointingHandCursor +CURSOR_DRAW = Qt.CrossCursor +CURSOR_MOVE = Qt.ClosedHandCursor +CURSOR_GRAB = Qt.OpenHandCursor + +#class Canvas(QGLWidget): +class Canvas(QWidget): + zoomRequest = pyqtSignal(int) + scrollRequest = pyqtSignal(int, int) + newShape = pyqtSignal() + selectionChanged = pyqtSignal(bool) + shapeMoved = pyqtSignal() + drawingPolygon = pyqtSignal(bool) + + CREATE, EDIT = range(2) + + epsilon = 11.0 + + def __init__(self, *args, **kwargs): + super(Canvas, self).__init__(*args, **kwargs) + # Initialise local state. + self.mode = self.EDIT + self.shapes = [] + self.current = None + self.selectedShape=None # save the selected shape here + self.selectedShapeCopy=None + self.lineColor = QColor(0, 0, 255) + self.line = Shape(line_color=self.lineColor) + self.prevPoint = QPointF() + self.offsets = QPointF(), QPointF() + self.scale = 1.0 + self.pixmap = QPixmap() + self.visible = {} + self._hideBackround = False + self.hideBackround = False + self.hShape = None + self.hVertex = None + self._painter = QPainter() + self._cursor = CURSOR_DEFAULT + # Menus: + self.menus = (QMenu(), QMenu()) + # Set widget options. + self.setMouseTracking(True) + self.setFocusPolicy(Qt.WheelFocus) + + def enterEvent(self, ev): + self.overrideCursor(self._cursor) + + def leaveEvent(self, ev): + self.restoreCursor() + + def focusOutEvent(self, ev): + self.restoreCursor() + + def isVisible(self, shape): + return self.visible.get(shape, True) + + def drawing(self): + return self.mode == self.CREATE + + def editing(self): + return self.mode == self.EDIT + + def setEditing(self, value=True): + self.mode = self.EDIT if value else self.CREATE + if not value: # Create + self.unHighlight() + self.deSelectShape() + + def unHighlight(self): + if self.hShape: + self.hShape.highlightClear() + self.hVertex = self.hShape = None + + def selectedVertex(self): + return self.hVertex is not None + + def mouseMoveEvent(self, ev): + """Update line with last point and current coordinates.""" + pos = self.transformPos(ev.posF()) + + self.restoreCursor() + + # Polygon drawing. + if self.drawing(): + self.overrideCursor(CURSOR_DRAW) + if self.current: + color = self.lineColor + if self.outOfPixmap(pos): + # Don't allow the user to draw outside the pixmap. + # Project the point to the pixmap's edges. + pos = self.intersectionPoint(self.current[-1], pos) + elif len(self.current) > 1 and self.closeEnough(pos, self.current[0]): + # Attract line to starting point and colorise to alert the user: + pos = self.current[0] + color = self.current.line_color + self.overrideCursor(CURSOR_POINT) + self.current.highlightVertex(0, Shape.NEAR_VERTEX) + self.line[1] = pos + self.line.line_color = color + self.repaint() + self.current.highlightClear() + return + + # Polygon copy moving. + if Qt.RightButton & ev.buttons(): + if self.selectedShapeCopy and self.prevPoint: + self.overrideCursor(CURSOR_MOVE) + self.boundedMoveShape(self.selectedShapeCopy, pos) + self.repaint() + elif self.selectedShape: + self.selectedShapeCopy = self.selectedShape.copy() + self.repaint() + return + + # Polygon/Vertex moving. + if Qt.LeftButton & ev.buttons(): + if self.selectedVertex(): + self.boundedMoveVertex(pos) + self.shapeMoved.emit() + self.repaint() + elif self.selectedShape and self.prevPoint: + self.overrideCursor(CURSOR_MOVE) + self.boundedMoveShape(self.selectedShape, pos) + self.shapeMoved.emit() + self.repaint() + return + + # Just hovering over the canvas, 2 posibilities: + # - Highlight shapes + # - Highlight vertex + # Update shape/vertex fill and tooltip value accordingly. + self.setToolTip("Image") + for shape in reversed([s for s in self.shapes if self.isVisible(s)]): + # Look for a nearby vertex to highlight. If that fails, + # check if we happen to be inside a shape. + index = shape.nearestVertex(pos, self.epsilon) + if index is not None: + if self.selectedVertex(): + self.hShape.highlightClear() + self.hVertex, self.hShape = index, shape + shape.highlightVertex(index, shape.MOVE_VERTEX) + self.overrideCursor(CURSOR_POINT) + self.setToolTip("Click & drag to move point") + self.setStatusTip(self.toolTip()) + self.update() + break + elif shape.containsPoint(pos): + if self.selectedVertex(): + self.hShape.highlightClear() + self.hVertex, self.hShape = None, shape + self.setToolTip("Click & drag to move shape '%s'" % shape.label) + self.setStatusTip(self.toolTip()) + self.overrideCursor(CURSOR_GRAB) + self.update() + break + else: # Nothing found, clear highlights, reset state. + if self.hShape: + self.hShape.highlightClear() + self.update() + self.hVertex, self.hShape = None, None + + def mousePressEvent(self, ev): + pos = self.transformPos(ev.posF()) + if ev.button() == Qt.LeftButton: + if self.drawing(): + if self.current and self.current.reachMaxPoints() is False: + initPos = self.current[0] + minX = initPos.x() + minY = initPos.y() + targetPos = self.line[1] + maxX = targetPos.x() + maxY = targetPos.y() + self.current.addPoint(QPointF(maxX, minY)) + self.current.addPoint(targetPos) + self.current.addPoint(QPointF(minX, maxY)) + self.current.addPoint(initPos) + self.line[0] = self.current[-1] + if self.current.isClosed(): + self.finalise() + elif not self.outOfPixmap(pos): + self.current = Shape() + self.current.addPoint(pos) + self.line.points = [pos, pos] + self.setHiding() + self.drawingPolygon.emit(True) + self.update() + else: + self.selectShapePoint(pos) + self.prevPoint = pos + self.repaint() + elif ev.button() == Qt.RightButton and self.editing(): + self.selectShapePoint(pos) + self.prevPoint = pos + self.repaint() + + def mouseReleaseEvent(self, ev): + if ev.button() == Qt.RightButton: + menu = self.menus[bool(self.selectedShapeCopy)] + self.restoreCursor() + if not menu.exec_(self.mapToGlobal(ev.pos()))\ + and self.selectedShapeCopy: + # Cancel the move by deleting the shadow copy. + self.selectedShapeCopy = None + self.repaint() + elif ev.button() == Qt.LeftButton and self.selectedShape: + self.overrideCursor(CURSOR_GRAB) + + def endMove(self, copy=False): + assert self.selectedShape and self.selectedShapeCopy + shape = self.selectedShapeCopy + #del shape.fill_color + #del shape.line_color + if copy: + self.shapes.append(shape) + self.selectedShape.selected = False + self.selectedShape = shape + self.repaint() + else: + shape.label = self.selectedShape.label + self.deleteSelected() + self.shapes.append(shape) + self.selectedShapeCopy = None + + def hideBackroundShapes(self, value): + self.hideBackround = value + if self.selectedShape: + # Only hide other shapes if there is a current selection. + # Otherwise the user will not be able to select a shape. + self.setHiding(True) + self.repaint() + + def setHiding(self, enable=True): + self._hideBackround = self.hideBackround if enable else False + + def canCloseShape(self): + return self.drawing() and self.current and len(self.current) > 2 + + def mouseDoubleClickEvent(self, ev): + # We need at least 4 points here, since the mousePress handler + # adds an extra one before this handler is called. + if self.canCloseShape() and len(self.current) > 3: + self.current.popPoint() + self.finalise() + + def selectShape(self, shape): + self.deSelectShape() + shape.selected = True + self.selectedShape = shape + self.setHiding() + self.selectionChanged.emit(True) + self.update() + + def selectShapePoint(self, point): + """Select the first shape created which contains this point.""" + self.deSelectShape() + if self.selectedVertex(): # A vertex is marked for selection. + index, shape = self.hVertex, self.hShape + shape.highlightVertex(index, shape.MOVE_VERTEX) + return + for shape in reversed(self.shapes): + if self.isVisible(shape) and shape.containsPoint(point): + shape.selected = True + self.selectedShape = shape + self.calculateOffsets(shape, point) + self.setHiding() + self.selectionChanged.emit(True) + return + + def calculateOffsets(self, shape, point): + rect = shape.boundingRect() + x1 = rect.x() - point.x() + y1 = rect.y() - point.y() + x2 = (rect.x() + rect.width()) - point.x() + y2 = (rect.y() + rect.height()) - point.y() + self.offsets = QPointF(x1, y1), QPointF(x2, y2) + + def boundedMoveVertex(self, pos): + index, shape = self.hVertex, self.hShape + point = shape[index] + if self.outOfPixmap(pos): + pos = self.intersectionPoint(point, pos) + shape.moveVertexBy(index, pos - point) + + def boundedMoveShape(self, shape, pos): + if self.outOfPixmap(pos): + return False # No need to move + o1 = pos + self.offsets[0] + if self.outOfPixmap(o1): + pos -= QPointF(min(0, o1.x()), min(0, o1.y())) + o2 = pos + self.offsets[1] + if self.outOfPixmap(o2): + pos += QPointF(min(0, self.pixmap.width() - o2.x()), + min(0, self.pixmap.height()- o2.y())) + # The next line tracks the new position of the cursor + # relative to the shape, but also results in making it + # a bit "shaky" when nearing the border and allows it to + # go outside of the shape's area for some reason. XXX + #self.calculateOffsets(self.selectedShape, pos) + dp = pos - self.prevPoint + if dp: + shape.moveBy(dp) + self.prevPoint = pos + return True + return False + + def deSelectShape(self): + if self.selectedShape: + self.selectedShape.selected = False + self.selectedShape = None + self.setHiding(False) + self.selectionChanged.emit(False) + self.update() + + def deleteSelected(self): + if self.selectedShape: + shape = self.selectedShape + self.shapes.remove(self.selectedShape) + self.selectedShape = None + self.update() + return shape + + def copySelectedShape(self): + if self.selectedShape: + shape = self.selectedShape.copy() + self.deSelectShape() + self.shapes.append(shape) + shape.selected = True + self.selectedShape = shape + self.boundedShiftShape(shape) + return shape + + def boundedShiftShape(self, shape): + # Try to move in one direction, and if it fails in another. + # Give up if both fail. + point = shape[0] + offset = QPointF(2.0, 2.0) + self.calculateOffsets(shape, point) + self.prevPoint = point + if not self.boundedMoveShape(shape, point - offset): + self.boundedMoveShape(shape, point + offset) + + def paintEvent(self, event): + if not self.pixmap: + return super(Canvas, self).paintEvent(event) + + p = self._painter + p.begin(self) + p.setRenderHint(QPainter.Antialiasing) + p.setRenderHint(QPainter.HighQualityAntialiasing) + p.setRenderHint(QPainter.SmoothPixmapTransform) + + p.scale(self.scale, self.scale) + p.translate(self.offsetToCenter()) + + p.drawPixmap(0, 0, self.pixmap) + Shape.scale = self.scale + for shape in self.shapes: + if (shape.selected or not self._hideBackround) and self.isVisible(shape): + shape.fill = shape.selected or shape == self.hShape + shape.paint(p) + if self.current: + self.current.paint(p) + self.line.paint(p) + if self.selectedShapeCopy: + self.selectedShapeCopy.paint(p) + + # Paint rect + if self.current is not None and len(self.line) == 2: + leftTop = self.line[0] + rightBottom = self.line[1] + rectWidth = rightBottom.x() - leftTop.x() + rectHeight = rightBottom.y() - leftTop.y() + color = QColor(0, 220, 0) + p.setPen(color) + brush = QBrush(Qt.BDiagPattern) + p.setBrush(brush) + p.drawRect(leftTop.x(), leftTop.y(), rectWidth, rectHeight) + + p.end() + + def transformPos(self, point): + """Convert from widget-logical coordinates to painter-logical coordinates.""" + return point / self.scale - self.offsetToCenter() + + def offsetToCenter(self): + s = self.scale + area = super(Canvas, self).size() + w, h = self.pixmap.width() * s, self.pixmap.height() * s + aw, ah = area.width(), area.height() + x = (aw-w)/(2*s) if aw > w else 0 + y = (ah-h)/(2*s) if ah > h else 0 + return QPointF(x, y) + + def outOfPixmap(self, p): + w, h = self.pixmap.width(), self.pixmap.height() + return not (0 <= p.x() <= w and 0 <= p.y() <= h) + + def finalise(self): + assert self.current + self.current.close() + self.shapes.append(self.current) + self.current = None + self.setHiding(False) + self.newShape.emit() + self.update() + + def closeEnough(self, p1, p2): + #d = distance(p1 - p2) + #m = (p1-p2).manhattanLength() + #print "d %.2f, m %d, %.2f" % (d, m, d - m) + return distance(p1 - p2) < self.epsilon + + def intersectionPoint(self, p1, p2): + # Cycle through each image edge in clockwise fashion, + # and find the one intersecting the current line segment. + # http://paulbourke.net/geometry/lineline2d/ + size = self.pixmap.size() + points = [(0,0), + (size.width(), 0), + (size.width(), size.height()), + (0, size.height())] + x1, y1 = p1.x(), p1.y() + x2, y2 = p2.x(), p2.y() + d, i, (x, y) = min(self.intersectingEdges((x1, y1), (x2, y2), points)) + x3, y3 = points[i] + x4, y4 = points[(i+1)%4] + if (x, y) == (x1, y1): + # Handle cases where previous point is on one of the edges. + if x3 == x4: + return QPointF(x3, min(max(0, y2), max(y3, y4))) + else: # y3 == y4 + return QPointF(min(max(0, x2), max(x3, x4)), y3) + return QPointF(x, y) + + def intersectingEdges(self, (x1, y1), (x2, y2), points): + """For each edge formed by `points', yield the intersection + with the line segment `(x1,y1) - (x2,y2)`, if it exists. + Also return the distance of `(x2,y2)' to the middle of the + edge along with its index, so that the one closest can be chosen.""" + for i in xrange(4): + x3, y3 = points[i] + x4, y4 = points[(i+1) % 4] + denom = (y4-y3) * (x2 - x1) - (x4 - x3) * (y2 - y1) + nua = (x4-x3) * (y1-y3) - (y4-y3) * (x1-x3) + nub = (x2-x1) * (y1-y3) - (y2-y1) * (x1-x3) + if denom == 0: + # This covers two cases: + # nua == nub == 0: Coincident + # otherwise: Parallel + continue + ua, ub = nua / denom, nub / denom + if 0 <= ua <= 1 and 0 <= ub <= 1: + x = x1 + ua * (x2 - x1) + y = y1 + ua * (y2 - y1) + m = QPointF((x3 + x4)/2, (y3 + y4)/2) + d = distance(m - QPointF(x2, y2)) + yield d, i, (x, y) + + # These two, along with a call to adjustSize are required for the + # scroll area. + def sizeHint(self): + return self.minimumSizeHint() + + def minimumSizeHint(self): + if self.pixmap: + return self.scale * self.pixmap.size() + return super(Canvas, self).minimumSizeHint() + + def wheelEvent(self, ev): + if ev.orientation() == Qt.Vertical: + mods = ev.modifiers() + if Qt.ControlModifier == int(mods): + self.zoomRequest.emit(ev.delta()) + else: + self.scrollRequest.emit(ev.delta(), + Qt.Horizontal if (Qt.ShiftModifier == int(mods))\ + else Qt.Vertical) + else: + self.scrollRequest.emit(ev.delta(), Qt.Horizontal) + ev.accept() + + def keyPressEvent(self, ev): + key = ev.key() + if key == Qt.Key_Escape and self.current: + print 'ESC press' + self.current = None + self.drawingPolygon.emit(False) + self.update() + elif key == Qt.Key_Return and self.canCloseShape(): + self.finalise() + + def setLastLabel(self, text): + assert text + self.shapes[-1].label = text + return self.shapes[-1] + + def undoLastLine(self): + assert self.shapes + self.current = self.shapes.pop() + self.current.setOpen() + self.line.points = [self.current[-1], self.current[0]] + self.drawingPolygon.emit(True) + + def resetAllLines(self): + assert self.shapes + self.current = self.shapes.pop() + self.current.setOpen() + self.line.points = [self.current[-1], self.current[0]] + self.drawingPolygon.emit(True) + self.current = None + self.drawingPolygon.emit(False) + self.update() + + def loadPixmap(self, pixmap): + self.pixmap = pixmap + self.shapes = [] + self.repaint() + + def loadShapes(self, shapes): + self.shapes = list(shapes) + self.current = None + self.repaint() + + def setShapeVisible(self, shape, value): + self.visible[shape] = value + self.repaint() + + def overrideCursor(self, cursor): + self.restoreCursor() + self._cursor = cursor + QApplication.setOverrideCursor(cursor) + + def restoreCursor(self): + QApplication.restoreOverrideCursor() + + def resetState(self): + self.restoreCursor() + self.pixmap = None + self.update() + diff --git a/colorDialog.py b/colorDialog.py new file mode 100644 index 00000000..3e712f8a --- /dev/null +++ b/colorDialog.py @@ -0,0 +1,31 @@ +from PyQt4.QtGui import * +from PyQt4.QtCore import * + +BB = QDialogButtonBox + +class ColorDialog(QColorDialog): + def __init__(self, parent=None): + super(ColorDialog, self).__init__(parent) + self.setOption(QColorDialog.ShowAlphaChannel) + # The Mac native dialog does not support our restore button. + self.setOption(QColorDialog.DontUseNativeDialog) + ## Add a restore defaults button. + # The default is set at invocation time, so that it + # works across dialogs for different elements. + self.default = None + self.bb = self.layout().itemAt(1).widget() + self.bb.addButton(BB.RestoreDefaults) + self.bb.clicked.connect(self.checkRestore) + + def getColor(self, value=None, title=None, default=None): + self.default = default + if title: + self.setWindowTitle(title) + if value: + self.setCurrentColor(value) + return self.currentColor() if self.exec_() else None + + def checkRestore(self, button): + if self.bb.buttonRole(button) & BB.ResetRole and self.default: + self.setCurrentColor(self.default) + diff --git a/contributors.txt b/contributors.txt new file mode 100644 index 00000000..21cf64dc --- /dev/null +++ b/contributors.txt @@ -0,0 +1,2 @@ +TzuTa Lin +[LabelMe](http://labelme2.csail.mit.edu/Release3.0/index.php) diff --git a/icons/cancel.png b/icons/cancel.png new file mode 100644 index 0000000000000000000000000000000000000000..8fbfab89d036a18e8b38c2156ca2636baf78d16f GIT binary patch literal 2136 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 O0000vo-V{qaa&1Cp6lbJ7OCYcX2$xJen z%oisyW)ci)lr32HB1=)(mky;U``Xe{3SDm7yL5iff9|=tX)x1k(8LTkd2{YL_niO# zdEWPVms3dS@9(!C@+T3yL*Nd9|7QZpx4JlI&YVFnKoRh42sSPp4p(87d@m1&LpkAa zzY2vPJBuBU*a7Zo!YmXD=~;L5&b{vg3(V=$rw2hG{?B-5JQoTDmjnWV(u9OWHcqgF zgak`YPB(q}`g)Du9k5`q&k_?8Te)u)KYhe~I{+HG4H1a@Gl7lY2HcaOP&h3+JKw6S ztL*N(%dk;4bZCL4q@*}c_V)JKwQJYx?Add8@syoB+2Ct#zVv!16nH&3Ii-%Z{)Dan zz6i*zzY7KfzY2x=^Gix9Y|50WHfhpCfR|Wyb_O0!APQl;EjffeBN9RD?DX4(3zzNi z;Y0St7j@Ryc=(atUjJH%{EKzp#+u>*BYnn`10%Wroj{;(Zf>s6X3Ust3l_|=k`kZk zgWe;cLpl!l9#%AzH4v1{60Nnh-9GzlyVcaJgw#n(N=mNhhMxt4!9#<{fw&3W!@aAK z%mWn_<8A5Er8Z&081J`80y?jMBZ)x3`z~-{0hR&mynXc13ahKzD1uGE`YG#ey`4#1 z%!X^&xO(#B8TRIzzp#-beX+j_;Qt`t5%j8zDWUn^Vy#0Pk7QodeFAn_Fzx zt}pEB)mFQCv&+)blI_J8m)NXXizG!K_kBndN-*>6+Y=)IAFE4b+&u=evudeSQd_WU*sHkm&At-9kJ1)OKtDoeRkzaGbFm*vrj+0(56kB zW0d53iTYm#5Qtks<5*}}ZthTNo>2Ru;8(0zYvtvmNaQKj)YNL9eB!F0RaI43Pfy># z2l|OHQB`F>Pd4z6BUY?KYkdI8-beY5o zl6d7TJjT|nsbyiK^EwjprXqoy((UD!7ubmtCm9*eIHE_6)QcDmuNaBk(7giB+NnIB zV{6ye+PQPhM5aiUiqRv0oZ2)?A+>vy(2r?IjEBHOEHtvTbTnrvl)HnPXH?z*=_kBn zY}~jid;k44Tr)fuB@vCptFJDm+FZi3hwX(I=8~)hc-DE|^hr-oPBai1KXNS>*+d9TiGx76Ix#WHh72h*BreHNCJ#lstvp>(Q4Wa*?BkC&0J;}X zW_fa=3iT5DBqTG7Xw0{}?iwm>d$Iw1Iwd!a%C(7H=tfq>@;bm>gCn;tLh3Yo1*l9u z9HOBxR6S?{fUHD=$RSty6D8{PQR!3w^gEz?D1(|jOCxog?kOBJ0RZQC6-3~9-|((80v{kJ_8^IF&(jbXj)qGl3B2tG zWSRgAxJ>scKiqmNS8m43opkgf6$Ry$03*{=RIhrj^=c~tmTWv(%BdNH?!^7LBc`0{ z=tV(BRcTONS2dz?IL81wU9&y_)N$qUAm*0wKnN^}+$k~u)SAZmb-MySuW~Z{pZjh)udY?WuQ5YVz!xQ!-p3NynqV4fGaU26+kN|qKQozO?AEDkw+dS zni;w#XT&%uB*#gLfbS&Fx`pa|97)`N49}p;W^L>xGv>YHI`A~7;kIPSJeo}r;Co`h zJDqRXP{*6rMk-OzBN2&2A5AQS`DeaOp8ON;&s4?n3WoOKS~`SNz;IPjl7t%KiNJm~ zYd?4HE6IpWleK`iffAJxI1=#l)nVm%fr|m3!l<#G!EYzMV-IC>10X_pK9+!n+0t@_B)jMUaW2n0S(KHP+v3Gf3cP@L zrIPNO;x=8sekVO+7oP86^KM9dsS-=l_9&5cuQ#pI{L-`*Z(?(aN`WH5UMZ}VNtbS+ zv^I*gUh)sd(TSbTm*bKCGiMqFUaeo=(GibLmgeP|sB9z|k=wFm4{vCnq1|?G3rKcA zXa^m88+s0ks22&50C*vqP?e19b+yz z&!!pDC35Moty_0923!?rKsfLYP)*HlO6xYjU*|m9N0g96<0g`-RU}v=;60-wy`US( zZNc0BR@bGc3?W)K80d}&PBZI#j9I({LTvndzrU+*|Nb4S#VnqsNAS#7Y`B#M)MAiy z9d*;DF9EpS)poOJP4^n1z~as8+_TkIt*TYilZ*tO?!1wxts^>}M59nnVPx6G=&iNv zuRPxt4}sV}ux?_gTdp?W&~QMxfOm2QM(?Y(di55fBT$Es&Q{89tA2|G&pL93tY4B5 zK_Xb=DpYH0haAEAI<8;0yu9JaC!0u|puZdzlsfG1asOqmsw(>KAV9+)vyJ=4Or1KL z3G_iEa#KK*)abShPqk_kxJ5U;)zNiUz!ow;jpoJYAd%@1cm~0IqI%jkZ(fDW{2gpR z4LclDTn0y=va)jErLk0p%_MNq!w=82^72X&(+`Pukx^;YQdlf_X9LK1=Ke~p@2WPu zOBBlUu4L}mu^w5q1z7BPYz=0&gMc=hf#+7><)TTG9%qamtKJ|2X!izQ?Gdn8`P}j- zX_~n)0noWfGGEeC#R2>V^&QPT%dmGayPX8I`9wx>p#&ehbiQ-rN{1%9x4D zc!wQ|EV3mFZ_~&#K_x56-a?|DH8n^zDLxmle_(&Zf|z|@1a!>e`dp4bCqJeWfmA%K zcUbhD8GR>!s7B(5%zD&qLmCfQ_C4$q?rHJ%`MwG0x@SMa9_CsV$1;vZdJT;HBVQj& zT-AF9k2PvAi~K`huLtbg61ekU4ek)QL*NJg`43JrM3&G&ct!vK002ovPDHLkV1mGS B`U(I5 literal 0 HcmV?d00001 diff --git a/icons/color.png b/icons/color.png new file mode 100644 index 0000000000000000000000000000000000000000..1a1e1ad03b799acb31b1ace1c68c48ca0635b2ef GIT binary patch literal 1461 zcmW+$X;hO(6rB(f1AJjAivkA-AQ}bb0~8n31cV9|lqxPDnjlC-K>}!tX#Em`7;IIL zqEV>4GAMf7t=A8G=J@?K`THv-VWL*ng007y~ z*L#PW%``b_ zI(xXx)BD&aT*^TapHJd(xj0@%hLP_^VRiM1EiBehJK54*Nn`g(;pTJt^NhQZomfr} z6bJ+?nM~$DIosISi1_>aQ;B$O!(L{3nU|LrVqsx{(8*8U)Wj&D;>!f=k!o<_UA+QJ zNSKC?9zBBD+1Zg4J`Q|L>M=HtKp=QtS>AQcZ3qf!7~2AIlfNk01D!+fO-jnj#xOs> z$C$bKwQYM-P*+!1pl#U0G-4XEK}_0(Up>lrYaP zQyMltFfdI%TmU+l9H3?Cgv76~zdhRFuvG;Ky2^&|$%jH3q@7YJ;oHA{hTYd!kHET< z)2i*lP4n1+1Me^wmpexUB{(h8J_XQ98^j0&)Ek2 zi6sv6w804odv9)p3}7Go`Ds36bqJ=ghGYU{b>Ezql$Vc7^7B8g7Ki~(d(B!8+x|gE z%Nx)p>vxspN~Qvu@frNIc}b&m5;HdZf{!~}Itp9buR=ym((0akJ#K39d+iUhmoHz! z{{DVSQv^MOWJovUiN(R&waDw6n&mJhrw@*_wZTh(99)nyDS6oQ6$=mTg|s)^y@Z$dq}t+R71kvgZPu{VxLyl|?n4kmEj2O}et z-H6Vd5Qm(9Iy(#ZOWDHO6C*HdUyYI>iFyWS=uLY{_fBC`?_2sP0@p)rP{())$6i!f zDU+N(-}XZw>HoxniNvw#-d^>}@9uKV!{^kgtpQC*R_XP}23nydmsq|}Vx2ugU%6ka z3i%Kcn8!uN#>Z9v>L2%xi5bI~act9wm2|)*N8%%|*Go~8fq@%KOY@!&kBulqg@r@# zwK^JJr5n}WXxuri5Q^RKw z#HuYlUQ1hRbab?w;|iz*r;w^ouveVWU_{W}DcI^Mo0*w`B_$+Vmc$A&qu+0b=O~_mi>+kz-hDvYp=G4neM|sVR(!j`?-qznf_8I|6^@Pyp|<~sR90Y?XF%adi3(tT z20M&zbs83v9Pr4PfZRD4hoXfsMJq18V$1v zwDRzE(Fm=HV6vewbK2%l8N~L#g@qg=9sgwyP#Zp8Z<)S6`&Adk(b2;eMJKV4kk_!Z zv=kN<6~Taj03pa%X8c0d_%(#0a@=h>4ZRQXJCzs{QFgPKiTu)wmo6DNRB;ZmSBaFz zB3Z0%qU_@np0P%Fy9?UWMYu2HizeY_Y3M)H#q!K^TwAMPE9zQlzL^PUIUy=4YA+fF zG>I`jfSAVg<&u5!=xfe6}KlFLH ALjV8( literal 0 HcmV?d00001 diff --git a/icons/color_line.png b/icons/color_line.png new file mode 100644 index 0000000000000000000000000000000000000000..6ef10bfc47505002aa3d06f67a4b6a6c6434f72f GIT binary patch literal 2368 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 literal 0 HcmV?d00001 diff --git a/icons/delete.png b/icons/delete.png new file mode 100644 index 0000000000000000000000000000000000000000..a1a4074f08042ab12ef344a8d79adbd6c44fd2f8 GIT binary patch literal 1486 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 Y19C{?upJRXod5s;07*qoM6N<$f_!*AcmMzZ literal 0 HcmV?d00001 diff --git a/icons/done.svg b/icons/done.svg new file mode 100644 index 00000000..aa8fd288 --- /dev/null +++ b/icons/done.svg @@ -0,0 +1,400 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + begin='' id='W5M0MpCehiHzreSzNTczkc9d' + + + + +Adobe PDF library 5.00 + + + + + +2003-12-22T22:34:35+02:00 + +2004-04-17T21:25:50Z + +Adobe Illustrator 10.0 + +2004-01-19T17:51:02+01:00 + + + + +JPEG + +256 + +256 + +/9j/4AAQSkZJRgABAgEASABIAAD/7QAsUGhvdG9zaG9wIDMuMAA4QklNA+0AAAAAABAASAAAAAEA +AQBIAAAAAQAB/+4ADkFkb2JlAGTAAAAAAf/bAIQABgQEBAUEBgUFBgkGBQYJCwgGBggLDAoKCwoK +DBAMDAwMDAwQDA4PEA8ODBMTFBQTExwbGxscHx8fHx8fHx8fHwEHBwcNDA0YEBAYGhURFRofHx8f +Hx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8f/8AAEQgBAAEAAwER +AAIRAQMRAf/EAaIAAAAHAQEBAQEAAAAAAAAAAAQFAwIGAQAHCAkKCwEAAgIDAQEBAQEAAAAAAAAA +AQACAwQFBgcICQoLEAACAQMDAgQCBgcDBAIGAnMBAgMRBAAFIRIxQVEGE2EicYEUMpGhBxWxQiPB +UtHhMxZi8CRygvElQzRTkqKyY3PCNUQnk6OzNhdUZHTD0uIIJoMJChgZhJRFRqS0VtNVKBry4/PE +1OT0ZXWFlaW1xdXl9WZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo+Ck5SVlpeYmZ +qbnJ2en5KjpKWmp6ipqqusra6voRAAICAQIDBQUEBQYECAMDbQEAAhEDBCESMUEFURNhIgZxgZEy +obHwFMHR4SNCFVJicvEzJDRDghaSUyWiY7LCB3PSNeJEgxdUkwgJChgZJjZFGidkdFU38qOzwygp +0+PzhJSktMTU5PRldYWVpbXF1eX1RlZmdoaWprbG1ub2R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo ++DlJWWl5iZmpucnZ6fkqOkpaanqKmqq6ytrq+v/aAAwDAQACEQMRAD8A9U4q7FXYq7FXYq7FXYq7 +FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F +XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX +Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY +q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq +7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 +FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FWGefPzS8v+ +U4mhdhe6uR+70+JhUVGxlbf0x+PtmFqtdDDtzl3Ou1vaWPAK5z7v1vD9U/OP8w9SuWli1A2cQPJb +e1RVRR8yGc/7Js0OTtLNI3de55nL2vqJm+KvczD8u/z0v3v4tM81OssM5CRakqhGRj0EqoApU/zA +bd69s7RdpyMhHJ16uy7O7YlKQhl69f1vcIZopo1kicPG26spqM3r0q/FXYq7FXYq7FXYq7FXYq7F +XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqo3l5aWVtJdXcyW9tCvKWaRgqKo7ljsMEp +ACzyYymIiyaDw/8AMD8+Zrj1NO8ploYTVZNUYUkYd/RU/YH+Ud/ADrmi1fahPpx/P9Tzeu7aJ9OL +b+l+p5jYaLe6jKbq7dgkjF3lclpJCTUnfffxOaUl52Rs2Wb2vlaWy0Z770xbWw4iIPs8rMQNgdzt +U1P0ZV4gunI/KzGM5DsOnmwHzBEkOqyenRQ3F6DsSN/65aHHD6D/ACn1ue40+3ilflyBjavio5Kf +u2ztoG4gvouOVxB7w9IyTN2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux +V2KuxVivnf8AMjy55Rtz9dl9fUGWsGnREGVvAt/Iv+U30VzF1GrhiG/PucLV67HgG+8u587ebfPn +mjzrfBblitqprb6dDURJ/lN/M3+U30UzntTqp5T6uXc8nrNdkzn1HbuRHl/yfJJPGvpG6vG3WJRV +F9z8vE7ZgymA4kISmeGIsvT9O8r6XodqdR1h1llj3CdUU9goP22/z98w5ZTI1F3eHQ48EePLuR+P +iwnzn5xe4lNxMaAVFna12A8T/E5k4sVB1Wq1Ms8rPLoGBWsFzqd8ZJCWDMGmf28B+oZsdJpTllX8 +PVu0OiOaYH8I5vffyv06aMQVFPjMjewUf12zq3uHqWKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV +2KuxV2KuxV2KuxV2KuxV2KrJpoYIXmnkWKGMFpJHIVVUbkknYAYCaQSALLxf8wfz7jj9XTfKdHk3 +WTVnFVH/ABgQ/a/1m28AeuanU9o9Mfz/AFOg1vbFenF8/wBTyO103VNZuXvbyV29VuUt1MS7ue5q +27fPNJknvZ3LzmSZJs7l6H5T8hy3EatEn1ayP27hhV3p/L4/qzDy5wPe5Wl0E8252j3/AKno1tZ6 +RoGnuyAQQoKyzNu7H3PUnwH3ZhkymXoIY8WnhtsO95j5085tcsZpSVt0JFpa1oSf5m9/E9szsOGn +nNXqpZ5f0RyedKLzVr4sxqzfbb9lFzY6fTHJLhDLSaSWaXDH4nuem+SfJjzPEqRnjXYdyT3/ANb9 +WdNhwxxx4YvZ6fTxww4Yvc9E0aDTLVY0A9QgB2HQU/ZHtlremOKuxV2KuxV2KuxV2KuxV2KuxV2K +uxV2KuxV2KuxV2KuxV2KuxV2KuxVj3nHz35d8p2Yn1Sf9/ICbezjo00tP5V7D/KO2U5tRHGN3G1O +rhhFyPwfOnnb8zPM/nO5+rGtvpvL9xpkBPE0OxlbrI3z2HYDNFqdXLJz2j3PLazXzzc9o9yhoXlB +5JoxNGbi5c/BbJ8QHzp1/VmtyZXXDimaiLL1ny95EgtwlxqYWWUUK2w3jX/W/m/V881+TPewd3pO +yhH1ZNz3MqnngtoGllYRQxCrMdgAMxwLdvKQiLOwDyjzt50F1WR6pZREi3g/adv5j7/qzYYMNe95 +bWauWeVD6Q80d7zV7+p3ZvnxRR/DNpg05meGKdNpZZZCMXo/krya0rRoqEioNabknv8APwGdHgwx +xxoPY6bTRww4Y/2vdtA0G30q2VQB6xFGPgPAfxy5yE1xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 +KuxV2KuxV2KuxV2KuxVpmVFLMQqqKsx2AA7nFXkH5hfnzY6f6mneVil7eCqyaifigjPT92P92N7/ +AGf9bNdqNcBtDc97ptZ2qI+nHue/p+14qsGteYb6S+vZ5JpJWrNeTEsSfAV607AbDNLly72dy83l +ykm5Gyzzyn5HlnH+jJ6UHSW8kFSfZelfkNswM2eubPT6TJnPdHven6Poun6VDwtk/eMKSTNu7fM+ +HsM185mXN6HT6WGIVEfFHSzxxRtLIwSNAWdjsAB1ORAciUgBZ5PLvO3nRLoE8jHp8J/dp+1K3Ykf +qHbNhgwV73mdbrDnlwx+kPLp573V77YVJ+wn7KL/AJ9c2uDAZHhix0+mlOQjHm9B8meTjKURUqCQ +WYjdiehp+oZ0GDAMcaD1+k0scMaHPqXvPlzy9BpVstVHrkb9+Pjv4nucvcpOcVdirsVdirsVdirs +VeFfmV+eupwancaR5XZIY7ZjFPqTKJHeRTRhEGqgUHbkQa9s1mo1hBqLotZ2nISMcfTqw3S/zp/M +XTbpZZtQN5ETye2uo0ZWHsQFdf8AYnMeGryA87cHH2lmibu3v3kT8w9D836cs1q4gv0AF3YOfjjb +2O3JT2Yfgc2uHMMgsPRaXVRzRsc+oZTlzkuxV2KuxV2KuxV2KuxV2KuxV2KpL5q84aB5X083ur3I +iU1EMC/FNKw/ZjTqfn0Hc5XkyxgLLTn1EMQuRfOnn782/MXm6VrG2DWOkMaJYxEl5fAzMN2/1Rt8 ++uajUaqU/KLzer7Qnl2+mP45pPo3lR5JEN0hkkYj07ZNyT706/IZrMmbudUZkmovVfL3kWONUm1J +R8NPTtF+yAOnMj9QzWZNRe0XZ6Xsz+LJ8v1syUJGgRAFVRRVAoAB2AGYpDuQABQaeZERndgqKCWY +mgAHUk4KUyA3Lzfzp5yjuFeOOQx6bF1PQysOm3h4D6flsNPp697z2t1hynhj9P3vK7y8vNWvAqgm +ppFEOijxP8Tm3w4DyHNrwacyIjEWSzvyb5PaRkCpyLEc3p9o/wBPAd832DAMY83rdJpI4Y0Pq6l7 +15Z8tQaXbq7oPXI2B341/wCNsvctPsVdirsVdirsVdirsVQuqzSwaZeTxf3sUEjx/wCsqEj8cEjs +xmaiS+OPL0ccuqp6tGoGcBt6sB/mc5rNtF4bLyZrqnl83OkxXMoD201Qsq9Y5ASKHwO305gwy1Ku +rDwpRiJjkWHWl5rHlfWY7u0kMVxEaxyCvGRa7gjuD3GbPDlIPFFytPnMDxR5vpr8uPzH03zbpy/E +ItSiAFxbk718R4g9jm8w5hMWHq9Lqo5o2OfUMzy1yXYq7FXYq7FXYq7FXYq7FXlf5h/nnpOiepp/ +l/hqWqiqvPWttCe9SP7xh4KaeJ7Zh5tWI7R3Lq9X2lGG0N5fY8JuZ/MHmjU5L/ULh7meQ/vbmU/C +o/lUCgAHZVGanLl3uR3edzZzI3I2WX+VvJkkzUtE26S3kg2HsP6D6c1ufUVz+TXiwTzHbk9P0Ty7 +Y6ZHWJecxFHuH+0fl4DNfKUp8+TvdNpIYhtz702qB0wVTlqbyAAkmgG5JyosSXnnnLzgkqSQQS8L +CL+9lH+7COw/yfDxzP0+n6nm6LW6w5DwQ+n73lOoahdardqiKeNaQxD9Z982+LDWw5tOHASaG5LN +PJ3lB3dfh5s394/Y07D/ACR+ObzBgGMeb1ej0Ywx/pHm988qeV4NNt0lkT99SqqR09z7/qzIcxke +KuxV2KuxV2KuxV2KuxVxAYEEVB2IPQjFXx/5w0K48oedLuwAPp28vqWrH9u3k+JN/wDVPE+9c0mf +DRMXkdXp+CZi9D8j6lbziXTpqSWt6nqRq3Qmm4+lf1Zz+qgR6hzDDQTFnHLkUs84eUFgUggyWUh/ +dS/tRt4H/PfLdNqL97VqdMcMrH0sBs7zWfK+sx3dpIYriI1jkFeMi13BHcHuM3OHL/FFs0+cxPFH +m+mvy4/MjTPNunKOQi1OIAXFsSOVfEeIPj/tZuMWUTD1Om1McsbHPuZplrkuxV2KuxV2KuxVLPMP +mXRPLunNqGr3SWtuuy8t3dv5Y0HxM3sMjOYiLLXlyxxi5Gnzt+YX50655mMmnaUH03R2JUxof384 +O37xl6A/yL9JOa3NqTLYbB0Gq7Qlk2HpixXSfLMkrLJdgjl9m3X7R+dP1ZrMmcDk6eWToHp/l7yP +VY3vk9OID93aJsaf5RHT5ZqsupJNR3Lm6bs8nefyZ3b2sMESxooREFERRRQPllQxdTzdzGAiKCqz +4SyJUXkplMixJYD5w83I6S2lvIFtE/3onB+3T9lafs/rzL02nPM83S63V8fojyeT6pqc+p3KxxA+ +kDSKLuSe5983WHDXvaMWE3Q3JZd5P8oyO61XlI/237U/lB8B3ObnBgEB5vUaLRjELP1F775Q8qQ6 +dbxzSr+8oCikUp4Ej9Q7ZkOcyjFXYq7FXYq7FXYq7FXYq7FXYq8e/wCcivKX1zRrXzJbJWfTj6F4 +QNzbyH4WP+pIf+GOYmqx2LdV2pguImOjybyfqskYVVak1qwkiJ/lrX8Dmj1WL5F5vJcZCQe32CW+ +tWHwqJEnj5iFt+Q/aX/WGaXFgkZED6x9rv8AGBlj7w8483eUxbhkZTJZSH93J+1G3gff9eZum1F/ +1nSajTnFKx9LAbe41jyzq8V5ZymKeI8oZlrxda7gjw8Rm5w5eobcGcxPFHm+mPy1/MzT/N1gEciH +VYQBcW5PU/zL4g5tsWUTD0+m1McsbHPqGcZa5LsVdirsVeb/AJifnVofln1dP03jqWtrVTGp/cQt +/wAWuOpH8i7+JGY+XOI7Dm4Gq18cew3k+fdV1bzL5v1V73UZ2upztyb4Yol6hUUbKPYZrc2XrIvP +59QZHikWR+WvKDySAW0fqSjaS5fZV+Xh+vNXqNTXNxoQnlNDk9P0Dyta2KiQD1J/2rhx+CDtmuJn +l8ou402jjDfr3shVUjFFHzPfLowERs5oFLWfIlVGWUKPftlE5UxJYL5u81rwls7aTjGtRdXFaCg6 +qD4eOX6bTkniLp9Zq79Efi8l1bVZdQnEMIPoA0jQdWPiR+rN5hw173HxYfmyjyf5SkkkVmXlM32i +P2R/KD+s5t8GDh3PN6bRaMYhZ+r7nvvk3yjDY28c8yDlQFFp18D8vD78yHPZdirsVdirsVdirsVd +irsVdirsVdiqG1PTbTU9OudOvE9S1u4mhmTxVxQ08D4HARYpjOIkCDyL471DT7zyt5pudOuv7yxm +aGU0IDx9nA8GUhhmozYrBi8nqMBBMT0es/l/rbRMbblUxn1oPdT9pc0Ge8cxkHRn2dmr09z0LWdI +t9StTNEgcSrWSI9HB/42zL1WlGQeLj+rn7/2u6zYRMX3vHPNnlQW4ZGUyWUh/dyftRt4H3/XlOm1 +N/1nnM+A4pWOTAre41fy1q8V3aSmKeI8opV+y69wR4eIzdYct7huwZyDxR5vpr8s/wAzNP8ANunh +HIh1WEAXFuTuT/MviDm0x5BIPS6bUjLGxzZxljkoHWdb0nRbCTUNVuktLSL7UshpU9lUdWY9gN8B +kBuWE8kYCyaD58/MT89dW1v1dN8vc9O0pqo9z0uZl+Y/u1PgN/E9sw8ucnYcnS6nXyntHYMD0zy7 +NORLd1SM7iP9tvn4ZrcucDYOmnlrYPSPLvkpnWM3EfoW/wCxbqKO3z8P15p82qs1HeTdg0Rmbm9C +sNKt7WFUCKiL9mJeg+fjkIaezc9y7nHhERSNLU27ZeW1SZ8qLFQlmCCp69hlM5UxJYV5r81emJLS +1lowqLicGgUd1B/Wcnp9OZHik6rV6r+GPN5JrOsPeyfV4K/VwaADq58f6DN9hwcO55uNiw172Q+U +fKcssqO6Ezt/wgPYf5Xie2bXDh4dzzej0WjEBxS+r7nvnkvydDaQJcXEYpQcFPf/AJt/XmQ7FmuK +uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KvCP+ckPKXF7LzTbJs1LO/p4irQufo5KT/q5jZ4dXU9pYeU +x7mA+TtaeIQyg1ltGAYdyh/5tqM0eswXY73QS/dzEg9+8s6kk9r6YbkoAkiPijb5j9m5tjA84vRa +bJYb13RYb2KRlQMWFJYj0cf1w6zScR44fV9658IkHjnmvysIAyMpezc/u5P2kbwPv+vK9Lqb/rPP +ZsJxGxyYLb3Or+WtXivLOUxTxHlFKv2XXuCPDxGbzDlvcOTgzkHijze2xf8AORmkReWEnktHm14j +h9UHwx8gPtvJ/L8tz7Zm+OK83dHtGPBderuePeYPM/mnzpqn1jUZ2nYV9KFfhghU9kXovz6nvXMT +Ll6ydPqNQZG5FNPL3lR2mUQx+vcjdpDsif0/Xmq1Gqob7BwrlkNReneXfKMNuVlYCWcdZmHwqf8A +IH8c1hlPNsNouy02jEd+ZZZDBFAtEFWPVj1OZGPFGA2diIgNs+ElbUmfKyWNqE06otT9AymcwAxJ +phvmjzQYeVrauPXIpLKD/djwHv8Aqx0+AzPFLk6zVaqvTHm8k1vWmumNtAf3APxMP2yP4Z0GDBw7 +nm42LDW55p15S8qzSypNIhMzU4rT7Ff+NjmzxYq3L0Oi0fD6pfV9z3zyT5Mht4VuJ0+Gmy/ze3y8 +fHMh2TO8VdirsVdirsVdirsVdirsVdirsVdirsVdiqV+adAtfMHl6/0a52jvIigb+VxvG/8AsXAb +BIWKa8uMTiYnq+PrUXWja7LZXimKWGV7a6Q/ssrcT9zDNZnxXHzDy+fEaI6h7H5D1sogiY/FbHp4 +xN/T+mc7l/dZRMci2aDNQruemCUEAg1B3Bzb8Vu7tJ9c0eG8idlQMWFJYj0cf1zX6rTWeOH1OPmw +iQeReafKwhRgymSzc/A/7Ubdq/1w6XVWf6TocuE4jY5MLt/LUxuGE7gQKdmX7TD28M2stSK25pln +Fbc2eeXvJ7yInJDb2v7KAfvH+/8AWc0+o1m9D1STi00pm5PR9K0G3tYVX0xHGNxEvf3Y5TDTGR4p +u3xYBEJryVVooAA6AZl8m9TZ8gSi1NnyslFqE06ovJvuymcgAwMqYh5m8zG35W8DVuWHxMOkYP8A +xtgwYDkPFLk67VamthzeSa7rZnLW9uxMVf3sn858Pl+vOh0+nrcuPhw1ueaZ+VPK808yTypWQ0Ma +EV4g9GI/m8Bmyx463LvtHpK9UufR755G8lRwxrcTrRB27se4r+s/QMvdm9BACgACgGwA6AYq7FXY +q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXzj/wA5FeUvqHmC38xW6UttVX07kjoLmJaV/wBnGB9I +OU5I726jX4qlxDqx7ydrhja3uWbdD6Vx7r0r92+aDXae7HxDpP7vJfR7hol8JrQRk1aLYHxU9Mxd +FluFHmHeYZ2EwMmZlt1pTq+kxXaOyKCzikkZ6OP65g6jT2eKP1OPlxCTGtP8lQQXXqLCxYGqmYgq +nyFN/wAcpJzT2Ozh49GAbplVraQWwqvxSd3PX6PDL8WCMOXNzoxAVmky0llam0mVkotSaTIEsbUJ +p1RSzHYZVOQAtiZUxTzJ5lFuDDCa3TDYdRGD3PvkMOE5TxH6XA1GorYc3k+va40rPbwSFuRPry1q +WJ6gH9edHptNW5cfDh/iKK8q+WZbqZJ5kqTQxIR0/wAph+oZsYQ6l3uj0n8Uvg978i+SVRFnnWiL +1J6k9wPfxOXOzejoiIgRAFVRRVGwAGKt4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FWN/mJ +5UTzR5Qv9KoDcsnq2THtcR/FHuenI/CfYnARYac+PjgQ+S9CuXtdQa3lBT1D6bqdiHU7V+nbMDVY +rjfc81qMdx9z2byTrVYY1dvii/dS/wCofsn/AD8M5qY8LLfSTbo82zOTJmdbs7aMmRtFrDJgJRaw +yZElFqbSZAlFqbSZAlFqMs6opZjQDK5SpiZMX8xeYxbIUjINww/dp1Cj+Zsrw4TllZ+lws+or3vK +vMGvSO8kEUnOR6+vNWpqeoB/XnSaXSgCzy6OPhw36pLvK/luS8lSeZKqd4oz0P8AlN7frzZRi7vS +6W/VLk968i+SBRZp1IRd2Y9a/wDNX6ssdo9NiijijWONQqKKKo6AYquxV2KuxV2KuxV2KuxV2Kux +V2KuxV2KuxV2KuxV2KuxV2Kvlv8APjyk2g+dG1C3ThZayDdREbATgj11+fIh/wDZZEh1GrxVK+hU +fKGsgSwTMaJMPTmHYN0r9/4ZzfaGm2I7tw6aP7uddHrunXnrWq1Pxp8LfR0zDwZOKLtsc7CIMuW2 +ztaZcFotYZMiSi1NpMiSi1KSZVUsxoB1OVylTEyY35g8wrbR0WjSt/dRf8bNleLEc0v6IcTNnp5b +5g16QySRI5a4kP76Xwr2Hv8AqzpdJpBQJ5dGjDhMjxSUfLPl2W/lSeVaxVrGh/ap3P8Ak5swHdab +TcXqPJ7z5E8kcys0q8VWhZiP89/Adsk7R6nBBFBEsUS8Y0FFGKr8VdirsVdirsVdirsVdirsVdir +sVdirsVdirsVdirsVdirsVYN+cnlH/Enkm6SFOWoaf8A6ZZ0FWLRg80H+ulRTxpi0ajHxRfMHly8 +4TtbMfhl3T/WH9RmHrMVji7nntVjsX3PY/Kmr+tBGWPxH93L/rDofpzlJR8LKR0LLT5GSmXLrcu1 +hlwWi1plyJKLU3mABJNAOpyJKCWPa7r8dtFXqx/uo/E+J9srx4zmlX8IcbLlp5j5g1+T1HVX53Un +23/lH9c6XR6MUNvSGnDhMzxS5ITy75fm1GdZpVJgr8K95D/TxObWnc6fT8W55PdvInkgyMkjqFRQ +CWpsB22/UMXaPWba3ht4VhhXiijYfxOKqmKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku +xV2KuxV2KvkX82fKj+U/PV1FbJ6djct9d08gUUJISSg/4xuCtPCmS4RIUXU6jFUiOhTPypqq+qlD +SK6UU9nHT+mct2lpzR74umiDCVPRre69WFWrv0b5jNfCdhzoysLjLhtNrGmAFSdsiSi0l1nW4reL +kTWv93H3Y/0yOPHLNKhyaMmR5r5g8wSh2+PndydT2Qf59BnTaLRCuXpH2teHCZmzyS3QNDn1O5Ek +oYwctz3dvAH9ZzbnZ3GDT8XP6XunkTyO0rIzRgIAO3whR028PAd/lkHZgU9etLSC0gWGFeKL95Pi +cUq2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV5h/wA5AeUP015OOqW6 +cr7RSZxQVZrdqCZf9iAH/wBicnA7uPqYXG+588+W70qWtyaMD6kR/X/XMPX4f4vgXQ6vHyk9X0TU +hPbo9f7wfEPBxsc46cPDmYsMc0yM3vjbbaV6rrEVvCWY7fsr3Y4MeOWWXCOTTObzvzB5gkDlmYNc +uPgXsi/LOn0OhFUPpH2ow4TkNnkk+iaNcatdc35ejy+N+7Mf2R75uTURQdxgwcXue4eRPI5maMem +AigAbfCFH8B+OVOyArZ7JY2NvZW6wwigH2m7k+JxSiMVdirsVdirsVdirsVdirsVdirsVdirsVdi +rsVdirsVdirsVdirsVdirsVWTQxTQvDMgkilUpIjCoZWFCCPAjFXxp538uz+T/Ot7ptD6VvL6lox +r8dvJ8Ue/f4TxPvXL5QE4V3uqz4ecWUeWdRXn6Yb4JQJIj70r+Izj+08BA4usdi6UXE0yC/1SOCA +yOaL4dyfAZrMcJZJcIZymwLX9fYMZHo0zCkUfZR751Gg0Aqhy6lOHCch8ki0jSrrV7ssxPp1Hqyd +SSf2V983hqAoO5w4b2HJ7b5E8jmZolWIKi7KvYAdd/1nMcl2IAAoPadN06CwthDEP9dqUJP+fTFK +KxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV4z/zkl5Q+u6Ha ++ZbZK3GmEQXZHU28rfCf9hIf+GOX4Zb04+ohYt4l5b1FlUR8qSwtyjr3Fa/gcwO0dNe/SXN0esxU +eIJjr2vEEySbuRSGGuw98w9B2fQocupacOE5D5Me03TrzV7wkk8agzS+A8B7+AzfnhxxoO5w4eg5 +PaPInkcyNCkcXFF2Vf11P6zmKTbsIxAFB7dpWlW+nWywxAcqDm4FK0/gMCUbirsVdirsVdirsVdi +rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVQ+o6faajYXFheRia0uo2hniPRkcc +WH3HCDSCLfKX5gfk/wCYfK+pymzRr3SWJa1ulpzCH9mQbfEvQkbd9sy45okbuLPCfexez8savdTA +SoYkJozuat9C1qcJyxiNkRwn3PW/Ivkcs0UUcRCA7DuT3JP836sxJSJNlyoxAFB7lo2j2+mWqxxq +PUoA7D9Q9siyTDFXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX +Yq7FXYqpXNrb3MRiuIxJGexxVIG/L3yuZfUFsUJ6qjFR+GKp1YaVYWEfC0hWMUpUbmnzOKorFXYq +7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 +FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F +XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX +Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY +q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq//Z + + + + + + +uuid:4b4d592f-95b8-4bcd-a892-74a536c5e52f + + + +image/svg+xml + + + +test.ai + + + + + + end='w' + + + + + + + + + + diff --git a/icons/edit.png b/icons/edit.png new file mode 100644 index 0000000000000000000000000000000000000000..36775390f1e8e89e7007e4978a003751acab855d GIT binary patch literal 1092 zcmV-K1iSl*P)~5*A*!^YQ=y03CEi zSad^gZEa<4bO1wgWnpw>WFU8GbZ8({Xk{QrNlj4iWF>9@00XE=L_t(|+O3vfXdG1- z#ea8pHk&l*+HTsiDwroRRr+SzZGu8xHAV0#Mi7GFgQ9}95d@3R>WdHJpJ03lL27YZ z&7+8I)5MxKX*Coot(4-HO(;o7$nMVU%)OrvGdufdlG>slTxJ<&&N<)t?me^cKh)6B zkaa)Ly#&YutTM2XPN$`}w^v3+Ms5J@fZC2g78e(#TrSJMmFv3Vx{kQ6BgJA-3Wb8q z&(BLwPfr2Z18mvReSz0W99dgimD8v5vb?-3A|g{$Q5*o_Pw9UTBnPfy3$ zMNmp1B8UiD`#6qEsZ=7BN&zr1Fo5GY*6{G~$DZfC6WZ8_5ietmXsyNfz3A$Bp17_f z8yg!kK0dzPj7ET@Y9WX^s3{dO1h*xeUvMA5_ccpPMY8+$@!O?2PMr7uJN`~}v zQvjVYf>z+*Doqw4g0d{CuFJ~mDxT}`_!Il_?>>V!m*TatqD-8*rhvV6tJlV8&Yz!- zlm>tx2nvOS4j3&MqcO(t{NPdi<$k=mc8-6yMhN~s&>ri+^QsNNAqj#QL0Jkhb&EuV zo#}_D7W$|z?BLDGO};sKv4;0DaBhnZ3>T&^L`nm|cn7|(85}%{d+P}9rFLGQSY;x= zz}s)U%BP=w4X_S4aRRM5(w9R_sItMTXqy_tuHD_ZH*=J)?cu#scbLd8F!tr=+`e_a z2DJvbTX!%s6Zjn3VTHg-smOEZ`e7>bDMruy&DghB867=FraMDvJyV0K0NUQ_NcZ>k zAqd8pCIWz6ySpj>afs686mR9%nap2h?5i)xWHLOQ&9c67C(;@_$pF6gnVFfb%{?4+ zFi_9)0JwegSw8ylCnod1bNt<76ql9|gaZejLbXI)j6iEm?(m^Vac#GFUX@24eT)|d z_Ok!QPXPG-)JeK_c9G3yNu}CQN?|GM-ULQ#W@l$ZV50Njx-I}e{BoCbXMaXnimuL1 zY&%I?TarW~fl~3Lj$7n=96b1RlX@`*U;F%Z<4=?Ym5M_$X$SMMtmw>WtuaP#Pf)E^ z(OQT01p6Kp%*7akHa^BTB$GCYM4}!WN=5HAI2$L}+}uQK9eAT?QmB+dDTQs@!SArU z+T0qmtFf9UQYaKa3?c?&>Z?(yr4+3)gE%3~CfUA&i@%;_N1F;FK_rT3BPI-L8kDQZ z?;5BP!{vo5)c1IEz4Cw`{d=tsfG1ni)CRi4mHdzYWISL6SosILcm(iR4NM6D0000< KMNUMnLSTZ^3;LP> literal 0 HcmV?d00001 diff --git a/icons/expert1.png b/icons/expert1.png new file mode 100644 index 0000000000000000000000000000000000000000..281364540cb28396ff70aa411ef806842695d18e GIT binary patch literal 278 zcmV+x0qOpUP)Ai7~R1}oJ1T&D{&1Qe^4@o7J?fnh?NkQOlFN!8hVBw$BFvIS8CRYq~ZxB_{;`TT%bg6D2U(%C3{E&N|%vsZ$Lb- z>?I9F0qpqno~8i* zOe?yYf_WY-KcuB7fDJzodzykxZNY*+qFc=oom;x3tG%YXnuj*B>;($aPBO1&#ZD~R;=+S1uohH0vO;Ty{1V3896S(oQy!)9Pz|^?MLlr?bnZG?Zk)D hZvH845{blA^9>4rlh*m?3^o7&002ovPDHLkV1kGuhNl1k literal 0 HcmV?d00001 diff --git a/icons/eye.png b/icons/eye.png new file mode 100644 index 0000000000000000000000000000000000000000..c4b65505acc1538d6a2fcc79604702f563fa16b8 GIT binary patch literal 1264 zcmeAS@N?(olHy`uVBq!ia0vp^A|TAc3?z4jzqMyzU}gyL3325V(*Pk6RZdZLAju)D z%r2(}*EcXQFf=qYGBPqYHa0OaF*P+cGcz+cH@C2`u(Y(ava+(awzjdcv9-0e zv$M0ew|8)GaCCHZa&mHZc6M=badmZdb8~ZdclYq{@bvWb^78Wb_V)4d@%8of^Yiof z_YVjN2n-Ai3JMAi4h{(k2@MSm3kwSm508k5h>VPkii(Pkj*f|miH(hoi;Ihok55QQ zNK8yjN=iyjPEJWlNli^nOG`^nPtVB6$jr>l%F4>l&d$ln$<58p%gf8p&o3w_C@d^2 zDk>^2E-o!CEiW&xtgNW2uBxf6sjshVY^rZ*ZER_6YHe$7Yj1ArXlVzcP9SOpqK?ki z=C)R#ikha@s>ar`#_qDFzVem{m8}zM+xwb3ds@4DI(vG$db@jiyZZWjCrs?0G-=|L zDU+v8ojQH`^qDhf&YCrA_Uzen=FFKpckaA-^XAW=zhJ?Fg$oxhTC`~K;>AmrELpmA z>GI{vR;*aDa@ERJt5>aFvwF?iHEY+dUAJ!Sy7lYUZ&<%!!}^UIH*DOrant5ao40J< zvUSV0ZQHhQ-@aqVj-5Mq?%K6$_wL<$_UzfaZ|}bS`}QB$f8fA@g9i^DI&|>x;X_A` z96omJ*vXS8&z?Pd{`~oi7cXAEeEI6tE7z`Fy>a8lty{P5+_`h_-rf86?>~6(;L)Q; zj~_pN`t-@OXU|@|c>eO`%h#`8y?*`r4H&$8_xAn!_a8rg1d{LHzXPN9AHV=8`03N9 z&!0bk`SRuK*RS8cef$0$h`#^$@#E*upTBtRv3M$cQb?Gcqx=aS4bkYUt?d=^Gdt8Jn1znOj&|S=-p! z**iEoIlH*JxqEnedHeYK`3D3B1&4%&g-1k2MaRU(#U~^tC8wmOrDtSjW#{DPqE&B<0t1O`W%F-M0N_FI~U=@HsFfUOc;Vao?JSbEZw7F>}`JIdkXDU$Ah| z;zf&q(Fr7h@wsH_vK6b=ZrHqi$Ie~54;(#l`s}&$=gytKeC^JICof*T`}q0mx9>lI z0Rj#WP+elF{r5}E)UhFz@y literal 0 HcmV?d00001 diff --git a/icons/feBlend-icon.png b/icons/feBlend-icon.png new file mode 100644 index 0000000000000000000000000000000000000000..1c1aca8497817ec07f2ab55216df32cb74d138af GIT binary patch literal 8059 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 JPDHLkV1g>|IV1o8 literal 0 HcmV?d00001 diff --git a/icons/file.png b/icons/file.png new file mode 100644 index 0000000000000000000000000000000000000000..1ec0515a25dc982de92c4f84105c32c5b8e38d01 GIT binary patch literal 765 zcmV2E~u3B0ewN-sfC9-);phi`iIq8DVSf26CAUgZGEs zl#>e-6El?Z%<{6H$)}gPO#rR6RZ(H_{#)V?a>~imP#xszg%bg#R8g0?ylZw3KDi2X zFT^;O%AjXP@si)sS`g7_JztVqGpRMczu2d>zpQQ5?PULx~7em_4kj=W~&h&Udi3nQ`p6Rz5_FNQMe2M=8rNm24y?zy& v7#dI_f>Np;*bPKWvJBe*1-w)L-JkapcUxz&@~yn63-pxHIOuxaX|NrYP{ z8bfnvA+09;F(xD%tro-(#vq8fHxA#`UW~;cMr$Q=_Ch7LOf3I2a(ad8ikg4n`iJtS z_ul7u&a)SpY4b|G*$)oqaDMRnobNfm^OcAYB_$i~~{&bYX^ zD?L3uO}s)#FK-+^e0Y0bU*Gq#Eaw*$6_JyZgTvuK2!Y@4r@OnGmX;PYO}m+#oP4^g ztLyJq1{4$&lub=dUCqnOGgVYnkeHZ=*=$CVB!m#Cs!A{zWO8znOP4Nj`}S?kZnswq z4Gl$9qdZ@fmzQsU`0!!dzJ2>lM~@!G>2wks8%sh$0#2tBm&=92;lO6IVYAuD&dz3O zX-U3!@814Rn>Jmao12^35D*TBf62?sORKJ~#%8l&x7%^KT-aj7kdZQHh$2_f>2963TvObm9r9jDVtR8$m-q9DsM zvMjGaWLd^)wUU;WMomo(hGFCKe zi>ERS0{|fex~}7JI2aon!|V0xnx-|br=TJn4j(ElEyd&Uke!`PdU`r--S;_krh$ox ziIt*;VX*hJbNqOv^+lIR61#WrM%VScNLTcmq9~-Kq+qdFxIa9>2cLY!#cMZsJ1rTf z(}~aLLkNLk80^W<<)>>mD60B~`@_%R9*+lLbEGyk;^X6KZf@rM)egMAFN0&gUO^24y(-1&#!cl zBuQwRhOX;atyZF=qX`Cs3=R%*?AS4c5amGAx(c$gwvwBhOI=+ZfxrTbi;L*GPC|S< zcDo&$%|>)|G$xY?MUk1Fo@QZTfhSL%P+wn<5aQ-~#a9%ls>-cfx7f3155>jBoH}(1 zv)PQI$QZ`6)9bp9rfGyiL1t!ViHnP)p`n4cwl)pe3tZn2(BI#WcVK`|tE;NYMJEH2kM1N;yH5N2*}j**d3=I7@*d-g2d z-QDckwTqoQcj9)t0T>$c(b3VtojY9sH-Xc@RUm%Z6=r}FK=WEaILz$qEJ$DogR${3 zyxu|nXlkOTx0lJuNdR0f7t_!1XXg^&1-8no0nhzr_4?(#4I-OiWBrRaNB$vep5(m*+b`B2Wm70DKM@uQ94OP~l!R{-5|4 X!3aP*oqec_00000NkvXXu0mjfE3=9z literal 0 HcmV?d00001 diff --git a/icons/fit-window.png b/icons/fit-window.png new file mode 100644 index 0000000000000000000000000000000000000000..585e970773e3fcd327874e6b1c95f194e25db04b GIT binary patch literal 1102 zcmV-U1hM;xP)m7h6!lKo|() z23LgOXuQoO2Xl(~2R!M2A*e$x!32yaK}|H-Rf7;jL{~H(Mm(5idb+!+dk=9MC5|qO zTkxQ|s(7FGzV*7Q;D2sfv57A9mdwc%r z)2I5-&=55>HI$c^Q(aw6O-&7V?%W|3i&0iqMp;=Ijg5`iwk_7z*Zc0@zyI#!2JYKze#o^(h{^iS; z383pTfBQ3gS9VR1p83ss_NJbLs9rIcB;imIxryxG}V{qEhnR903JjYf$? zB19q)gb<-~-}g~U;dx$IQMp`>gM$MeKYlD-*EKHPWTh0ErlIRPN-55Ms$a4w%$)~G zDe*k-m&`6mq?Fp<-Q5jqePCdKXV0D?r3~%7vs5a@@bEC6=i$08TU%QwrS^*gf*@G_ z@Zkgbd>+?z!zf+X#c`a_T-U{Q-7tf~_}ttazV9y=1qdNBnM{W5?QLw^4y8z?QVa|X zVB0p1er3Qc9Fk*tX5LZ{K+T{yjjZD8RC;4JqZq*w`4BWnIu$DTQTO;dsHM zl$@TPGCn?z@B0hD+bho^!!TNal_yW0=p!Q|7>0qa>tW6Nz8`M1>$>D}ImXAwnV+AR z!0*7jE6*a|_oJGoEo^OV^{uU~iTe6_N=r*|T{o1-aU3kmVsmqov9U2eeflJU9PkHl z0{nU1aUBO@nx;(%Av!xcI%sQaqoJVzfSsKkmX?-STwDZL0A2!bfU2`#kAWA!>~$AT z9QY0B15Dt-+4w%Ne72#-z#%|GL&GMZ?d|OezylIz>#l9_EA0H5<8(UhwYIj}!0DN6 z@teGQ@B|v=@)Zy_*J{ha3S4=mg^04Zl*(NBlRyKXRT6 UX2HdmmH+?%07*qoM6N<$f)LCR!vFvP literal 0 HcmV?d00001 diff --git a/icons/fit.png b/icons/fit.png new file mode 100644 index 0000000000000000000000000000000000000000..9e0e817be2ac2e29799aeb5f0752224c1996e73a GIT binary patch literal 2262 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 literal 0 HcmV?d00001 diff --git a/icons/labels.png b/icons/labels.png new file mode 100644 index 0000000000000000000000000000000000000000..c82ffb7b6fa64c44f97559c8ac954eae1e73da85 GIT binary patch literal 2381 zcmV-T39|NyP)1{1LZf#e$wY9CTw%e(;)K*=qU3W@xFc4d6Tk1pv1*7#Ap-2KKmn7t# zy!(R&)0jX4sQ>IaC+B&2^ZPyde1FgLySxeTf4jLRc)F=jC=!8fQmOP#K@cKtFq6C4 z>~{MpQ4}{-S6A;FwzWc`h{(&!>#VD*6HO+QI8t*s9Aok_8jWIIU7eVhmnSYwzO3oE+`;l z=T4&I;>Hx-Q(ITNCIilz_a>;WxR?-gD@#|JkeJVMdF~q80#~s3)gRIL*kkne^o%*Y z)4Q{I72r*M_lXmzc9oF1NDpBW`lif6AG?Nx`0<2G4v_WRciA}pku+jC?b+q@a0(Kx2?-ptb^_WEH{ za&!4+elxWL4TmvL@Y6ll;e zK?j(0(DN2pnjm5Y(m*w<-_D?+xR}dbU4Dxg(K705@F1CtJKubh^5RB}A?pVOXo22t zP?v!53`FE38>i&%-zC%V+;eEPTE9fNU;8A$*O37jCzo@__U-H|sKFZk%c~-~+o7!l z`dcBqh^V-F?)+I44X?e1!C>%9gkQ_3Kk&}KBV%J(P*TFKwTG}oaU)_@2dpg9eyJz&&B#6zSl zxq#68Da{8DVzF3!7BQ><=V^2#@J^pFe?BvR{};-(YO%>OuV$j{D5&;=Re*?mGIJNw zSyo0{Tbobter;qUg?IXySy@Ep7V_CgAvl6ku8KH+2rhgK)?k9B-%dwO4XrAbU&oCh z1&n6o-Tj=^tFg~r#?hv9>>=@B2J|BIJFtE0Ab8GPqHjsYa{4rVeSO11`&B}tg?IXl zq9W9e$z0Ioz|JH@nN(3hM`FfQL zPb)v=Oz*&X#%9p)d3hNX2WmLl*hKS*qf}RZfm&}Hh}+Z3spE|(l}f5VKkF6NllNp^ z1;|1hkpx8Y$NQEJ3fTYfJ^W<(2ZL?;ntsjr=s9SPJi*-L)c`c?{wY~2?&EC3*F1f9 zHodjKVcGIrjw?ISwQOf{Y${r8T>QF>U#) zUGERJF(2WZyC!-J2HluoOuxI}d3@_~-FPNHX>rStGEo{Bh5i+Nx&eYwAlsX1>lxx1Cp z(*qADUzE2qZo(>_DlVkDqKs$WP!hA?9zbOKzWJ!W+D%){`@C0YV%n5wzskp_eE{I- zE06MOn;vn(RtgGs^6tCuLDD;zx<8@3+sNU!&afq^oEKVkNTQ)4CKcRldwi z-|7gPXXUe<%h*_V34pjOZ?SgyKA~0Wg_NcPJE!l&GkvA?wfE(&lTsw6rvz;hpAnBkStwdZ(+a>m2~8 zRQmS^AAB$+Jw1K!o8_@Q3yst}91fqq*gAjm!jqTC+X50S&3t|n=@78iB00000NkvXXu0mjfZ2q0w literal 0 HcmV?d00001 diff --git a/icons/labels.svg b/icons/labels.svg new file mode 100644 index 00000000..652cef3f --- /dev/null +++ b/icons/labels.svg @@ -0,0 +1,819 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + begin='' id='W5M0MpCehiHzreSzNTczkc9d' + + + + + +Adobe PDF library 5.00 + + + + + +2004-01-26T11:58:28+02:00 + +2004-03-28T20:41:40Z + +Adobe Illustrator 10.0 + +2004-02-16T23:58:32+01:00 + + + + +JPEG + +256 + +256 + +/9j/4AAQSkZJRgABAgEASABIAAD/7QAsUGhvdG9zaG9wIDMuMAA4QklNA+0AAAAAABAASAAAAAEA +AQBIAAAAAQAB/+4ADkFkb2JlAGTAAAAAAf/bAIQABgQEBAUEBgUFBgkGBQYJCwgGBggLDAoKCwoK +DBAMDAwMDAwQDA4PEA8ODBMTFBQTExwbGxscHx8fHx8fHx8fHwEHBwcNDA0YEBAYGhURFRofHx8f +Hx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8f/8AAEQgBAAEAAwER +AAIRAQMRAf/EAaIAAAAHAQEBAQEAAAAAAAAAAAQFAwIGAQAHCAkKCwEAAgIDAQEBAQEAAAAAAAAA +AQACAwQFBgcICQoLEAACAQMDAgQCBgcDBAIGAnMBAgMRBAAFIRIxQVEGE2EicYEUMpGhBxWxQiPB +UtHhMxZi8CRygvElQzRTkqKyY3PCNUQnk6OzNhdUZHTD0uIIJoMJChgZhJRFRqS0VtNVKBry4/PE +1OT0ZXWFlaW1xdXl9WZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo+Ck5SVlpeYmZ +qbnJ2en5KjpKWmp6ipqqusra6voRAAICAQIDBQUEBQYECAMDbQEAAhEDBCESMUEFURNhIgZxgZEy +obHwFMHR4SNCFVJicvEzJDRDghaSUyWiY7LCB3PSNeJEgxdUkwgJChgZJjZFGidkdFU38qOzwygp +0+PzhJSktMTU5PRldYWVpbXF1eX1RlZmdoaWprbG1ub2R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo ++DlJWWl5iZmpucnZ6fkqOkpaanqKmqq6ytrq+v/aAAwDAQACEQMRAD8A9U4q7FXYq7FXYq7FXYq7 +FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqlvmDzFo +3l7TJdT1e5W1tItuTbszHoiKN2Y+AxV4j5g/5ydvTcMnl/SYlgU0Se/LOzDxMcTIF/4M4qk//QzP +nv8A5YNL/wCRVx/2UYq7/oZnz3/ywaX/AMirj/soxV3/AEMz57/5YNL/AORVx/2UYq7/AKGZ89/8 +sGl/8irj/soxV3/QzPnv/lg0v/kVcf8AZRirv+hmfPf/ACwaX/yKuP8AsoxV3/QzPnv/AJYNL/5F +XH/ZRirv+hmfPf8AywaX/wAirj/soxV3/QzPnv8A5YNL/wCRVx/2UYq7/oZnz3/ywaX/AMirj/so +xV3/AEMz57/5YNL/AORVx/2UYq7/AKGZ89/8sGl/8irj/soxV3/QzPnv/lg0v/kVcf8AZRirv+hm +fPf/ACwaX/yKuP8AsoxV3/QzPnv/AJYNL/5FXH/ZRirv+hmfPf8AywaX/wAirj/soxV3/QzPnv8A +5YNL/wCRVx/2UYq7/oZnz3/ywaX/AMirj/soxV3/AEMz57/5YNL/AORVx/2UYq7/AKGZ89/8sGl/ +8irj/soxV3/QzPnv/lg0v/kVcf8AZRirv+hmfPf/ACwaX/yKuP8AsoxVFad/zk75oS4B1HSbG4t+ +6W/qwP8A8E7zj/hcVeyeRfzJ8tec7Vn0yUx3kQBuLCaizJ25AAkMlf2l+mmKsqxV2KuxV2KuxV2K +vm/XDqf5ufmk+j287Q+XtJLqJF3VIY2CSzAHYvM9AvtTwOKvePLfk/y35bs0tdHsYrZVFGlCgyuf +GSQ/Ex+ZxVOK4q6oxVrkMVdyGKu5jFWvUGKu9RffFWvVX3xV3rL74q71l8DirXrp4HFXfWE8DirX +1hPA4q76yngcVd9Zj8D+GKtfWo/A/hirvrcfgfw/rirvrcfgfw/rirX1yLwb8P64q765F4N+H9cV +d9di8G/D+uKtfXovBvw/riqVa/5X8r+abR7TV7GO55CiyMoWZP8AKjkHxKR7HFXzB5n0XXfys8/R +NZXBJgIudOujsJYGJUpIB8ijj+oxV9VeWtfs/MGhWWsWf9xexLKErUoxHxI3up2OKplirsVdirsV +Q+oMy2Fyy/aWJyvzCnFXhP8AziwqvL5nmYcpQLIBz1oxuC2/uVGKvficVaxVrFWicVaJxVrFWsVa +JxVonFWsVaxVrFWicVaxVrFWicVaJxVrFWsVaJxVonFWsVaxVdCSJkp/MP14q8V/5ypRBJ5ZkCjm +wvVZu5CmAgfRyOKsn/5x3vJX8lwWzElQZmSvbjMR/wAbYq9XxV2KuxV2KofUv+Oddf8AGGT/AIic +VeE/84pn/lKP+jD/ALGcVe+nFWsVaJxVonFWsVaxVonFWicVaxVrFWsVaJxVrFWsVaJxVonFWsVa +xVonFWicVaxVrFWicVXQ/wB9H/rD9eKvFv8AnKw/8ov/ANH/AP2LYqn/APzjn/yisHyuP+T4xV6/ +irsVdirsVQ+pf8c66/4wyf8AETirwf8A5xRNf8U/9GH/AGM4q9+PXFWicVaJxVrFWsVaJxVonFWs +VaxVrFWicVaxVrFWicVaJxVrFWsVaJxVonFWsVaxVonFWicVXQ/30f8ArD9eKvFf+crjT/C3/R// +ANi2Ksg/5xy/5RS3+Vx/yfGKvYMVdirsVdiqH1L/AI511/xhk/4icVeDf84nmv8Ain/ow/7GcVe/ +HrirROKtYq1irROKtE4q1irWKtYq0TirWKtYq0TirROKtYq1irROKtE4q1irWKtE4q0TirWKroP7 ++P8A1h+vFXiv/OWBp/hb/o//AOxbFWQf844f8onb/K4/5PjFXsOKuxV2KuxVD6l/xzrr/jDJ/wAR +OKvBP+cTD/ylX/Rh/wBjOKvf2O5xVrFWsVaJxVonFXln5ofnxoPk9pNM05V1XX1qrwK1IYD/AMXO +v7X+Qu/iRmNm1IhsNy7vs7sWef1S9MPtPu/W+fdS81/mp5+uWaS6urm3ZivoQH6vZoaV4mhSKtP5 +zXNXn1dbzlT1uDQ6fAPTEX8z+tX8r+Z/Pf5Xa5azXMUo0+evrac8oe3njGz8GQugkWoNRuNq7GhO +m1Q5xNhhrNHh1cDH+Ideo/Y+q/KfnXRfM+nw3umyVinXkgPXbZlPgynqM3UJiQsPAajTzwzMJiiE ++yTS1irROKtE4q1irWKtE4q0TirWKtYq0TirROKtYq1iq6A/v4/9Zf14q8U/5yzP/KK/9H//AGLY +qyH/AJxv/wCUSt/lcf8AJ/FXsWKuxV2KuxVD6l/xzrr/AIwyf8ROKvAv+cSj/wApV/0Yf9jOKvoB +upxVrFWicVaJxV4h+fH50yaCJPK/l2amsSLTUL1DvbI4qET/AItYGtf2R79MPU6jh9I5vSdi9keL ++9yD0dB3/s+95B5J/L5tQC6rrQZ4JgJLe2JPKXlv6krdeJ6qK1br0+1zGu7S8P0w3l937Xryeg5P +W7GwRESONFSNAFjjQBVVR0CqKAD2GaCUpTNyNlxpzA5Jlr3ky01XQTYapDytrj4gw2kikH2HQkfC +wH8QdiRncdk9ncOmqW0pG/c8jqe1JQ1PHjO0dvIvF/L+u6/+Vvm19PvuUmnyMryqlaPGTRLiCtPi +FKHxoVPTaeHMcciO40XoNTpsfaGATjtLp+o/jzfVXlnzJY67psN3bSrKJUEiOvR1P7Q/iOxzbRkC +LDw2XHKEjGQqQTgnCwaJxVrFWsVaJxVonFWsVaxVonFWicVaxVrFWicVXwf38f8ArL+vFXiX/OWp +/wCUV/6P/wDsWxVkX/ONv/KI23yuf+T+KvY8VdirsVdiqH1L/jnXX/GGT/iJxV4D/wA4kGv+K/8A +t3/9jOKvoFvtH54qtJxVonFWMfmT5vXyj5M1LWwA1xDGEs4z0aeUhI6juAzcm9gcryz4YkuZ2fpf +HzRh0PP3PkvyBob+ZPMFzqWpt9aS3YT3Pq0czTzMSvME7glWZutaUPXOY7R1RxQ2+qX4t9GkBECI +2H6HtlraEmp3J3JOcsBbjZMjItDtrU3a+oQWT4lQ9GI7Z1HY/YxmRlyD0dB3/s+/3PM9p9p1cIHf +qe5mUsMV5CSAC1KMh751s5iIsvOAW87/ADA8gadr+mtY3i8WXk1hegVkglI/FTQc16MPAgEeXajX +ZtNq5ZpbwyHcfo946PXdn5/DiBHp073j/kXzlrX5ceZZNB1rktgJfiZakRM2wnjJA5RuPtDw361B +7fQ62MoiUTcJOX2n2fHVw8SH94Pt8i+qNH1i11SzS4gdW5KGPA8lIYVDKR1U9jm5BeHlEg0eaOxQ +1irROKtE4q1irWKtE4q0TirWKtYq0TirROKr4P7+P/XX9eKvEv8AnLc0/wAKf9vD/sWxVkf/ADjX +/wAofbfK5/5P4q9jxV2KuxV2KofUv+Oddf8AGGT/AIicVfP/APziMa/4r/7d/wD2M4q+gm+0fniq +0nFWsVedfn15Y1LzF+Xlzb6chlurOaO8WAbtIsQZWVffi5I+WUamBlDZ2vYupjh1AMuRFPn78qPM +lrYm40e4iIuJpDNCxNAxChWjpTZhxqPHfw35/P2fHUyAMuCvK/1PXdpZp4o+JEcUevf7/c9Xt9Qk +moFURr4Dc/fm30Xs/gwnil65efL5frt43Vdq5cuw9I8v1ptbB6rwryG4I7ZstXq8WngZ5JCMR3/j +d1+PHKZqIssu0fUGZQrn9+o+LwYZwp9pBq8hEPTGPIHr5/s6O1/I+HHfcpndWsN3CSBWv2l/z75b +qtNDUQJq+8fjqxx5DAvKfzN/LO08x2fAkQapbqTp98QeJHUxTUqSh+9TuO6tzej1U+z8vBPfDL8X +7+96HR6wjccuoed/lX+Y+p+TtZPlrzCWtoIpDHE02wt3O5R/GJ67GtB16bj0PSaoUN7ieRYdr9mD +PHxsX1df6X7Q+oLC/hvbdZoj7MvcHwzaPGognFWicVaxVrFWicVaJxVrFWsVaJxVonFWsVX2/wDv +RF/rr+vFXiP/ADlyaf4U/wC3h/2LYqyT/nGr/lDrb5XP/URir2TFXYq7FXYqh9S/4511/wAYZP8A +iJxV8+/84hn/AJSz/t3/APYzir6Dc/Efniq3FWsVWnf5Yq+d/wA+PydeGWTzf5ahKnl6mpWkIPIP +Wvrx07/zU+fXrg6nT/xB6rsTtblhynb+E/o/V8kF+VXnTStfC6bqf7rW0X4BXilyqipZAOjgCrL9 +K7VC6HtjtPXYcXFhIqPPaz79/wBSdb2Ljxz4gPQfs8vd3fLuvqaRJGKIoUe2ebavX5tRLiyzMz5/ +o7lx44wFRFLlLIwZTRhuCMx4TMSCNiGZF7FP9M1H1BXpIPtr4+4zs+yu0+Mf0hzH6XW6jBXuRd9Z +Q3UJIFVO5p1B8R75s9do4ajGSOR/FtGHKYF41+bP5W/p+3N3Yqkeu2y/umPwrcxiv7pmNArfyMfk +djVdJ2br5aLJ4OX+7PI937O/uei0WsEf6v3Md/Jr81b3S75PLGvM0c0bfV7V56q3JW4/VpeW6sDs +len2fDPQ9LqOh+Dhds9lgjxsXvIH3j9PzfSFtdQ3MCzRGqt94Pgcz3lVTFWsVaJxVonFWsVaxVon +FWicVaxVrFV9uf8ASIv9df14q8Q/5y8P/KJ/9vD/ALFsVZL/AM40f8oba/K5/wCojFXsuKuxV2Ku +xVD6l/xzrr/jDJ/xE4q+fP8AnEE/8pZ/27/+xnFX0G/2j8ziq3FWsVaJxVZIiOjI6hkYEMp3BB6g +4q+Yvzr/ACku/K+of4r8sq8enGQSzRw1DWsla81p+wT93yzXanT16hyex7H7UGWPg5dz0vr5Hz+9 +l35Z/mFaeatMEM7LHrVqg+t2/Tmo29aPxUnr/Kdj1Unzbt3sbwScuMfuzzHd+z7vcy1OnOGVfwnk +f0Hz+/5s0IzmGm243eNw6GjL0OW4ssschKPMLIAiiyDTtQWReQ6/7sTw9xnb9l9piYsfEOrz4KVd +R0+K5hLDodwR2PjmV2l2fDPCxy+78dWGDMYF4X+cX5Wzamr61pMBOs261ubeMfFdRrQBkp1kQDYd +WGw3AB13ZHaUsE/y+fl/Cf0e7u7uT0mi1YGx+k/Yu/JL83pLgx6Hq8pa+ReMMjH/AHoRR3J/3ao/ +4Ie+eg6fPfpPN0/bPZXhk5cY9HUd37Pue+xTRzRrLGwZGFVYZlvOricVaJxVrFWsVaJxVonFWsVa +xVonFV9v/vRF/rr+vFXiH/OXx/5RP/t4f9i2Ksl/5xn/AOUMtflc/wDURir2bFXYq7FXYqh9S/45 +11/xhk/4icVfPX/OH5r/AIt/7d//AGNYq+hH+23zOKrcVaJxVrFWsVUbq2t7u3ktrmNZYJlKSxuK +qynqCMUgkGw+VPzW/LbV/wAvNfj8xeXnkj0ppfUt7iPrbSMT+6bqCjVoK7EfCffVarTAXtcS9r2X +2jHVQ8LL9f8AuvP3/wBoeofl/wCeLHzboy3KFY9QgAS/tQd0c9CK78XpVfu6g55j232OdNLjh/dH +7PL3d32+dObFLFPhPwPf+3vZORmga7XQyyQyB0NCPxHgcvwZ5YpCUeaJREhRZDYXySIGH2T9te4O +d32b2jGcbHLqO51ebCQWtT02OePkvzVvD+zB2r2ZHLGx8D3fsTp85iXz3+cn5aTQyzea9EjMN3A3 +ranBF8P2fiN0lKUYUq9Ov2v5iYdi9rSEvy+baY+k9/l+rvek0epBHAd4nl+r8e5lP5L/AJuLrFuN +M1RwupQj96NgJVH+7Y18R+2o+Y8B3eDPxCjzed7W7MOCXHD+7P2fjo9oV1ZQykFWFQR0IOZLpXYq +1irROKtE4q1irWKtE4q1iq+2/wB6Iv8AXX9eKvD/APnMA0/wl/28P+xXFWTf84y/8oXafK5/6iMV +ez4q7FXYq7FUPqX/ABzrr/jDJ/xE4q+eP+cPTX/Fv/bu/wCxrFX0K/22+ZxVaTirWKtYq0TirROK +oPVdLsNV0+fT7+Fbi0uFKSxOAQQfngIvYsoTMSJRNEPlHzr5S8yflN5ui1TSJGbTJWItJ2+JHQ7t +bzgEV6fxBBFc0+r0kSDGQuEnuNFrIa3Fwz+sc/8Aih+PseyeTvOOneaNFi1K0+BvsXNsTVopQAWQ +mgqN9jTcfdnmHa/ZEtLOxvjPI/oP43+biZMRhLhlz+8d/wCOSfBlOaWmFK1vO8EgdOn7Q7EZk6XV +Swz4o/HzYTgJCiyGyvI5Iwa1jbqD2Pvne9n6+M4f0D9jq8uIg+ahqmmCQB02cfYb+BzF7W7L4xxR ++ocj+j9TZp9RWxfNv5qfl1deWb//ABb5YBtIYZBJd28VB9WlJp6kQ6ekxNCnRe3wmi5XYnbByfus +m2aP21+nv+b0mnzxyx8Oe4P2/j8bvTfyh/Naz8xaeLe6ZYb+EAXNvX7J6eqlf91sf+BP3ntsOYTH +m8r2n2dLTz23geR/Q9TrXfLnWNE4q0TirWKtYq0TirWKtYqvtv8AemL/AF1/Xirw7/nMI0/wl/28 +f+xXFWUf84x/8oVafK5/6iMVez4q7FXYq7FUPqX/ABzrr/jDJ/xE4q+d/wDnDo/8pd/27v8AsaxV +9CyH42+ZxVbirWKtE4q0TirWKtYqlXmXy5pXmPR7jSdThE1rcLxNeqnsynsR45GURIUW3DmlimJx +NEPlbU9P80flB5zPEG4024+yGNI7q3B6EgfDInZqbHxBIOk1uijOJhMXEvb6fPj12K+U4/Yf1F7Z +5e8yabrulQ6np0hktph0YUdHH2o5F3oy9/vFQQc8x7T7MnpcnCd4nke/9rimBBMZfUPx8k2SfNWY +sTBF2d8YJOQ3U/aXxzK0erlgnY5dQ0ZcPEGSWl1HLGBXlG3Q+Htne6LWRyQA5wLqcuMg+aB1nSI5 +43BRXDqVZGAKupFCrA7GozWdrdmSvxMe0xyP469zkabUVsXzJ598j6r+XutxeZfLbOulep9glmNs +7HeCWpq8T9FY7/stvRm2/YnbH5gVL05o8x3+f63ooThqIHHk3v7fP3vbPyu/MnT/ADPpMZDenMlE +mgY7xSU+yT3U/sN/mOwxZRMW8frtFLTz4Ty6HvegE5Y4TWKtYq0TirWKtYq1iq+2P+kxf66/rxV4 +d/zmKf8AlEf+3j/2K4qyj/nGL/lCbT5XX/URir2jFXYq7FXYqh9S/wCOddf8YZP+InFXzr/zhwf+ +Uv8A+3d/2NYq+hpPtt8ziq3FWicVaJxVrFWsVaJxVonFWP8AnbyZpHm7QptK1JNm+KCcfbikH2WU +5CcBIUXI0upngmJw5vmCxuvMX5T+b59M1SJptOmI+sInSWIfZnhJ25rXpX2PY5oNfoI5YnHMbfjc +PbRnDV4xOG0x9nkfL+17fp2q2V/Zw31jOtxZ3C84Jk6MvTvuCCKEHcHY755rrtDPT5DCXwPeGiO/ +MURzCNSf3zBMUGCP0/U2t3od4m+0v8RmZodYcEv6B5/rcXNp+IebKbW6jmjCkhkYfA2d1pdRHJHh +O4PIumyYzE2lXmLQLW+tZ7e4hWaC4Ro54W6SIwoRt3pmk7T7PniyDNi2nHf3/j7XK02or8cnzF5l +8va/+VvmmPVtKLTaJcMVgkapVlO7W1xTo4pVT+0ByG4YL0fY3a8dRDiG0x9Q/HR38hDVYzCfP8bh +9C/l9580zzPpENxby8uXw0enNXHWOQfzD8RvnUwmJCw8ZqtLPBMwl/ay7JuM0TirWKtYq1irROKq +lt/vTF/rr+vFXhn/ADmOf+UQ/wC3j/2K4qyn/nGD/lB7P5XX/UTir2nFXYq7FXYqh9S/4511/wAY +ZP8AiJxV85/84bGv+L/+3d/2NYq+iJP7xvmcVWE4q0TirWKtYq0TirROKtYq1irEPzJ/LzS/Ouhv +Z3AEV9EC1jd03jkp38VPcZXlxiYouZodbPTz4o8uo73zh5W17Vvy68y3Pl7zDG8envJ/pCgEiNzR +VuYtqspAo1Oo9xTOd7R7OjngYT59D3PZkxzwGXFz+/8Aon8be57ZFco6JJG6yRSKHilQhkdGFVZW +GxBG4Oec6nSzwzMJjcMIESFhXSf3zFMUGCaaXqxt34SGsLf8KfHNhoNacJ4ZfQfscPUabiFjmy23 +uUnjEbmtRVG8c7fDljljwy+BdJPGYmwx7zZ5asdU0+5sr2AT2lyvG4hP7QrUMpHRlIrUdDnPa3SZ +NNl8fD9Q5+Y/HP8AW52l1HL7HzS6+Yfym83ru1zpF38SOPhS4hU9uoWaLluO1f5WFet7K7TjngJw ++I7vx0dxqMENXjo7SH2fsL6X8n+btO8xaXBdWswlWVOSOOrAdQR2dejDOhjISFh4rNhlikYyFEMg +yTU1irWKtE4q1iqpa/70xf66/rxV4X/zmSaf4Q/7eP8A2K4qyr/nF/8A5Qaz+V1/1E4q9qxV2Kux +V2KofUv+Oddf8YZP+InFXzl/zhoa/wCMP+3d/wBjWKvoiT+8b5n9eKrCcVaxVrFWicVaJxVrFWsV +aJxVonFWAfm1+V1j510gtEFh1u1UmzuSOvcxvTs2U5sQmPN2PZ3aEtPO+cDzDwbyD5vv/K2qyeVv +MnK2s1kKIZtvqkxJJ3/31ITv2B+IftV5rtPs2OojR2mOR/HR6+dSAy4975+Y/WP2e7sPqMjFW2Iz +gM2CWORjIVIMokSFjkqpP75QYoME40fWfQYQzN+6J+Fv5T/TNp2drvDPBL6fucDVaXi3HNmEMyXM +fpuaOPsnxzsYSGaPDLm6KUDA2OTCfzD8nWes6Df2VzErRtG8kZYf3M6IxjmSm/wnw6io6EjNHDSZ +NNqRPH9Mj6h5d7tdFqLIHX8bPA/yY8z3eh+Y59HuGeOK4LERmtY7mHqQOx4g8vGgzuNLOjXe2du6 +cTxDIOcfuL6k0fU0v7USbeotA9Ohr0I+ebB5FHYq0TirWKtYqqWv+9UP+uv68VeF/wDOZZp/g/8A +7eP/AGK4qyr/AJxd/wCUFs/ldf8AUTir2vFXYq7FXYqh9S/4511/xhk/4icVfOH/ADhia/4w/wC3 +b/2NYq+iZT+8b5n9eKrMVaxVonFWicVaxVrFWicVaJxVrFWsVeWfnR+Ulv5ssG1XTI1j1+1QlSBT +6wij+7b3/lOY+fDxCxzdt2X2kcEuGX92fs83kv5c+e7m1nTyr5hYxGFvQ0+5m2eJwaC2lr+xXZCf +s9Ps048x2p2YM8bG2SP2+RerkBH95DeJ5/8AFD9Pf7+fT+boxVgQymhB6gjOGnjMSQRRDkCpCxyK +qk+VmLEwT/Q9c9Nlt5noP91SE9D4H2zb9na4xIhI+4us1mkv1D4ppqdy+tXUGiwL3EmoTDokSmvH +5tnWwHjECveXCwQGnic0vdEd5/Y+b/zp0N/J/wCa0moWqFLW9dNTtlGwJdv3yV95Fb6DmzPplYc7 +QZBqNNwy84l7d+Xmrxy8FR+UMyj02HQq45Ic2gNi3jJwMZGJ5hn5OFi1irWKtYqqWp/0qH/XX9Yx +V4V/zmcaf4P/AO3l/wBiuKsr/wCcXP8AlBLL5XX/AFE4q9sxV2KuxV2KofUv+Oddf8YZP+InFXzf +/wA4Xmv+Mf8At2/9jWKvomX+8f5n9eKrMVaJxVonFWsVaxVonFWicVaxVrFWicVaJxV4t+eP5PLr +UMnmPQYQNWiWt5bIAPrCj9r/AFwPvzFz4OLcc3edk9p+EfDmfQfs/Ywv8tvzA/SSxeXtaYrq0Q9O +xu3/AN3hf90yk9JV/ZY/a6H4qcuU7W7L8YccP7wfb+3u+Xc9IR4J4h/dnn/R8x5d/dz72frG7EhQ +aru3sPE+GcfHHKRoCy5RkEdpunXd7MI7YBiDR5m/uk+n9o/575vdB2OSbn8unxcXU6mGIXL5dT+p +6JoOmWmmWxiiq8kh5Tzt9uRvE/wzstPjjAUHkdZqp5pWeQ5DueX/APOT3lb9I+TbbXYUrcaNMPVY +Df6vcEI3Twk4H78syDZzexM/DkMDyl94Yb+TmvPLpFoC/wC9tHNsxP8Ak0eL8CBmVppXH3ON21g4 +M5PSW76DhmWaFJV+y6hh9IzIdSuxVrFWicVVLX/eqH/XX9YxV4V/zmgaf4O/7eX/AGK4qyz/AJxa +/wCUDsvldf8AUScVe2Yq7FXYq7FUPqX/ABzrr/jDJ/xE4q+bf+cLTX/GP/bt/wCxrFX0VL/ev/rH +9eKrCcVaJxVrFWsVaJxVonFWsVaxVonFWicVaxVo74q8F/Or8k5by5fzF5ZhUTSVa/sRRQTSvqJ2 +BP7Vdu+YmfT3vF6DsvtcYxwZPp6Hu/Y8z078w/O3lu9S31pJNQiiP+8uoF2ald/Tlrypttuy+2az +Jpo3uKL0UTHJD93Kr6int3kj85vJmuCO09UaTemgW0ueKKT4RyD4G9gaE+GARMXn9XoMsSZH1eb0 +yC498thN1UosQ/OLz35a0DyZfWWrD61catby21rpyMBJJzUqXrvwVK15U69N8zcOM5Nujjz1XgET +/iB2fOf5VambLX7jTy443KcomFfikhPJSvzQscGnPDMxL0na4GbTxyx8j8JfgPqjytei50xd907e +zbj8a5nPLJvirROKtYqqWv8AvVD/AK6/rGKvCf8AnNI0/wAHf9vL/sVxVlv/ADix/wAoFY/K6/6i +Tir23FXYq7FXYqh9S/4511/xhk/4icVfNf8AzhWf+Uy/7dv/AGN4q+i5T+9f/WP68VWE4q1irWKt +E4q0TirWKtYq0TirROKtYq1irROKtHFWGeavy30fW0k9S3jkVqt6bAAhj3Unb78jKIPNtw554zcC +QXiHm38h720keTSXIpU/Vpq9P8k7n/iWYs9L/Nd/pe3jyyj4j9SRaL+Yv5leRD9RmZ3tACkdregy +xrtt6T1qvH+UNTxGYksfCdw7GeDBqomUCL7x+kMO1rVNX1/UpdS1C8e/vpz8bSbP2oqoPhCitFVP +uGbXBqMdUPS8V2j2JqcRMj+8j3j9I6fc1peoyWGoWGpLXnbSKJAD8TCMio9gYzx+/MbVR4MgkOrv +/Z/MM+klhPOO3wPL7bfV/wCX+pKzCIMGRxRSOhDfEp/XmWC6GUSDRZ2TihrFWsVVLT/euH/jIv6x +irwj/nNQ/wDKG/8Aby/7FMVZd/ziv/ygNj8rr/qKOKvbsVdirsVdiqH1L/jnXX/GGT/iJxV80/8A +OFBr/jL/ALdv/Y3ir6MmP71/9Y/rxVZirWKtE4q0TirWKtYq0TirROKtYq1irROKtYq1irWKqc0M +MyGOVA6HsRXFWMa/5B0jVIXR4kdXFDHKKinhy6/fXAQDzZwySgbiaLxjzh+QZiZ5tKZrdzUiB94y +dzsf6H6Mxp6UHk7vS9uTjtkHEO/q8r1vy75k0ovb39rII0IZpgvJaLVVJelQKdA2Y8xMCjydxpZ6 +aczkx0Jy59D8R+l7H+T2vNNo9i3KsttW2fsAYqGP/hOOZmnlcXnO18PBnPdLf8fF73HIskayL9lw +GX5EVy51jeKtYqqWh/0uH/jIv6xirwf/AJzXNP8ABv8A28v+xTFWX/8AOKv/AJL+x+V3/wBRRxV7 +firsVdirsVQ+pf8AHOuv+MMn/ETir5o/5wmNf8Z/9u3/ALG8VfRs396/+sf14qp4q0TirROKtYq1 +irROKtE4q1irWKtE4q1irWKtYq0TirWKtYqskRJFKuoZT1UioxVI9V8o6ZfIQEUH+VxyX6O6/Rir +EW8gNpk0k1lEYjI4kbiOalhtUkfF274AAGc8kpVZJpnukpLHYRLIQSBVSO6ncdfnhYIvFWicVVbT +/euD/jIv/Ehirwb/AJzZNP8ABn/by/7FMVZf/wA4qf8AkvrD5Xf/AFFHFXuGKuxV2KuxVD6l/wAc +66/4wyf8ROKvmb/nCQ/8pn/27P8AsbxV9HTf3z/6x/XiqmTirROKtYq1irROKtE4q1irWKtE4q1i +rWKtYq0TirWKtYq1irROKtYq1irWKtE4q1iqrZ/71wf8ZF/4kMVeC/8AObZ/5Qz/ALef/YpirMP+ +cUv/ACXth8rv/qKOKvccVdirsVdiqH1L/jnXX/GGT/iJxV8y/wDOER/5TT/t2f8AY3ir6OnP75/9 +Y/rxVTJxVrFWsVaJxVonFWsVaxVonFWsVaxVrFWicVaxVrFWsVaJxVrFWsVaxVonFWsVaxVVs/8A +eyD/AIyL/wASGKvBf+c3T/yhf/bz/wCxTFWY/wDOKH/kvLD5Xf8A1FHFXuOKuxV2KuxVD6l/xzrr +/jDJ/wAROKvmP/nB81/xp/27P+xvFX0fOf30n+sf14qp4q1irROKtE4q1irWKtE4q1irWKtYq0Ti +rWKtYq1irROKtYq1irWKtE4q1irWKtYqq2Z/0yD/AIyJ/wASGKvBP+c4DT/Bf/bz/wCxTFWZf84n +/wDku9P+V3/1FHFXuWKuxV2KuxVD6l/xzrr/AIwyf8ROKvmD/nCCRUn86W7njORpzCM7NRDdBtvY +sK4q+kbiomkr/Mf14qp4q0TirROKtYq1irROKtYq1irWKtE4q1irWKtYq0TirWKtYq1irROKtYq1 +irWKtE4qrWIJvIABU81P3GuKvAP+c4ZozL5MiDAyIupOydwrG1Cn6eJxVm3/ADieGH5dafUEHjdn +fwN0SMVe5Yq7FXYq7FVskayRtG32XBVvkRTFXxjrN7rf5Efnjca1FbNP5e1ZpDLAtFWW2mcPLGld +g8MlGT2p2JxV9U+U/PHknzvp8d/5f1SG8DrV4UcLcRnussJ+NCPcfLbFU8/R0X8zfhirv0bF/M34 +Yq1+jIv52/DFXfoyL+dvwxV36Lh/nb8MVa/RUP8AO34Yq79FQ/zt+H9MVa/RMP8AO34Yq79Ew/zt ++GKu/REH87fh/TFWv0PB/O34f0xV36Hg/nb8P6Yq79DQfzt+H9MVa/QsH87fh/TFXfoWD/fj/h/T +FWv0Jb/78f8AD+mKu/Qdv/vx/wAP6Yq1+g7f/fj/AIf0xV36Ct/9+P8Ah/TFXfoK3/34/wCH9MVa +/QNv/vx/w/pirv0Bbf78f8P6Yqk3mfzh5E8iWEuoa9qcNpxUlIpHDXEngsUK/G5PsPntir4i/MXz +tr35wfmQtxa27Rxy8bTSbImvo2yEtykI2qas7n6OgGKvsf8AJ7y5HoWhW1jAP3NpbpEGIoWJp8R9 +24VPzxV6FirsVdirsVdirE/zG/Lfy/560OTTNViUvSsE9KsjjoR3+7FXyP5v/wCcW/Nuk3rpYTLL +ASfTMwYrx9pIw1fpQYqx3/oXzz942v8AwU//AFSxV3/Qvnn7xtf+Cn/6pYq7/oXzz942v/BT/wDV +LFXf9C+efvG1/wCCn/6pYq7/AKF88/eNr/wU/wD1SxV3/Qvnn7xtf+Cn/wCqWKu/6F88/eNr/wAF +P/1SxV3/AEL55+8bX/gp/wDqlirv+hfPP3ja/wDBT/8AVLFXf9C+efvG1/4Kf/qlirv+hfPP3ja/ +8FP/ANUsVd/0L55+8bX/AIKf/qlirv8AoXzz942v/BT/APVLFXf9C+efvG1/4Kf/AKpYq7/oXzz9 +42v/AAU//VLFXf8AQvnn7xtf+Cn/AOqWKu/6F88/eNr/AMFP/wBUsVd/0L55+8bX/gp/+qWKu/6F +88/eNr/wU/8A1SxV3/Qvnn7xtf8Agp/+qWKu/wChfPP3ja/8FP8A9UsVd/0L55+8bX/gp/8Aqliq +L0z/AJxz85XFwEu54IIu7xiWRv8AgWWP9eKvevys/JPTPLg/0WEz3sgHr3UtC5HWjECiJ/kjr3xV +7vpthHY2qwpuert4se+KorFXYq7FXYq7FXYqtkijlUpIgdD1VgCPxxVCnRtLJ/3mT7sVd+htL/5Z +k/HFXfobS/8AlmT8cVd+htL/AOWZPxxV36G0v/lmT8cVd+htL/5Zk/HFXfobS/8AlmT8cVd+htL/ +AOWZPxxV36G0v/lmT8cVd+htL/5Zk/HFXfobS/8AlmT8cVd+htL/AOWZPxxV36G0v/lmT8cVd+ht +L/5Zk/HFXfobS/8AlmT8cVd+htL/AOWZPxxV36G0v/lmT8cVd+htL/5Zk/HFXfobS/8AlmT8cVd+ +htL/AOWZPxxV36G0v/lmT8cVd+htL/5Zk/HFXDRtLB/3mT7sVRUcUcShI0CIOiqAB+GKrsVdirsV +f//Z + + + + + + +uuid:4ee3f24b-6ed2-4a2e-8f7a-50b762c8da8b + + + +image/svg+xml + + + +mime.ai + + + + image/svg+xml + end='w' + + +Labels + \ No newline at end of file diff --git a/icons/new.png b/icons/new.png new file mode 100644 index 0000000000000000000000000000000000000000..dd795cfffc5c1ce273b3afedb5ed01da3fc5668c GIT binary patch literal 977 zcmV;?11|iDP)bWCsWYp)^2+5pE&16P)J5wbOa;T^94~jGe@$^;8|{N*-xE=iGD7yYG#t zD);gVxW`xYe;#`OHF@&p7Liq?Fv=6g5~?BqQNT@!pB*cZ>hN`{7r7 z0@PL2_61PYzIFCAKdP##I$yS{oLX(QZfdoPWw^&}T5r!d$9(p=D`Njv29iHLkmyYoqFd-sx$01C;)-KSr9NW?hA@p%q*ht6 zmBq{Ur!PNBt}Oo0xOA02fK^~?NCng%Kounf3J6mu2dGt6?ZW)I`_c{m0&2h#@Q*)+)q%|+6*xkz zvTPUT&+i3#9k}X2>%fKw-O>SHJ_8A?H#zstslxR28`z&KEbRfh;$?0CiQdK+@4!zp z5h(%3fWyEo4>%O)?GhLPrv1^{dTECO&0hZj`DhT15m$C300000NkvXXu0mjfIXk#o literal 0 HcmV?d00001 diff --git a/icons/next.png b/icons/next.png new file mode 100644 index 0000000000000000000000000000000000000000..163a343cb44010ea43ae8216396e8db82080ce04 GIT binary patch literal 30288 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

sa06TI(r5BH5U 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 literal 0 HcmV?d00001 diff --git a/icons/open.png b/icons/open.png new file mode 100644 index 0000000000000000000000000000000000000000..45fa2883a71fcb891f1ef7c0c217d71eeae284bc GIT binary patch literal 2073 zcmV+!2RP)CWtKz1rEEwa&Ubd$6s{da=&VIP1;2`BM0`Wb;D z{M-!)vd0-ix#k=pmKgFxQgYk(eOi$0QlJD2NbOI5d5567avIIj< zv@<}9dj`!tE;Q@xs8{wNhf{?zUNu9!u=J3D!C+h_ze{}K1V|htI6?j0>T@UYxhDij zhnKMl|M#(rT!AcZ}eF)wgP_d zAX10jekLr}U#(CrCA<(opAbNs2#S{v>vbjZBPMG2>Dlh2!oC#Mk@9m9Zc z2%^^3CBjkLC=!RpAFqNhVw6pZB#Q!^oqj*T-F(Vw$mLX*nO_ zNX-3DeeTpEomGUYnz~IsN92z9JUkMF)7=lf!HB}*Vw`?29z6pA^e+N~guKQ7E$%u) zC{dC3_66}y+`oN81yr%;K@{IH8|1O-3y*riL6}qGd@SEo}8X#Q_kq zZ|eG3QMpHgF(8Pc07FLLD$kpMaaUZZl&Qk=tr>Kq76&g@g}Kbh`}mD}bLg zSob6#9DIaI(-=7VVTPPm{Z+FbtPVT4Iv?2~9(pg}6TG@z0w%t}gOqRBIG>z~1AjdP zW3QR%ZYsA%*Mp?X$w>b?i;UGgQ?+sSsoXX8X`%zES@sOGBngFV;lVB@d3_10@@V;lg>dY2BN>v^RZ2^?j@k8NdQ$X;_ z_a$H}ZfeJ=gha#~If~qTHdcoJ4Lhqwh-3dbkKgY5JsSA}oWGEOlkpdDqpb%S#7{~T>2A7M zsP8QLl$cN`w?OF*Jo#7bDJpj@!Dj^fwz=d)jlRsXTKwbW85}(HH?VT^u<$rb~rBzaiB|lB=W)A?(%51dO$!?mU^ ze8O#IHd*n50bG}w!BKl4^90wps7K`#)>4RXJ_(`usyx1v$_9j`-;Pq{6K%jV&lNRO%>FPb&x$A5bBEmwG~ zsNAo;tlZJ!2;Bu-bsyf#uSL0b05WG_^}?r@soeJn(y81#_yhC8@e_i|9PXV^3ptdy z4Z_G4qZfz6FCzC2|JrSe-C>#48@AYMyIwNBFNyyFX1QPd5r93<00000NkvXXu0mjf DP*&js literal 0 HcmV?d00001 diff --git a/icons/open.svg b/icons/open.svg new file mode 100644 index 00000000..48e7a343 --- /dev/null +++ b/icons/open.svg @@ -0,0 +1,577 @@ + + +image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/icons/quit.png b/icons/quit.png new file mode 100644 index 0000000000000000000000000000000000000000..7445887949c3b817d3fd5a223747264e7a5d2ac9 GIT binary patch literal 1915 zcmV->2ZZ>EP)7r0xWIucLV^Pql7VD02xVgt4ki;@N<7Yj+ga>(r@P%<)!ntsp{lDFTXT!%lS*GL zuipP(|M$N4y%N`TIViFhm;lCsF!y&#Qq9A|B__p&?w?(uf2vIkFUmVa1!e3BHZ0gD3L(x>cX;Z z%uEI;6wp>ya8_0VwWM_pg@`}#1o_LCS?A$|bpY3OsoFNKZDaWkTEXKZBP4h2LXX8( z5$x>mugADpnDGC4`RQgv_<#Borq1RVduE*8NjAV7S0nEw6y2{nYpv2B*-=eaXC$KAO( z+9DAWLql{A57Rv`fbs!1J@N>}&6~OQ)mQXaDggo4aZpMHm>vPg0ic@CBcTvV1U(*K z1%B{p^FVt$9e`_^xQ2mi z7(^_KWT}Mp#TQ)v@=L1avPUA3VEuE?k;`VmG!fH8L;_6J6oOoir5}EvV`PMN+qVZ_ ze(IA?s9w0hV?8~DEXxBmO(FvWL~9DW$48h>$3m)D>qM^U?djvfJ-GD!yx(Wv-H3527Rx;PGQ$Bj9d=aG@(=i!@xRo zhQiED;OEhoU*_`syr)2e>Z+ClwTjk}N)b*bgM>T&!3XT@FDl+$(FwgrywUb#YeW`<}BIHrj- zRLgKIMy^nR8n|hKY2wV!Q%$D>yXb}uRMTmc2zFx#9LEW2c~=90^wbnxjzcw_##&nP zPO+9}Zqv`2Ba1p^&$>4Fh|5 z8TZ~j++xuKZ5)+K@bywEK|YV0&0<};6qx*J>sB(=DoUv!2Xp}2w$YSAYE{c0B0^l( zgWXI6#J0V!Y#CB6BZg7mko=9R#UU%U?JYw;Hxz*7hd@&bV|qHU-#9)_u|b{2?Y4C& zA5b-biwL2yvA|~W@?{d?FiHfgDFn8S_^Y7UK%jryHVU=;XxZCWDX<2(5I9~z zSs#h4R={?gpwTcI*6#XL3ahVg%?6`YgGSKWq4o8lhK2&0%*;%kKx-0;FK^}gbt>7c z_fXS#{QdVS_&Zo5iAJJ#E?pv`Y0V)}inap>g5A}~W>M)hx>BnPk!9O;=OUz!9u1ri z@7|5EZ(q>;)a**1ea5XHf8^%*^PE3+jFGmsCh+jyz3AiPfuD1S4lx#wd&-Gm`61A2 z3aDCNCqn7;X%8ZzADf*&O+H~D(UN&r? z{lgE5z4<088U>)VxX8~(j_{Xc(gSZHpw~hW4Tqaz?B;UZeeXSbCMIa>=>edB_imh> zJ1JhfM&-&Ct$x zlbxL?*G2r+xh7d{?{oaWBFA-!Dn*-L*~Gsmu3HDJo%{Z5+h%@ok*f;}+%6OVrgUK9 zW`G5bO{};v9J({rdYv=#~002ovPDHLkV1jg; Bou>c* literal 0 HcmV?d00001 diff --git a/icons/save-as.png b/icons/save-as.png new file mode 100644 index 0000000000000000000000000000000000000000..1b5d900064c79dac15ee24d0a33b22f3245aa222 GIT binary patch literal 2811 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 N002ovPDHLkV1ka2D6Ieh literal 0 HcmV?d00001 diff --git a/icons/save-as.svg b/icons/save-as.svg new file mode 100644 index 00000000..c8441a1f --- /dev/null +++ b/icons/save-as.svg @@ -0,0 +1,1358 @@ + + + + + + + + + + + + + + + + + + + + +begin='' id='W5M0MpCehiHzreSzNTczkc9d' + + + + +Adobe PDF library 5.00 + + + + + +2004-01-26T11:58:28+02:00 + +2004-03-28T20:41:40Z + +Adobe Illustrator 10.0 + +2004-02-16T23:58:32+01:00 + + + + +JPEG + +256 + +256 + +/9j/4AAQSkZJRgABAgEASABIAAD/7QAsUGhvdG9zaG9wIDMuMAA4QklNA+0AAAAAABAASAAAAAEA +AQBIAAAAAQAB/+4ADkFkb2JlAGTAAAAAAf/bAIQABgQEBAUEBgUFBgkGBQYJCwgGBggLDAoKCwoK +DBAMDAwMDAwQDA4PEA8ODBMTFBQTExwbGxscHx8fHx8fHx8fHwEHBwcNDA0YEBAYGhURFRofHx8f +Hx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8f/8AAEQgBAAEAAwER +AAIRAQMRAf/EAaIAAAAHAQEBAQEAAAAAAAAAAAQFAwIGAQAHCAkKCwEAAgIDAQEBAQEAAAAAAAAA +AQACAwQFBgcICQoLEAACAQMDAgQCBgcDBAIGAnMBAgMRBAAFIRIxQVEGE2EicYEUMpGhBxWxQiPB +UtHhMxZi8CRygvElQzRTkqKyY3PCNUQnk6OzNhdUZHTD0uIIJoMJChgZhJRFRqS0VtNVKBry4/PE +1OT0ZXWFlaW1xdXl9WZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo+Ck5SVlpeYmZ +qbnJ2en5KjpKWmp6ipqqusra6voRAAICAQIDBQUEBQYECAMDbQEAAhEDBCESMUEFURNhIgZxgZEy +obHwFMHR4SNCFVJicvEzJDRDghaSUyWiY7LCB3PSNeJEgxdUkwgJChgZJjZFGidkdFU38qOzwygp +0+PzhJSktMTU5PRldYWVpbXF1eX1RlZmdoaWprbG1ub2R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo ++DlJWWl5iZmpucnZ6fkqOkpaanqKmqq6ytrq+v/aAAwDAQACEQMRAD8A9U4q7FXYq7FXYq7FXYq7 +FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqlvmDzFo +3l7TJdT1e5W1tItuTbszHoiKN2Y+AxV4j5g/5ydvTcMnl/SYlgU0Se/LOzDxMcTIF/4M4qk//QzP +nv8A5YNL/wCRVx/2UYq7/oZnz3/ywaX/AMirj/soxV3/AEMz57/5YNL/AORVx/2UYq7/AKGZ89/8 +sGl/8irj/soxV3/QzPnv/lg0v/kVcf8AZRirv+hmfPf/ACwaX/yKuP8AsoxV3/QzPnv/AJYNL/5F +XH/ZRirv+hmfPf8AywaX/wAirj/soxV3/QzPnv8A5YNL/wCRVx/2UYq7/oZnz3/ywaX/AMirj/so +xV3/AEMz57/5YNL/AORVx/2UYq7/AKGZ89/8sGl/8irj/soxV3/QzPnv/lg0v/kVcf8AZRirv+hm +fPf/ACwaX/yKuP8AsoxV3/QzPnv/AJYNL/5FXH/ZRirv+hmfPf8AywaX/wAirj/soxV3/QzPnv8A +5YNL/wCRVx/2UYq7/oZnz3/ywaX/AMirj/soxV3/AEMz57/5YNL/AORVx/2UYq7/AKGZ89/8sGl/ +8irj/soxV3/QzPnv/lg0v/kVcf8AZRirv+hmfPf/ACwaX/yKuP8AsoxVFad/zk75oS4B1HSbG4t+ +6W/qwP8A8E7zj/hcVeyeRfzJ8tec7Vn0yUx3kQBuLCaizJ25AAkMlf2l+mmKsqxV2KuxV2KuxV2K +vm/XDqf5ufmk+j287Q+XtJLqJF3VIY2CSzAHYvM9AvtTwOKvePLfk/y35bs0tdHsYrZVFGlCgyuf +GSQ/Ex+ZxVOK4q6oxVrkMVdyGKu5jFWvUGKu9RffFWvVX3xV3rL74q71l8DirXrp4HFXfWE8DirX +1hPA4q76yngcVd9Zj8D+GKtfWo/A/hirvrcfgfw/rirvrcfgfw/rirX1yLwb8P64q765F4N+H9cV +d9di8G/D+uKtfXovBvw/riqVa/5X8r+abR7TV7GO55CiyMoWZP8AKjkHxKR7HFXzB5n0XXfys8/R +NZXBJgIudOujsJYGJUpIB8ijj+oxV9VeWtfs/MGhWWsWf9xexLKErUoxHxI3up2OKplirsVdirsV +Q+oMy2Fyy/aWJyvzCnFXhP8AziwqvL5nmYcpQLIBz1oxuC2/uVGKvficVaxVrFWicVaJxVrFWsVa +JxVonFWsVaxVrFWicVaxVrFWicVaJxVrFWsVaJxVonFWsVaxVdCSJkp/MP14q8V/5ypRBJ5ZkCjm +wvVZu5CmAgfRyOKsn/5x3vJX8lwWzElQZmSvbjMR/wAbYq9XxV2KuxV2KofUv+Oddf8AGGT/AIic +VeE/84pn/lKP+jD/ALGcVe+nFWsVaJxVonFWsVaxVonFWicVaxVrFWsVaJxVrFWsVaJxVonFWsVa +xVonFWicVaxVrFWicVXQ/wB9H/rD9eKvFv8AnKw/8ov/ANH/AP2LYqn/APzjn/yisHyuP+T4xV6/ +irsVdirsVQ+pf8c66/4wyf8AETirwf8A5xRNf8U/9GH/AGM4q9+PXFWicVaJxVrFWsVaJxVonFWs +VaxVrFWicVaxVrFWicVaJxVrFWsVaJxVonFWsVaxVonFWicVXQ/30f8ArD9eKvFf+crjT/C3/R// +ANi2Ksg/5xy/5RS3+Vx/yfGKvYMVdirsVdiqH1L/AI511/xhk/4icVeDf84nmv8Ain/ow/7GcVe/ +HrirROKtYq1irROKtE4q1irWKtYq0TirWKtYq0TirROKtYq1irROKtE4q1irWKtE4q0TirWKroP7 ++P8A1h+vFXiv/OWBp/hb/o//AOxbFWQf844f8onb/K4/5PjFXsOKuxV2KuxVD6l/xzrr/jDJ/wAR +OKvBP+cTD/ylX/Rh/wBjOKvf2O5xVrFWsVaJxVonFXln5ofnxoPk9pNM05V1XX1qrwK1IYD/AMXO +v7X+Qu/iRmNm1IhsNy7vs7sWef1S9MPtPu/W+fdS81/mp5+uWaS6urm3ZivoQH6vZoaV4mhSKtP5 +zXNXn1dbzlT1uDQ6fAPTEX8z+tX8r+Z/Pf5Xa5azXMUo0+evrac8oe3njGz8GQugkWoNRuNq7GhO +m1Q5xNhhrNHh1cDH+Ideo/Y+q/KfnXRfM+nw3umyVinXkgPXbZlPgynqM3UJiQsPAajTzwzMJiiE ++yTS1irROKtE4q1irWKtE4q0TirWKtYq0TirROKtYq1iq6A/v4/9Zf14q8U/5yzP/KK/9H//AGLY +qyH/AJxv/wCUSt/lcf8AJ/FXsWKuxV2KuxVD6l/xzrr/AIwyf8ROKvAv+cSj/wApV/0Yf9jOKvoB +upxVrFWicVaJxV4h+fH50yaCJPK/l2amsSLTUL1DvbI4qET/AItYGtf2R79MPU6jh9I5vSdi9keL ++9yD0dB3/s+95B5J/L5tQC6rrQZ4JgJLe2JPKXlv6krdeJ6qK1br0+1zGu7S8P0w3l937Xryeg5P +W7GwRESONFSNAFjjQBVVR0CqKAD2GaCUpTNyNlxpzA5Jlr3ky01XQTYapDytrj4gw2kikH2HQkfC +wH8QdiRncdk9ncOmqW0pG/c8jqe1JQ1PHjO0dvIvF/L+u6/+Vvm19PvuUmnyMryqlaPGTRLiCtPi +FKHxoVPTaeHMcciO40XoNTpsfaGATjtLp+o/jzfVXlnzJY67psN3bSrKJUEiOvR1P7Q/iOxzbRkC +LDw2XHKEjGQqQTgnCwaJxVrFWsVaJxVonFWsVaxVonFWicVaxVrFWicVXwf38f8ArL+vFXiX/OWp +/wCUV/6P/wDsWxVkX/ONv/KI23yuf+T+KvY8VdirsVdiqH1L/jnXX/GGT/iJxV4D/wA4kGv+K/8A +t3/9jOKvoFvtH54qtJxVonFWMfmT5vXyj5M1LWwA1xDGEs4z0aeUhI6juAzcm9gcryz4YkuZ2fpf +HzRh0PP3PkvyBob+ZPMFzqWpt9aS3YT3Pq0czTzMSvME7glWZutaUPXOY7R1RxQ2+qX4t9GkBECI +2H6HtlraEmp3J3JOcsBbjZMjItDtrU3a+oQWT4lQ9GI7Z1HY/YxmRlyD0dB3/s+/3PM9p9p1cIHf +qe5mUsMV5CSAC1KMh751s5iIsvOAW87/ADA8gadr+mtY3i8WXk1hegVkglI/FTQc16MPAgEeXajX +ZtNq5ZpbwyHcfo946PXdn5/DiBHp073j/kXzlrX5ceZZNB1rktgJfiZakRM2wnjJA5RuPtDw361B +7fQ62MoiUTcJOX2n2fHVw8SH94Pt8i+qNH1i11SzS4gdW5KGPA8lIYVDKR1U9jm5BeHlEg0eaOxQ +1irROKtE4q1irWKtE4q0TirWKtYq0TirROKr4P7+P/XX9eKvEv8AnLc0/wAKf9vD/sWxVkf/ADjX +/wAofbfK5/5P4q9jxV2KuxV2KofUv+Oddf8AGGT/AIicVfP/APziMa/4r/7d/wD2M4q+gm+0fniq +0nFWsVedfn15Y1LzF+Xlzb6chlurOaO8WAbtIsQZWVffi5I+WUamBlDZ2vYupjh1AMuRFPn78qPM +lrYm40e4iIuJpDNCxNAxChWjpTZhxqPHfw35/P2fHUyAMuCvK/1PXdpZp4o+JEcUevf7/c9Xt9Qk +moFURr4Dc/fm30Xs/gwnil65efL5frt43Vdq5cuw9I8v1ptbB6rwryG4I7ZstXq8WngZ5JCMR3/j +d1+PHKZqIssu0fUGZQrn9+o+LwYZwp9pBq8hEPTGPIHr5/s6O1/I+HHfcpndWsN3CSBWv2l/z75b +qtNDUQJq+8fjqxx5DAvKfzN/LO08x2fAkQapbqTp98QeJHUxTUqSh+9TuO6tzej1U+z8vBPfDL8X +7+96HR6wjccuoed/lX+Y+p+TtZPlrzCWtoIpDHE02wt3O5R/GJ67GtB16bj0PSaoUN7ieRYdr9mD +PHxsX1df6X7Q+oLC/hvbdZoj7MvcHwzaPGognFWicVaxVrFWicVaJxVrFWsVaJxVonFWsVX2/wDv +RF/rr+vFXiP/ADlyaf4U/wC3h/2LYqyT/nGr/lDrb5XP/URir2TFXYq7FXYqh9S/4511/wAYZP8A +iJxV8+/84hn/AJSz/t3/APYzir6Dc/Efniq3FWsVWnf5Yq+d/wA+PydeGWTzf5ahKnl6mpWkIPIP +Wvrx07/zU+fXrg6nT/xB6rsTtblhynb+E/o/V8kF+VXnTStfC6bqf7rW0X4BXilyqipZAOjgCrL9 +K7VC6HtjtPXYcXFhIqPPaz79/wBSdb2Ljxz4gPQfs8vd3fLuvqaRJGKIoUe2ebavX5tRLiyzMz5/ +o7lx44wFRFLlLIwZTRhuCMx4TMSCNiGZF7FP9M1H1BXpIPtr4+4zs+yu0+Mf0hzH6XW6jBXuRd9Z +Q3UJIFVO5p1B8R75s9do4ajGSOR/FtGHKYF41+bP5W/p+3N3Yqkeu2y/umPwrcxiv7pmNArfyMfk +djVdJ2br5aLJ4OX+7PI937O/uei0WsEf6v3Md/Jr81b3S75PLGvM0c0bfV7V56q3JW4/VpeW6sDs +len2fDPQ9LqOh+Dhds9lgjxsXvIH3j9PzfSFtdQ3MCzRGqt94Pgcz3lVTFWsVaJxVonFWsVaxVon +FWicVaxVrFV9uf8ASIv9df14q8Q/5y8P/KJ/9vD/ALFsVZL/AM40f8oba/K5/wCojFXsuKuxV2Ku +xVD6l/xzrr/jDJ/xE4q+fP8AnEE/8pZ/27/+xnFX0G/2j8ziq3FWsVaJxVZIiOjI6hkYEMp3BB6g +4q+Yvzr/ACku/K+of4r8sq8enGQSzRw1DWsla81p+wT93yzXanT16hyex7H7UGWPg5dz0vr5Hz+9 +l35Z/mFaeatMEM7LHrVqg+t2/Tmo29aPxUnr/Kdj1Unzbt3sbwScuMfuzzHd+z7vcy1OnOGVfwnk +f0Hz+/5s0IzmGm243eNw6GjL0OW4ssschKPMLIAiiyDTtQWReQ6/7sTw9xnb9l9piYsfEOrz4KVd +R0+K5hLDodwR2PjmV2l2fDPCxy+78dWGDMYF4X+cX5Wzamr61pMBOs261ubeMfFdRrQBkp1kQDYd +WGw3AB13ZHaUsE/y+fl/Cf0e7u7uT0mi1YGx+k/Yu/JL83pLgx6Hq8pa+ReMMjH/AHoRR3J/3ao/ +4Ie+eg6fPfpPN0/bPZXhk5cY9HUd37Pue+xTRzRrLGwZGFVYZlvOricVaJxVrFWsVaJxVonFWsVa +xVonFV9v/vRF/rr+vFXiH/OXx/5RP/t4f9i2Ksl/5xn/AOUMtflc/wDURir2bFXYq7FXYqh9S/45 +11/xhk/4icVfPX/OH5r/AIt/7d//AGNYq+hH+23zOKrcVaJxVrFWsVUbq2t7u3ktrmNZYJlKSxuK +qynqCMUgkGw+VPzW/LbV/wAvNfj8xeXnkj0ppfUt7iPrbSMT+6bqCjVoK7EfCffVarTAXtcS9r2X +2jHVQ8LL9f8AuvP3/wBoeofl/wCeLHzboy3KFY9QgAS/tQd0c9CK78XpVfu6g55j232OdNLjh/dH +7PL3d32+dObFLFPhPwPf+3vZORmga7XQyyQyB0NCPxHgcvwZ5YpCUeaJREhRZDYXySIGH2T9te4O +d32b2jGcbHLqO51ebCQWtT02OePkvzVvD+zB2r2ZHLGx8D3fsTp85iXz3+cn5aTQyzea9EjMN3A3 +ranBF8P2fiN0lKUYUq9Ov2v5iYdi9rSEvy+baY+k9/l+rvek0epBHAd4nl+r8e5lP5L/AJuLrFuN +M1RwupQj96NgJVH+7Y18R+2o+Y8B3eDPxCjzed7W7MOCXHD+7P2fjo9oV1ZQykFWFQR0IOZLpXYq +1irROKtE4q1irWKtE4q1iq+2/wB6Iv8AXX9eKvD/APnMA0/wl/28P+xXFWTf84y/8oXafK5/6iMV +ez4q7FXYq7FUPqX/ABzrr/jDJ/xE4q+eP+cPTX/Fv/bu/wCxrFX0K/22+ZxVaTirWKtYq0TirROK +oPVdLsNV0+fT7+Fbi0uFKSxOAQQfngIvYsoTMSJRNEPlHzr5S8yflN5ui1TSJGbTJWItJ2+JHQ7t +bzgEV6fxBBFc0+r0kSDGQuEnuNFrIa3Fwz+sc/8Aih+PseyeTvOOneaNFi1K0+BvsXNsTVopQAWQ +mgqN9jTcfdnmHa/ZEtLOxvjPI/oP43+biZMRhLhlz+8d/wCOSfBlOaWmFK1vO8EgdOn7Q7EZk6XV +Swz4o/HzYTgJCiyGyvI5Iwa1jbqD2Pvne9n6+M4f0D9jq8uIg+ahqmmCQB02cfYb+BzF7W7L4xxR ++ocj+j9TZp9RWxfNv5qfl1deWb//ABb5YBtIYZBJd28VB9WlJp6kQ6ekxNCnRe3wmi5XYnbByfus +m2aP21+nv+b0mnzxyx8Oe4P2/j8bvTfyh/Naz8xaeLe6ZYb+EAXNvX7J6eqlf91sf+BP3ntsOYTH +m8r2n2dLTz23geR/Q9TrXfLnWNE4q0TirWKtYq0TirWKtYqvtv8AemL/AF1/Xirw7/nMI0/wl/28 +f+xXFWUf84x/8oVafK5/6iMVez4q7FXYq7FUPqX/ABzrr/jDJ/xE4q+d/wDnDo/8pd/27v8AsaxV +9CyH42+ZxVbirWKtE4q0TirWKtYqlXmXy5pXmPR7jSdThE1rcLxNeqnsynsR45GURIUW3DmlimJx +NEPlbU9P80flB5zPEG4024+yGNI7q3B6EgfDInZqbHxBIOk1uijOJhMXEvb6fPj12K+U4/Yf1F7Z +5e8yabrulQ6np0hktph0YUdHH2o5F3oy9/vFQQc8x7T7MnpcnCd4nke/9rimBBMZfUPx8k2SfNWY +sTBF2d8YJOQ3U/aXxzK0erlgnY5dQ0ZcPEGSWl1HLGBXlG3Q+Htne6LWRyQA5wLqcuMg+aB1nSI5 +43BRXDqVZGAKupFCrA7GozWdrdmSvxMe0xyP469zkabUVsXzJ598j6r+XutxeZfLbOulep9glmNs +7HeCWpq8T9FY7/stvRm2/YnbH5gVL05o8x3+f63ooThqIHHk3v7fP3vbPyu/MnT/ADPpMZDenMlE +mgY7xSU+yT3U/sN/mOwxZRMW8frtFLTz4Ty6HvegE5Y4TWKtYq0TirWKtYq1iq+2P+kxf66/rxV4 +d/zmKf8AlEf+3j/2K4qyj/nGL/lCbT5XX/URir2jFXYq7FXYqh9S/wCOddf8YZP+InFXzr/zhwf+ +Uv8A+3d/2NYq+hpPtt8ziq3FWicVaJxVrFWsVaJxVonFWP8AnbyZpHm7QptK1JNm+KCcfbikH2WU +5CcBIUXI0upngmJw5vmCxuvMX5T+b59M1SJptOmI+sInSWIfZnhJ25rXpX2PY5oNfoI5YnHMbfjc +PbRnDV4xOG0x9nkfL+17fp2q2V/Zw31jOtxZ3C84Jk6MvTvuCCKEHcHY755rrtDPT5DCXwPeGiO/ +MURzCNSf3zBMUGCP0/U2t3od4m+0v8RmZodYcEv6B5/rcXNp+IebKbW6jmjCkhkYfA2d1pdRHJHh +O4PIumyYzE2lXmLQLW+tZ7e4hWaC4Ro54W6SIwoRt3pmk7T7PniyDNi2nHf3/j7XK02or8cnzF5l +8va/+VvmmPVtKLTaJcMVgkapVlO7W1xTo4pVT+0ByG4YL0fY3a8dRDiG0x9Q/HR38hDVYzCfP8bh +9C/l9580zzPpENxby8uXw0enNXHWOQfzD8RvnUwmJCw8ZqtLPBMwl/ay7JuM0TirWKtYq1irROKq +lt/vTF/rr+vFXhn/ADmOf+UQ/wC3j/2K4qyn/nGD/lB7P5XX/UTir2nFXYq7FXYqh9S/4511/wAY +ZP8AiJxV85/84bGv+L/+3d/2NYq+iJP7xvmcVWE4q0TirWKtYq0TirROKtYq1irEPzJ/LzS/Ouhv +Z3AEV9EC1jd03jkp38VPcZXlxiYouZodbPTz4o8uo73zh5W17Vvy68y3Pl7zDG8envJ/pCgEiNzR +VuYtqspAo1Oo9xTOd7R7OjngYT59D3PZkxzwGXFz+/8Aon8be57ZFco6JJG6yRSKHilQhkdGFVZW +GxBG4Oec6nSzwzMJjcMIESFhXSf3zFMUGCaaXqxt34SGsLf8KfHNhoNacJ4ZfQfscPUabiFjmy23 +uUnjEbmtRVG8c7fDljljwy+BdJPGYmwx7zZ5asdU0+5sr2AT2lyvG4hP7QrUMpHRlIrUdDnPa3SZ +NNl8fD9Q5+Y/HP8AW52l1HL7HzS6+Yfym83ru1zpF38SOPhS4hU9uoWaLluO1f5WFet7K7TjngJw ++I7vx0dxqMENXjo7SH2fsL6X8n+btO8xaXBdWswlWVOSOOrAdQR2dejDOhjISFh4rNhlikYyFEMg +yTU1irWKtE4q1iqpa/70xf66/rxV4X/zmSaf4Q/7eP8A2K4qyr/nF/8A5Qaz+V1/1E4q9qxV2Kux +V2KofUv+Oddf8YZP+InFXzl/zhoa/wCMP+3d/wBjWKvoiT+8b5n9eKrCcVaxVrFWicVaJxVrFWsV +aJxVonFWAfm1+V1j510gtEFh1u1UmzuSOvcxvTs2U5sQmPN2PZ3aEtPO+cDzDwbyD5vv/K2qyeVv +MnK2s1kKIZtvqkxJJ3/31ITv2B+IftV5rtPs2OojR2mOR/HR6+dSAy4975+Y/WP2e7sPqMjFW2Iz +gM2CWORjIVIMokSFjkqpP75QYoME40fWfQYQzN+6J+Fv5T/TNp2drvDPBL6fucDVaXi3HNmEMyXM +fpuaOPsnxzsYSGaPDLm6KUDA2OTCfzD8nWes6Df2VzErRtG8kZYf3M6IxjmSm/wnw6io6EjNHDSZ +NNqRPH9Mj6h5d7tdFqLIHX8bPA/yY8z3eh+Y59HuGeOK4LERmtY7mHqQOx4g8vGgzuNLOjXe2du6 +cTxDIOcfuL6k0fU0v7USbeotA9Ohr0I+ebB5FHYq0TirWKtYqqWv+9UP+uv68VeF/wDOZZp/g/8A +7eP/AGK4qyr/AJxd/wCUFs/ldf8AUTir2vFXYq7FXYqh9S/4511/xhk/4icVfOH/ADhia/4w/wC3 +b/2NYq+iZT+8b5n9eKrMVaxVonFWicVaxVrFWicVaJxVrFWsVeWfnR+Ulv5ssG1XTI1j1+1QlSBT +6wij+7b3/lOY+fDxCxzdt2X2kcEuGX92fs83kv5c+e7m1nTyr5hYxGFvQ0+5m2eJwaC2lr+xXZCf +s9Ps048x2p2YM8bG2SP2+RerkBH95DeJ5/8AFD9Pf7+fT+boxVgQymhB6gjOGnjMSQRRDkCpCxyK +qk+VmLEwT/Q9c9Nlt5noP91SE9D4H2zb9na4xIhI+4us1mkv1D4ppqdy+tXUGiwL3EmoTDokSmvH +5tnWwHjECveXCwQGnic0vdEd5/Y+b/zp0N/J/wCa0moWqFLW9dNTtlGwJdv3yV95Fb6DmzPplYc7 +QZBqNNwy84l7d+Xmrxy8FR+UMyj02HQq45Ic2gNi3jJwMZGJ5hn5OFi1irWKtYqqWp/0qH/XX9Yx +V4V/zmcaf4P/AO3l/wBiuKsr/wCcXP8AlBLL5XX/AFE4q9sxV2KuxV2KofUv+Oddf8YZP+InFXzf +/wA4Xmv+Mf8At2/9jWKvomX+8f5n9eKrMVaJxVonFWsVaxVonFWicVaxVrFWicVaJxV4t+eP5PLr +UMnmPQYQNWiWt5bIAPrCj9r/AFwPvzFz4OLcc3edk9p+EfDmfQfs/Ywv8tvzA/SSxeXtaYrq0Q9O +xu3/AN3hf90yk9JV/ZY/a6H4qcuU7W7L8YccP7wfb+3u+Xc9IR4J4h/dnn/R8x5d/dz72frG7EhQ +aru3sPE+GcfHHKRoCy5RkEdpunXd7MI7YBiDR5m/uk+n9o/575vdB2OSbn8unxcXU6mGIXL5dT+p +6JoOmWmmWxiiq8kh5Tzt9uRvE/wzstPjjAUHkdZqp5pWeQ5DueX/APOT3lb9I+TbbXYUrcaNMPVY +Df6vcEI3Twk4H78syDZzexM/DkMDyl94Yb+TmvPLpFoC/wC9tHNsxP8Ak0eL8CBmVppXH3ON21g4 +M5PSW76DhmWaFJV+y6hh9IzIdSuxVrFWicVVLX/eqH/XX9YxV4V/zmgaf4O/7eX/AGK4qyz/AJxa +/wCUDsvldf8AUScVe2Yq7FXYq7FUPqX/ABzrr/jDJ/xE4q+bf+cLTX/GP/bt/wCxrFX0VL/ev/rH +9eKrCcVaJxVrFWsVaJxVonFWsVaxVonFWicVaxVo74q8F/Or8k5by5fzF5ZhUTSVa/sRRQTSvqJ2 +BP7Vdu+YmfT3vF6DsvtcYxwZPp6Hu/Y8z078w/O3lu9S31pJNQiiP+8uoF2ald/Tlrypttuy+2az +Jpo3uKL0UTHJD93Kr6int3kj85vJmuCO09UaTemgW0ueKKT4RyD4G9gaE+GARMXn9XoMsSZH1eb0 +yC498thN1UosQ/OLz35a0DyZfWWrD61catby21rpyMBJJzUqXrvwVK15U69N8zcOM5Nujjz1XgET +/iB2fOf5VambLX7jTy443KcomFfikhPJSvzQscGnPDMxL0na4GbTxyx8j8JfgPqjytei50xd907e +zbj8a5nPLJvirROKtYqqWv8AvVD/AK6/rGKvCf8AnNI0/wAHf9vL/sVxVlv/ADix/wAoFY/K6/6i +Tir23FXYq7FXYqh9S/4511/xhk/4icVfNf8AzhWf+Uy/7dv/AGN4q+i5T+9f/WP68VWE4q1irWKt +E4q0TirWKtYq0TirROKtYq1irROKtHFWGeavy30fW0k9S3jkVqt6bAAhj3Unb78jKIPNtw554zcC +QXiHm38h720keTSXIpU/Vpq9P8k7n/iWYs9L/Nd/pe3jyyj4j9SRaL+Yv5leRD9RmZ3tACkdregy +xrtt6T1qvH+UNTxGYksfCdw7GeDBqomUCL7x+kMO1rVNX1/UpdS1C8e/vpz8bSbP2oqoPhCitFVP +uGbXBqMdUPS8V2j2JqcRMj+8j3j9I6fc1peoyWGoWGpLXnbSKJAD8TCMio9gYzx+/MbVR4MgkOrv +/Z/MM+klhPOO3wPL7bfV/wCX+pKzCIMGRxRSOhDfEp/XmWC6GUSDRZ2TihrFWsVVLT/euH/jIv6x +irwj/nNQ/wDKG/8Aby/7FMVZd/ziv/ygNj8rr/qKOKvbsVdirsVdiqH1L/jnXX/GGT/iJxV80/8A +OFBr/jL/ALdv/Y3ir6MmP71/9Y/rxVZirWKtE4q0TirWKtYq0TirROKtYq1irROKtYq1irWKqc0M +MyGOVA6HsRXFWMa/5B0jVIXR4kdXFDHKKinhy6/fXAQDzZwySgbiaLxjzh+QZiZ5tKZrdzUiB94y +dzsf6H6Mxp6UHk7vS9uTjtkHEO/q8r1vy75k0ovb39rII0IZpgvJaLVVJelQKdA2Y8xMCjydxpZ6 +aczkx0Jy59D8R+l7H+T2vNNo9i3KsttW2fsAYqGP/hOOZmnlcXnO18PBnPdLf8fF73HIskayL9lw +GX5EVy51jeKtYqqWh/0uH/jIv6xirwf/AJzXNP8ABv8A28v+xTFWX/8AOKv/AJL+x+V3/wBRRxV7 +firsVdirsVQ+pf8AHOuv+MMn/ETir5o/5wmNf8Z/9u3/ALG8VfRs396/+sf14qp4q0TirROKtYq1 +irROKtE4q1irWKtE4q1irWKtYq0TirWKtYqskRJFKuoZT1UioxVI9V8o6ZfIQEUH+VxyX6O6/Rir +EW8gNpk0k1lEYjI4kbiOalhtUkfF274AAGc8kpVZJpnukpLHYRLIQSBVSO6ncdfnhYIvFWicVVbT +/euD/jIv/Ehirwb/AJzZNP8ABn/by/7FMVZf/wA4qf8AkvrD5Xf/AFFHFXuGKuxV2KuxVD6l/wAc +66/4wyf8ROKvmb/nCQ/8pn/27P8AsbxV9HTf3z/6x/XiqmTirROKtYq1irROKtE4q1irWKtE4q1i +rWKtYq0TirWKtYq1irROKtYq1irWKtE4q1iqrZ/71wf8ZF/4kMVeC/8AObZ/5Qz/ALef/YpirMP+ +cUv/ACXth8rv/qKOKvccVdirsVdiqH1L/jnXX/GGT/iJxV8y/wDOER/5TT/t2f8AY3ir6OnP75/9 +Y/rxVTJxVrFWsVaJxVonFWsVaxVonFWsVaxVrFWicVaxVrFWsVaJxVrFWsVaxVonFWsVaxVVs/8A +eyD/AIyL/wASGKvBf+c3T/yhf/bz/wCxTFWY/wDOKH/kvLD5Xf8A1FHFXuOKuxV2KuxVD6l/xzrr +/jDJ/wAROKvmP/nB81/xp/27P+xvFX0fOf30n+sf14qp4q1irROKtE4q1irWKtE4q1irWKtYq0Ti +rWKtYq1irROKtYq1irWKtE4q1irWKtYqq2Z/0yD/AIyJ/wASGKvBP+c4DT/Bf/bz/wCxTFWZf84n +/wDku9P+V3/1FHFXuWKuxV2KuxVD6l/xzrr/AIwyf8ROKvmD/nCCRUn86W7njORpzCM7NRDdBtvY +sK4q+kbiomkr/Mf14qp4q0TirROKtYq1irROKtYq1irWKtE4q1irWKtYq0TirWKtYq1irROKtYq1 +irWKtE4qrWIJvIABU81P3GuKvAP+c4ZozL5MiDAyIupOydwrG1Cn6eJxVm3/ADieGH5dafUEHjdn +fwN0SMVe5Yq7FXYq7FVskayRtG32XBVvkRTFXxjrN7rf5Efnjca1FbNP5e1ZpDLAtFWW2mcPLGld +g8MlGT2p2JxV9U+U/PHknzvp8d/5f1SG8DrV4UcLcRnussJ+NCPcfLbFU8/R0X8zfhirv0bF/M34 +Yq1+jIv52/DFXfoyL+dvwxV36Lh/nb8MVa/RUP8AO34Yq79FQ/zt+H9MVa/RMP8AO34Yq79Ew/zt ++GKu/REH87fh/TFWv0PB/O34f0xV36Hg/nb8P6Yq79DQfzt+H9MVa/QsH87fh/TFXfoWD/fj/h/T +FWv0Jb/78f8AD+mKu/Qdv/vx/wAP6Yq1+g7f/fj/AIf0xV36Ct/9+P8Ah/TFXfoK3/34/wCH9MVa +/QNv/vx/w/pirv0Bbf78f8P6Yqk3mfzh5E8iWEuoa9qcNpxUlIpHDXEngsUK/G5PsPntir4i/MXz +tr35wfmQtxa27Rxy8bTSbImvo2yEtykI2qas7n6OgGKvsf8AJ7y5HoWhW1jAP3NpbpEGIoWJp8R9 +24VPzxV6FirsVdirsVdirE/zG/Lfy/560OTTNViUvSsE9KsjjoR3+7FXyP5v/wCcW/Nuk3rpYTLL +ASfTMwYrx9pIw1fpQYqx3/oXzz942v8AwU//AFSxV3/Qvnn7xtf+Cn/6pYq7/oXzz942v/BT/wDV +LFXf9C+efvG1/wCCn/6pYq7/AKF88/eNr/wU/wD1SxV3/Qvnn7xtf+Cn/wCqWKu/6F88/eNr/wAF +P/1SxV3/AEL55+8bX/gp/wDqlirv+hfPP3ja/wDBT/8AVLFXf9C+efvG1/4Kf/qlirv+hfPP3ja/ +8FP/ANUsVd/0L55+8bX/AIKf/qlirv8AoXzz942v/BT/APVLFXf9C+efvG1/4Kf/AKpYq7/oXzz9 +42v/AAU//VLFXf8AQvnn7xtf+Cn/AOqWKu/6F88/eNr/AMFP/wBUsVd/0L55+8bX/gp/+qWKu/6F +88/eNr/wU/8A1SxV3/Qvnn7xtf8Agp/+qWKu/wChfPP3ja/8FP8A9UsVd/0L55+8bX/gp/8Aqliq +L0z/AJxz85XFwEu54IIu7xiWRv8AgWWP9eKvevys/JPTPLg/0WEz3sgHr3UtC5HWjECiJ/kjr3xV +7vpthHY2qwpuert4se+KorFXYq7FXYq7FXYqtkijlUpIgdD1VgCPxxVCnRtLJ/3mT7sVd+htL/5Z +k/HFXfobS/8AlmT8cVd+htL/AOWZPxxV36G0v/lmT8cVd+htL/5Zk/HFXfobS/8AlmT8cVd+htL/ +AOWZPxxV36G0v/lmT8cVd+htL/5Zk/HFXfobS/8AlmT8cVd+htL/AOWZPxxV36G0v/lmT8cVd+ht +L/5Zk/HFXfobS/8AlmT8cVd+htL/AOWZPxxV36G0v/lmT8cVd+htL/5Zk/HFXfobS/8AlmT8cVd+ +htL/AOWZPxxV36G0v/lmT8cVd+htL/5Zk/HFXDRtLB/3mT7sVRUcUcShI0CIOiqAB+GKrsVdirsV +f//Z + + + + + + +uuid:4ee3f24b-6ed2-4a2e-8f7a-50b762c8da8b + + + +image/svg+xml + + + +mime.ai + + + + + + +end='w' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +begin='' id='W5M0MpCehiHzreSzNTczkc9d' + + + + +Adobe PDF library 5.00 + + + + + +2004-02-04T02:08:51+02:00 + +2004-03-29T09:20:16Z + +Adobe Illustrator 10.0 + +2004-02-29T14:54:28+01:00 + + + + +JPEG + +256 + +256 + +/9j/4AAQSkZJRgABAgEASABIAAD/7QAsUGhvdG9zaG9wIDMuMAA4QklNA+0AAAAAABAASAAAAAEA +AQBIAAAAAQAB/+4ADkFkb2JlAGTAAAAAAf/bAIQABgQEBAUEBgUFBgkGBQYJCwgGBggLDAoKCwoK +DBAMDAwMDAwQDA4PEA8ODBMTFBQTExwbGxscHx8fHx8fHx8fHwEHBwcNDA0YEBAYGhURFRofHx8f +Hx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8f/8AAEQgBAAEAAwER +AAIRAQMRAf/EAaIAAAAHAQEBAQEAAAAAAAAAAAQFAwIGAQAHCAkKCwEAAgIDAQEBAQEAAAAAAAAA +AQACAwQFBgcICQoLEAACAQMDAgQCBgcDBAIGAnMBAgMRBAAFIRIxQVEGE2EicYEUMpGhBxWxQiPB +UtHhMxZi8CRygvElQzRTkqKyY3PCNUQnk6OzNhdUZHTD0uIIJoMJChgZhJRFRqS0VtNVKBry4/PE +1OT0ZXWFlaW1xdXl9WZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo+Ck5SVlpeYmZ +qbnJ2en5KjpKWmp6ipqqusra6voRAAICAQIDBQUEBQYECAMDbQEAAhEDBCESMUEFURNhIgZxgZEy +obHwFMHR4SNCFVJicvEzJDRDghaSUyWiY7LCB3PSNeJEgxdUkwgJChgZJjZFGidkdFU38qOzwygp +0+PzhJSktMTU5PRldYWVpbXF1eX1RlZmdoaWprbG1ub2R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo ++DlJWWl5iZmpucnZ6fkqOkpaanqKmqq6ytrq+v/aAAwDAQACEQMRAD8A9U4q7FXYq7FXYq7FXYq7 +FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F +XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX +Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY +q7FXzd+b/wDzlWum3k+h+QxFc3EJMdzrkoEkKuNiLZPsyU/nb4fAEb50vZ/YXEBPLsP5v62meXue +A3v5mfmprl080vmLVriXdjHBcTIi17rFCVRfoXOghocEBQhH5NJmepUf8Tfmj/1dtb/6SLv/AJqy +f5fD/Nj8gjxPN3+JvzR/6u2t/wDSRd/81Y/l8P8ANj8gviebv8Tfmj/1dtb/AOki7/5qx/L4f5sf +kF8Tzd/ib80f+rtrf/SRd/8ANWP5fD/Nj8gviebv8Tfmj/1dtb/6SLv/AJqx/L4f5sfkF8Tzd/ib +80f+rtrf/SRd/wDNWP5fD/Nj8gviebv8Tfmj/wBXbW/+ki7/AOasfy+H+bH5BfE83f4m/NH/AKu2 +t/8ASRd/81Y/l8P82PyC+J5u/wATfmj/ANXbW/8ApIu/+asfy+H+bH5BfE83f4m/NH/q7a3/ANJF +3/zVj+Xw/wA2PyC+J5u/xN+aP/V21v8A6SLv/mrH8vh/mx+QXxPN3+JvzR/6u2t/9JF3/wA1Y/l8 +P82PyC+J5u/xN+aP/V21v/pIu/8AmrH8vh/mx+QXxPN3+JvzR/6u2t/9JF3/AM1Y/l8P82PyC+J5 +u/xN+aP/AFdtb/6SLv8A5qx/L4f5sfkF8Tzd/ib80f8Aq7a3/wBJF3/zVj+Xw/zY/IL4nm7/ABN+ +aP8A1dtb/wCki7/5qx/L4f5sfkF8Tzd/ib80f+rtrf8A0kXf/NWP5fD/ADY/IL4nm7/E35o/9XbW +/wDpIu/+asfy+H+bH5BfE82j5t/M+Aes2ta3EI/i9U3N2vGnfly2x/LYT/DH5BePzZ15C/5yh/Mb +y7cxRaxcHzDpQIEsF2f9IC9zHc058v8AX5D9ea/VdiYcg9I4JeXL5NkchD688jeefLvnby/DrmhT ++rayEpLE4CywygAtFKtTxYV+RG4qDnH6nTTwT4JjdyIytkGY6XYq7FXYq7FXYq7FXjX/ADlH+YV1 +5W8hppunymHU/MMj2qSqaMltGoNwynxPNE/2WbrsPSDLl4pfTDf49GvJKg+VPy+8lP5ivecqM9rG +4jWFaqZpTvw57cVUULGvcfMdtYFk7Ac3Ua3VHGAI/XLk+jNK/LfSLS0SK4JYqDSGCkUCV3PBVAPX +vtXwzWT7TlfoAA+11f5Xi3mTIo608meV/wBL2lnLbSSLcc/92sB8Kk70IOU5+0s4xSmCPT5NuDRY +pZBEjmyu2/KnydcFgliF4ip5TT/wY5ov5f1f877B+p2/8kaf+b9pVv8AlT3lL/lkT/kdcf1w/wAv +az+d9kf1I/kjTfzftLR/J/yl/wAsif8AI65/rj/L2s/nfZH9S/yRpv5v2lafyg8p/wDLKn/I65/r +h/l3Wfzvsj+pf5J03837S0fyh8p/8sqf8jrn+uP8u6z+d9kf1L/JOm/m/aWj+UXlP/llj/5HXP8A +XH+XdZ/O+yP6l/knTfzftLX/ACqPyn/yzR/8jrn+uH+XNb/O+yP6l/knTd32lr/lUflX/lmj/wCR +1z/XB/Lmt/nfZH9S/wAk6bu+0u/5VD5W/wCWaP8A5HXP9cf5d1n877I/qX+SdN/N+0u/5VB5Y/5Z +ov8Akdc/1x/l3Wfzvsj+pf5J03837S7/AJU/5a/5Zov+R1z/AFx/l3Wfzvsj+pf5J03837S7/lT3 +lv8A5Zov+R1z/XB/L2s/nfZH9S/yRpv5v2l3/KnfLv8AyzRf8jrn+uP8vaz+d9kf1L/JGm/m/aXf +8qc8v/8ALNF/yOuf64/y9rP532R/Uv8AJGm/m/aXf8qb0H/lmh/5HXP9cf5f1n877I/qX+SNN/N+ +0u/5U1oP/LND/wAjrn+uD+X9Z/O+wfqT/JGn/m/aVk/5P6BDBJM1rEVjUswE1xWg8KnH/RBq/wCd +9g/Uv8kaf+b9pYp5i8oeXLOGBoLQo0j8SRJIe3+Uxza9ldq6jNKQnLkO4Ov1/Z2HGAYj7SkreXdK +IoEZD/Mrmo+Vaj8M3I1eR1fgRee/mD+W8NxE91ZIPrhq0UygL6rbt6ctNubfssevy6XwmJjbYjo5 +ml1csUhGRuB+xJP+cfvzGvfJvny1T1T+iNXdLTUbcn4SWNIpPZkduvgTmq7Z0gy4Sf4obj9L0WOV +F93xSJLGsiGqOAyn2O+cK5K7FXYq7FXYq7FXYq+R/wDnM65lbzjoFsT+6i05pEG/2pJ2VvbpGM6/ +2cH7uR/pfocfNzb/ACCs7caXZzBAJPQuJS3fn9ZMXL/gNs2uvkRirvl+h0GffUm+kfx972EnNKyU +LXfzNpZ/4y/8QOOo/wAWn8PvbdN/fRei6SPjl/1R+vOWDvyjyMsQsIwoWkYVWEYULSMKFhGSVrFV +wOBVwOBVwOBK4HFVwOBK4HAq4HAlcDgVQ1I/7jrn/jE36siUh5X5uH+j23tL/DN52F9U/c6vtX6Q +x0nOidEgNZodNmBAP2aE9jzG4+jL9P8AWGrL9JfNGuSmDzPqEsICGK9maNRsF4ykgCnhmRKArhel +08iccT5B+iHk+4afQbcsalBx+8Bv+Ns8wdknWKuxV2KuxV2KuxV8hf8AOZn/ACneif8AbLH/AFES +52Hs7/dS/rfoDj5uaO/IUf7gbI/8ulx/1GnNlr/7v/O/Q6DN/jEv6v6nqxOahksshXzJpv8Az0/4 +gcjqf8Xn8PvbdL/exei6SPjk/wBUfrzlw9AmBGTYrSMKrCMKFpGFVhGFC0jChYRklaxVcDgVcDgV +cDgSuBxVcDgSuBwKuBwJUdRP+4+5/wCMTfqyJSHlvmwf6Lb+0n8M3XYX1S9zq+1fpDwzzXoX1nzD +eT8a82U1/wBgBm1y6fikS6qGfhFJt5T076lomoJSnOSM/dTMzQYuCTj6rJxh4h5k/wCUi1T/AJjJ +/wDk62bM83fab+6j/VH3P0N8jf8AHBj+Y/5NpnlztGQYq7FXYq7FXYq7FXyF/wA5mf8AKd6J/wBs +sf8AURLnYezv91L+t+gOPm5ph+Q4/wCddsj/AMutx/1Gtmx1/wBH+d+h0Gb/ABiX9X9T1InNUl2n +b+Y9P/56f8QOQ1X+Lz+H3t+l/vYvRtJH7yT/AFR+vOWDv0xIySFhGSQtIwqsIwoWkYVWEYULSMKF +hGSVrFVwOBVwOBVwOBK4HFVwOBK4HAqjf/8AHPuf+MTfqyEkh5j5rH+iQ/65/Uc3XYf1y9zre1Pp +DDpbGzkcu8QZ26k50weeMQoXVvDDZyrEgQNQkD5jLMX1BhMbPmrzN/ykmrf8xlx/ydbMp6XTf3cf +6o+5+hnkb/jgx/Mf8m0zy52bIMVdirsVdirsVdir5C/5zM/5TvRP+2WP+oiXOw9nf7qX9b9AcfNz +TL8iR/zrFif+Xa4/6jWzYa76f879Doc/9/L3fqenE5rEL9KFfMNh85P+IHK9X/cT+H3uRpP72L0f +SR+8k/1f45yzv0xIwqtIwoWEZJC0jCqwjChaRhVYRhQtIwoWEZJWsVXA4FXA4FXA4ErgcVXA4EqV +9/vBc/8AGJv1ZCXJIea+ah/ocfsx/wCInNx2H9cvcHW9qfQGIE507z6HvN7dx8v1jLMfNhPk+Z/N +H/KTav8A8xtx/wAnWzJek0/93H+qPufoX5G/44MfzH/JtM8vdmyDFXYq7FXYq7FXYq+Qv+czP+U7 +0T/tlj/qIlzsPZ3+6l/W/QHHzc0z/Isf86nYH/l3uP8AqNbM/W8v879Doc/9/L3fqelk5rkK2j76 +/ZfN/wDiBynWf3Evx1cjSf3oej6UP3r/AOr/ABzl3fpliq0jCq0jChYRkkLSMKrCMKFpGFVhGFC0 +jChYRklaxVcDgVcDgVcDgSuBxVTvP94rn/jE36shPkyDzjzUP9BX5n/iJzbdifXL4Ou7U+gfFhhO +dS86pXG8TD5frycebGXJ8z+av+Un1j/mNuf+TrZkh6TT/wB3H+qPufoV5G/44MfzH/JtM8vdmyDF +XYq7FXYq7FXYq+Qv+czP+U70T/tlj/qIlzsPZ3+6l/W/QHHzc01/I0f86fp5/wCKLj/qNbM7W8v8 +79Dos/8AfH3fqejE5gMEVoe+u2fzf/iByjW/3Evx1cnR/wB4Ho+l/wB4/wAv45y7v0xxV2KrSMKr +SMKFhGSQtIwqsIwoWkYVWEYULSMKFhGSVrFVwOBVwOBVwOBKy6P+h3H/ABib9WQnySHnnmkf6APY +t/xE5texPrPwdf2n9A+LByc6t5xTfcEZIIL5p82f8pTrP/Mdc/8AJ5syRyek0/8Adx9w+5+hPkb/ +AI4MfzH/ACbTPL3ZsgxV2KuxV2KuxV2KvkL/AJzM/wCU70T/ALZY/wCoiXOw9nf7qX9b9AcfNzTf +8jx/zpWnH/im4/6jHzO1n6f0Oi1H98fd+p6ETmE1o3y/vrdr82/4gcxtd/cycrR/3gej6b/eP8v4 +5y7v0wxV2KuxVaRhVaRhQsIySFpGFVhGFC0jCqwjChaRhQsIyStYquBwKuBwKtuT/olx/wAYm/Vk +J8mUXn/mkf7jj/sv+InNp2L/AHh+Dr+0/oHxYGTnWvONDdgMUPmnzb/yletf8x9z/wAnmzIjyelw +f3cfcH6EeRv+ODH8x/ybTPMHZMgxV2KuxV2KuxV2KvkL/nMz/lO9E/7ZY/6iJc7D2d/upf1v0Bx8 +3NOPyRH/ADo2mn/im4/6jHzN1fP4/odHqP70+5n5OYjUmHlzfWrb5t/xA5ia7+5k5Wi/vA9H07+8 +f5fxzmHfo/FXYq7FXYqtIwqtIwoWEZJC0jCqwjChaRhVYRhQtIwoWEZJWsVXA4Fan/3luP8AjE36 +shk5MosD80D/AHGt8m/4gc2XY394fg4Haf0fN56TnXvNLod5VHz/AFYJclD5p83/APKWa3/zH3X/ +ACebMiPIPS4P7uPuD9CPI3/HBj+Y/wCTaZ5g7JkGKuxV2KuxV2KuxV8hf85mf8p3on/bLH/URLnY +ezv91L+t+gOPm5p1+SYp5B0w/wDFVx/1GPmZq/q+P6HR6n+9PuZ0TmM0pr5Y31iD5t/xA5h6/wDu +i5mi/vA9G0/7b/LOYd8jsVdirsVdirsVWkYVWkYULCMkhaRhVYRhQtIwqsIwoWkYULCMkrWKul/3 +mn/4xt+rK8nJMebB/NA/3Fyf6r/8QObHsb+8Pw+9we0/o+bzgnOxeZVLXe4QfP8AUcjPkmPN81ec +f+Uu1z/toXX/ACebL4fSHpcH0R9wfoP5G/44MfzH/JtM8xdkyDFXYq7FXYq7FXYq+Qv+czP+U70T +/tlj/qIlzsPZ3+6l/W/QHHzc08/JUf8AIPNLP/Fdx/1GSZl6r6z7/wBDpNT/AHh9zNicocdOPKu+ +rQ/M/wDEGzB7Q/ui5uh+sPRbEhXappt3zmXfI3mn8w+/FXeon8w+/FWvUj/mH3jFXepH/MPvGKu9 +WP8AnH3jFXepF/Ov3jFVpeP+dfvGG1Wl4/51+8YbQtLJ/Mv3jDa0tJT+ZfvGHiCKWnj/ADL/AMEP +64eILS08f5l/4If1w8QRS0qP5l/4If1w8YWlpUfzL/wS/wBceMIorCn+Uv8AwS/1w8YXhKyai289 +WXeNgPiB3I+eRnIEJiGFeZx/uKm/1H/4gc2PY/8AefL73B7S+j5vNCc7N5dWsN7uMfP/AIichl+k +so83zX5z/wCUw13/ALaF1/yffL8f0j3PS4foj7g/QbyN/wAcGP5j/k2meYuyZBirsVdirsVdirsV +fIX/ADmZ/wAp3on/AGyx/wBREudh7O/3Uv636A4+bmnv5Lj/AJBxpZ/yLj/qMkzK1X1n3/odJqv7 +w+5mZOVOOmvly5jtrwTyAlIzuFpXdSO9Mw9bjM4cI6uVpJiMrLK/8T2H++5fuX/mrNL/ACdk7x+P +g7b85DuLX+JbD/fcv3L/AM1Y/wAnZO8fj4L+ch3Fr/Elj/vuX7l/5qx/k7J3j8fBfzkO4tf4jsf9 +9y/cv/NWP8nZO8fj4L+ch3Fo+YrH/fcv3L/zVj/J2TvH4+C/nIdxW/4hsv5JPuX/AJqx/k7J3j8f +BfzkO4tfp+y/kk+5f+asf5Oyd4/HwX85DuLX6es/5JPuX/mrH+TsnePx8F/OQ7i1+nbP+ST7l/5q +x/k7J3j8fBfzkO4tfpy0/kk+5f64/wAnZO8fj4L+ch3Fr9N2n8kn3L/XH+TsnePx8F/OQ7i0datf +5JPuX+uP8nZO8fj4L+ch3Fb+mLX+R/uH9cf5Oyd4/HwX85DuLX6Xtv5H+4f1x/k7J3j8fBfzkO4t +fpa2/lf7h/XH+TsnePx8F/OQ7i0dVt/5X+4f1x/k7J3j8fBfzkO4tHVLf+V/uH9cf5Oyd4/HwX85 +DuKW6/dxz6XcKgYFY5DvT+Q++bDs7TSx5Bdbkfe4etzicNvN5sTnWPOojTN7+If63/ETleb6Cyhz +fNnnX/lMte/7aN3/AMn3y/H9I9z02H6B7g/QXyN/xwY/mP8Ak2meYuxZBirsVdirsVdirsVfIX/O +Zn/Kd6J/2yx/1ES52Hs7/dS/rfoDj5uaf/kyP+QZ6Uf8m4/6jJMytT/eH8dHS6r6z7mXk5W4rSyy +JXgxWvWhIxMQVEiOTjdXH+/X/wCCOPAO5eM9603Vz/v1/wDgjh4I9y8Z71pu7n/fz/8ABHDwR7kc +Z71pu7r/AH8//BH+uHw49y8cu9aby6/39J/wR/rh8OPcEccu9ab27/3/ACf8E39cPhx7gjjl3rTe +3f8Av+T/AINv64fDj3BfEl3rTfXn+/5P+Db+uHw49wR4ku8rTfXv/LRJ/wAG39cPhR7gviS7ytN/ +e/8ALRJ/wbf1w+FHuCPEl3ladQvv+WiX/g2/rh8KPcEeJLvK06hff8tMv/Bt/XD4Ue4L4ku8rTqN +/wD8tMv/AAbf1w+FDuCPEl3ladRv/wDlpl/4Nv64fBh3D5L4ku8rTqWof8tUv/Bt/XD4MO4fJHiy +7ytOp6h/y1Tf8jG/rh8GHcPkjxZd5aOp6j/y1Tf8jG/rh8GHcPkviy7ypvqN+6lWuZWVhRlLsQQe +xFcIwwHQfJByS7yhScta0Xo++pQj/W/4icq1H0Fnj+p82+d/+Uz1/wD7aN3/AMn3y7F9I9z02H6B +7g/QTyN/xwY/mP8Ak2meZOxZBirsVdirsVdirsVfIX/OZn/Kd6J/2yx/1ES52Hs7/dS/rfoDj5ub +IfybH/ILtJPtcf8AUZLmTqP70/jo6XVfWWVE5FxFpOFVpOFDCLz82fLtrdz2slteGSCRonKpFQlC +VNKyDbbLRjLLgKgfzh8tf8s17/wEX/VXD4ZXwytP5weWv+Wa9/4CL/qrjwFHhlo/m95b/wCWa8/4 +CL/qrh4Cvhlo/m75b/5Zrz/gIv8Aqrh4V8Mrf+Vt+XD/AMe15/wEX/VXCIFHhF3/ACtjy6f+Pa8/ +4CL/AKqZMYijwy1/ytXy8f8Aj3u/+Ai/6qZYNPJHhl3/ACtPy+f+Pe7/AOAj/wCqmTGll5I8Mtf8 +rQ0A/wDHvd/8BH/1UywaKfkjwy7/AJWboR/497r/AICP/qpkx2fPvCOAtf8AKytDP+6Lr/gI/wDq +pkx2bk7x+PgjgLY/MXRT0guf+Bj/AOa8P8nZO8fj4LwFseftIPSG4/4FP+a8f5Pn3j8fBHAUTY+b +dOvbqO2iimWSQkKXVQNhXejHwyGTSSiLNIMSE4JzGYLCcKFpOFCN0PfVYB/rf8QOU6n+7LZi+oPm +7zx/ymvmD/tpXn/J98uxfQPcHpsX0D3B+gfkb/jgx/Mf8m0zzJ2LIMVdirsVdirsVdir5C/5zM/5 +TvRP+2WP+oiXOw9nf7qX9b9AcfNzZF+To/5BVpB9rj/qMlzI1H98fx0dNq/qLJycXDWk4ULScKEq +/IbT7OTVvMty0S/Wm1BoRPQcxHVmKqT0BPXNL25M3EdKd52bEUS9s/RNv/O/3j+maC3Zu/RNv/O/ +3j+mNq79E2/87/eP6Y2rv0Tb/wA7/eP6Y2rv0Tb/AM7/AHj+mNq79E2/87/eP6Y2rv0Tb/zv94/p +jau/RNv/ADv94/pjau/RNv8Azv8AeP6Y2rv0Tb/zv94/pjau/RNv/O/3j+mNq80/PXTbMeUJmaMP +LbyQvBKwBZC8gRqEU6qc6L2YyyjqwAdpA38nA7RiDiJ7nzykeekEvOpz5cSmsWx9z/xE5jak+gsZ +cmeE5qWhaThQtJwqj/L2+sW4/wBf/iDZRq/7s/jq2YfqD5v89f8AKb+Yf+2nef8AUQ+W4foHuD02 +L6R7n6BeRv8Ajgx/Mf8AJtM8zdiyDFXYq7FXYq7FXYq+Qv8AnMz/AJTvRP8Atlj/AKiJc7D2d/up +f1v0Bx83Nkn5Pj/kEujn/mI/6jJcvz/35/HR02r+osjJyThLScKFhOSQgvyCamo+YR46o3/G2aHt +z6o+533Zv0l7pmhdk7FXYq7FXYq7FXYq7FXYq7FXYq8w/PPfytdr7wf8nRm/9m/8bj7pfc4PaP8A +cn4PntI89IJebTXQUpqlufc/8ROY+c+gsZcmZk5rWhaThVaThQmPlrfW7Yf6/wDybbMfWf3R/HVt +wfWHzh58/wCU58xf9tO8/wCoh8twfRH3B6fH9I9z9AfI3/HBj+Y/5NpnmbsGQYq7FXYq7FXYq7FX +yF/zmZ/yneif9ssf9REudh7O/wB1L+t+gOPm5sm/KEf8gh0Y+9x/1GTZdm/vz+OgdPrOZT8nLHAW +E5JC0nCqX/kO9NT8wf8AbUb/AI2zQ9ufVH3O+7N+kvdPUzQ07Jg/5n+a7ny3o9zq0CGY20cREHMx +hvUnEfUA9OVemZmh03jZRC6u/utpz5eCBl3PIv8AoY3V/wDq1j/pKf8A5ozoR7NxP8f2ftdf/KR/ +m/ay/wDLf81dQ826lcW0tsbQWypJyWZpOXJuNKELmu7U7JGliJCXFZ7nJ0ur8UkVVPZvUzR05rvU +xpXepjSu9TGld6mNK71MaV3qY0rzP8625eXrlf8AjB/ydGb32c/xuPul9zg9o/3J+DwdI89FJebT +PRkpqEJ9z+o5RmPpLCXJlJOYLStJwoWE4UJp5V31+1H/ABk/5NtmNrf7o/D727T/AFh84efv+U68 +x/8AbUvf+oh8swf3cfcHp8f0j3P0B8jf8cGP5j/k2meaOwZBirsVdirsVdirsVfIX/OZn/Kd6J/2 +yx/1ES52Hs7/AHUv636A4+bmyf8AKMf8gc0U/wCVcf8AUZNl2b/GD+OgdPrOZTsnLnXrScKrScKE +s/I1qanr3/bTb/jbND22PVH3O/7N+kvb/UzROyeYfny9fJmoj/iu2/6i0zbdiD/CofH/AHJcTW/3 +R+H3vmQDPQ4wefep/kEeOuah/wAYov8Ak5nOe1Eaxw/rH7nZdmfUfc+l/UziXcu9TFXepirvUxV3 +qYq71MVd6mKvOPzhblolwPaH/k5m79nv8aj7j9zgdo/3J+DxdI89BJebTDTEpeRH3P6jlOQ7MZck +/JzFaFhOFC0nCqbeUd/MVoP+Mn/Jpsxdf/cy+H3hu031h84/mB/ynnmT/tqXv/UQ+Waf+7j/AFR9 +z0+P6R7n6AeRv+ODH8x/ybTPNHYMgxV2KuxV2KuxV2KvkL/nMz/lO9E/7ZY/6iJc7D2d/upf1v0B +x83NlP5TD/kC+iH/AC7n/qMmy3L/AIzL8dA6jWcym5OZDrlpOFC0nChKfyUbjqmue+pN/wAbZpO3 +h6of1Xf9m/SXtXqZz9Oyeafnm9fKOoD/AIrt/wDqKXNz2CP8Lh/nf7kuJrv7o/D73zaFz0mMHnre +nfkWeOt33/GKP/k5nMe1kaxQ/rH7nZ9l/Ufc+j/UzhKdy71MaV3qY0rvUxpXepjSu9TGld6mNK8/ +/NduWlzL7Rf8nM3XYH+NR+P3OD2l/cn4PJEjzvSXmkbYpS4Q/wCfTKpnZjLkmpOUtC0nCq0nJITj +ybv5lsx/xk/5NPmH2h/cy+H3hv0394Hzl+YP/KfeZf8Atq3v/US+Waf+7j/VH3PTw+kPv/yN/wAc +GP5j/k2meaOwZBirsVdirsVdirsVfIX/ADmZ/wAp3on/AGyx/wBREudh7O/3Uv636A4+bmyv8qB/ +yBPRD/xZc/8AUZNlmT/GpfjoHUa1MycynWrScKFhOFUn/JxuOqa1/wBtJv8AjbNR7QD1Q/qu+7M+ +kvZfUznKdm83/Ox+XlW/H/Fdv/1Erm69nh/hkP8AO/3JcTXf3J+H3vncLnp8YvOPSvyUHDWL0+Mc +f/E85P2u/uof1j9ztOy/qPufQ3qZwVO6d6mNK71MaV3qY0rvUxpXepjSu9TGlYJ+ZjcrGUe0X/E8 +3HYX+Mx+P3OB2l/cn4PNEjzuSXmkVbpSRTlZLGXJFk5FpWk5JC0nChOvJG/miyH/ABl/5MvmF2l/ +cS+H3hyNL/eD8dHzn+Yf/Kf+Zv8AtrX3/US+T0391H+qPueoh9Iff3kb/jgx/Mf8m0zzVz2QYq7F +XYq7FXYq7FXyF/zmZ/yneif9ssf9REudh7O/3Uv636A4+bmyz8qv/JHaGf8Aiy5/6jJ8nk/xuXu/ +QHUa1MCczHWLCcKrScKEk/KN+Gqaz/20W/42zV+0Y3x/1Xfdl/SXr31gZzVO0Yv520E+YLSSwbms +EyIHkjKhgUk9Tbl8hmXodXLTZRliATG+fmKas2IZImJ6sFH5J2Q/3ddffF/TOh/0W5/5kPt/W4P8 +lw7ynvlX8v18vXbz25mkMoVX9QpQBWrtxAzV9pdsZNXERkAOHutyNPpI4iSDzei/WBmnpy3fWBjS +u+sDGld9YGNK76wMaV31gY0rvrAxpWGfmA4kt5B/kx/8Tzbdi/4wPj9zgdpf3J+DAkjztCXmldEp +vkbYy5Licm0LScKFhOFU98ib+a7H/nr/AMmXzB7T/wAXl8PvDkaT+8H46PnT8xf/ACYPmf8A7a19 +/wBRL5PTf3Uf6o+56iHIPv3yN/xwY/mP+TaZ5q57IMVdirsVdirsVdir5C/5zMB/x1oh7fosf9RE +udh7O/3Uv636A4+bmyz8qv8AyRuh07S3Ffb/AEyfJz/xuXu/QHUa3kjSczXWLScKFpOFDH/ywfhq +OsH/AJf2/W2a72lG+P8AqO+7L+kvT/rXvnMU7R31r3xpXfWvfGld9a98aV31r3xpXfWvfGld9a98 +aV31r3xpXfWvfGld9a98aV31r3xpWM+bpPUiYeyf8Szadj/4wPj9zg9pf3J+DFUjzsCXmVVkpGTg +id2MuSHJy9oWE4VWk4UJ95CqfNljQbD1a/8AIl8wO1P8Xl8PvDkaP+8H46PnX8xf/Jg+Z/8AtrX3 +/US+T0v91H+qPuephyD798jf8cGP5j/k2meaueyDFXYq7FXYq7FXYq+b/wDnMvyrcXGj6F5ngQtH +YSSWV6QK8VuOLxMfBQ8bLXxYZ0vs7nAlLGeu4+DTmHVif/OOXm+xvdGvfImoTiO5LvdaSXbZlIDS +RINt0ZfUp1ILeGbPtDGYTGUfF12pxcQZ/fafeWUhjuIytDQPT4W+Ry3FljMWC6acDHmhCcta1hOF +Uo/KW39fzBf2/X1dQYU/4LNf7UHfH/Ud92V9Je4/4U/yPwzkuN2tO/wp/kfhjxrTv8Kf5H4Y8a07 +/Cn+R+GPGtO/wp/kfhjxrTv8Kf5H4Y8a07/Cn+R+GPGtO/wp/kfhjxrTv8Kf5H4Y8a07/Cn+R+GP +GtO/wp/kfhjxrTz78wrH6lf/AFelKxI1Pmx/pm27GN5x8fucDtP+5PwYmkedcS8wuuEpbufb+OMD +6mMuSWE5ltK0nChyJJK4jjUu7bKqgkk+wGJIAsqBfJldi1p5F0G982+Yf3BjjMdlZsQsskjbqig/ +tvxoB2FSds0Wu1H5iQxY9+8u20OlINl82eV7HUPNvny1WWs1zqF4bm8cDqC5lmb2rvT3zK1mUYMB +PdGh9wd/AWafoD5TtzBo6L2LEj5ABf8AjXPPHLTjFXYq7FXYq7FXYql/mDQdL8waLeaLqsIuNPv4 +mhuIj3Vu4PZlO6nsd8sxZZY5CUeYQRb4V/NL8oPNv5a656pEs2kiX1NL1uDko+FqpzZf7qVdtvHd +Sc7vQ9o49TGuUusfxzDjTgQmOjf85K/mRp1klrMbLUymy3F5C5loBQAtDJCG+ZFfE4z7KxSN7j3O +OcUSj/8Aoaf8wf8Aq36T/wAibn/soyH8kYu+X2fqR4Ad/wBDT/mD/wBW/Sf+RNz/ANlGP8kYu+X2 +fqXwAoN/zkl5puryK6v9OtRJACIHsXmtXUk9SzvcfgBlObsSEuUiPfv+puxejkjP+hnPMn++bz/u +JS/9U8xv9Dw/n/7H9rd4rv8AoZzzJ/vm8/7iUv8A1Tx/0PD+f/sf2r4rv+hnPMn++bz/ALiUv/VP +H/Q8P5/+x/aviu/6Gc8yf75vP+4lL/1Tx/0PD+f/ALH9q+K7/oZzzJ/vm8/7iUv/AFTx/wBDw/n/ +AOx/aviu/wChnPMn++bz/uJS/wDVPH/Q8P5/+x/aviu/6Gc8yf75vP8AuJS/9U8f9Dw/n/7H9q+K +7/oZzzJ/vm8/7iUv/VPH/Q8P5/8Asf2r4rv+hnPMn++bz/uJS/8AVPH/AEPD+f8A7H9q+K7/AKGc +8yf75vP+4lL/ANU8f9Dw/n/7H9q+K7/oZzzJ/vm8/wC4lL/1Tx/0PD+f/sf2r4qEm/5yR8yi8jvr +awikvEBQyahNLdjgRSg4mBh1/mPyy7D2FCJ3kT7hX62vJLjFK3/Q0/5g/wDVv0n/AJE3P/ZRmT/J +GLvl9n6nH8AO/wChp/zB/wCrfpP/ACJuf+yjH+SMXfL7P1L4Ad/0NP8AmD/1b9J/5E3P/ZRj/JGL +vl9n6l8AO/6Gn/MH/q36T/yJuf8Asox/kjF3y+z9S+AGj/zlP+YJH/HP0ke/o3P/AGUY/wAkYu+X +2fqXwQwPXvM/nfz/AKxF9emm1O7qRa2cS0jiDHf040AVR0qx32+I5lxhi08L2iO9tjCtg+ifyJ/J +ubQF+u36q+tXajmRusEXXiD+vxNPAE8f2r2l+YlUfoH2+f6nKhCn0XBCkEKQxiiRgKv0ZqGxfirs +VdirsVdirsVdiqhfWFlf2slpewpcW0o4yQyKGVh7g4QSNwryzXP+cZ/yy1G4a4i0xIGY1McTyQrX +5RMo/wCFzYY+1tTAUJn40fvYHGEp/wChVPy+/wCWAf8ASXdf1yf8tar+f9kf1L4cXf8AQqn5ff8A +LAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/ +rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n +/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF +3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff +8sA/6S7r+uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r ++uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+ +f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4c +Xf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4cW1/5xW/L +9WDCwWo33urkj7icT2zqv5/2R/UvhxZl5Z/KLy9oKcLG1t7RduRgT42p4sQN/c5g5tRkym5yMmQA +DNrOytrSL04E4j9o9ST7nKUq+KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K +uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku +xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux +V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV//2Q== + + + + + + +uuid:f3c53255-be8a-4b04-817b-695bf2c54c8b + + + +image/svg+xml + + + +filesave.ai + + + + + + +end='w' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/icons/save.png b/icons/save.png new file mode 100644 index 0000000000000000000000000000000000000000..daba865fafd22fa18e7c0488eb699b79d3554170 GIT binary patch literal 1187 zcmV;U1YG-xP)5-PJz!8#8DIjU4h)0S{a*K!i>mJVVCD^kQ5IHGsm^=1>z+FI)Tw&v zz2|;5 zYXiKvXAppke-?cB?jC^K0C4>59N#}M1b8m}xWN9m&Tq?d4;^`$3nP}(pC4rW)qR_5 zKt-??KzML0Bg?XF0WdI@VU185d=w)kA`~mw7?IVLbLY;3D!2sF6tWD`ER0DCNfO?7 zI*{j(x1rU7b}No;C~~s;IMxc|ue?cX@%rWftQD*k1h7Wfy?f^tYwL!tfLf?lf$D8h zjjsf?g7=`NgaKy-HG&AJ3Y9FwBOo3K!0;X~0^TDMCKY^$Bg7#dJRx2{O;{K}*Gh>7 ztf1Os0Gczu1&UJ#X#$l5vNZMt5(iG9=s;dTE04VeOF6W2$O}}5aXkPkPoHKY21CJ!U{_^v8Xy`U*q`vX%#{A#01X5mtL``3Wj}4_b=eEU&o)}BH zcC!Nrol+61khoCqTE#GZvCBZkunzPltylR~F5%(E(lYhTaDB;yE$K=b5S$vobLD22 zD>u8WQCC0Ls$_n}C!#5=1r@`b3$=HqY!|4(sUXN2HLsgB8jo2qp8k93?-T&>g72GH zFe_J90#zZ=ko@OU-}3936D%#>xTpG8Y6Cp=>`tC}VFC}RGg~nb1AK?~_rJly!UDH$ z-J&Q8L>2*RmC}ns$#9hnDF1_1m8Hc<-5*m|${p@{U>9F*?@YhOX2JRd6<}qE@f>YdJGB!_d$W)>^#xG@H%40#K{h zaM6gg)QA+E3nyHlDgdZft7KW$r?@xXX>%H>7ePy{I3CBnBed6yF^ELpk2<)ko3Ayf z4fFOGE + + + + + + + begin='' id='W5M0MpCehiHzreSzNTczkc9d' + + + + +Adobe PDF library 5.00 + + + + + +2004-02-04T02:08:51+02:00 + +2004-03-29T09:20:16Z + +Adobe Illustrator 10.0 + +2004-02-29T14:54:28+01:00 + + + + +JPEG + +256 + +256 + +/9j/4AAQSkZJRgABAgEASABIAAD/7QAsUGhvdG9zaG9wIDMuMAA4QklNA+0AAAAAABAASAAAAAEA +AQBIAAAAAQAB/+4ADkFkb2JlAGTAAAAAAf/bAIQABgQEBAUEBgUFBgkGBQYJCwgGBggLDAoKCwoK +DBAMDAwMDAwQDA4PEA8ODBMTFBQTExwbGxscHx8fHx8fHx8fHwEHBwcNDA0YEBAYGhURFRofHx8f +Hx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8fHx8f/8AAEQgBAAEAAwER +AAIRAQMRAf/EAaIAAAAHAQEBAQEAAAAAAAAAAAQFAwIGAQAHCAkKCwEAAgIDAQEBAQEAAAAAAAAA +AQACAwQFBgcICQoLEAACAQMDAgQCBgcDBAIGAnMBAgMRBAAFIRIxQVEGE2EicYEUMpGhBxWxQiPB +UtHhMxZi8CRygvElQzRTkqKyY3PCNUQnk6OzNhdUZHTD0uIIJoMJChgZhJRFRqS0VtNVKBry4/PE +1OT0ZXWFlaW1xdXl9WZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo+Ck5SVlpeYmZ +qbnJ2en5KjpKWmp6ipqqusra6voRAAICAQIDBQUEBQYECAMDbQEAAhEDBCESMUEFURNhIgZxgZEy +obHwFMHR4SNCFVJicvEzJDRDghaSUyWiY7LCB3PSNeJEgxdUkwgJChgZJjZFGidkdFU38qOzwygp +0+PzhJSktMTU5PRldYWVpbXF1eX1RlZmdoaWprbG1ub2R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo ++DlJWWl5iZmpucnZ6fkqOkpaanqKmqq6ytrq+v/aAAwDAQACEQMRAD8A9U4q7FXYq7FXYq7FXYq7 +FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F +XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX +Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY +q7FXzd+b/wDzlWum3k+h+QxFc3EJMdzrkoEkKuNiLZPsyU/nb4fAEb50vZ/YXEBPLsP5v62meXue +A3v5mfmprl080vmLVriXdjHBcTIi17rFCVRfoXOghocEBQhH5NJmepUf8Tfmj/1dtb/6SLv/AJqy +f5fD/Nj8gjxPN3+JvzR/6u2t/wDSRd/81Y/l8P8ANj8gviebv8Tfmj/1dtb/AOki7/5qx/L4f5sf +kF8Tzd/ib80f+rtrf/SRd/8ANWP5fD/Nj8gviebv8Tfmj/1dtb/6SLv/AJqx/L4f5sfkF8Tzd/ib +80f+rtrf/SRd/wDNWP5fD/Nj8gviebv8Tfmj/wBXbW/+ki7/AOasfy+H+bH5BfE83f4m/NH/AKu2 +t/8ASRd/81Y/l8P82PyC+J5u/wATfmj/ANXbW/8ApIu/+asfy+H+bH5BfE83f4m/NH/q7a3/ANJF +3/zVj+Xw/wA2PyC+J5u/xN+aP/V21v8A6SLv/mrH8vh/mx+QXxPN3+JvzR/6u2t/9JF3/wA1Y/l8 +P82PyC+J5u/xN+aP/V21v/pIu/8AmrH8vh/mx+QXxPN3+JvzR/6u2t/9JF3/AM1Y/l8P82PyC+J5 +u/xN+aP/AFdtb/6SLv8A5qx/L4f5sfkF8Tzd/ib80f8Aq7a3/wBJF3/zVj+Xw/zY/IL4nm7/ABN+ +aP8A1dtb/wCki7/5qx/L4f5sfkF8Tzd/ib80f+rtrf8A0kXf/NWP5fD/ADY/IL4nm7/E35o/9XbW +/wDpIu/+asfy+H+bH5BfE82j5t/M+Aes2ta3EI/i9U3N2vGnfly2x/LYT/DH5BePzZ15C/5yh/Mb +y7cxRaxcHzDpQIEsF2f9IC9zHc058v8AX5D9ea/VdiYcg9I4JeXL5NkchD688jeefLvnby/DrmhT ++rayEpLE4CywygAtFKtTxYV+RG4qDnH6nTTwT4JjdyIytkGY6XYq7FXYq7FXYq7FXjX/ADlH+YV1 +5W8hppunymHU/MMj2qSqaMltGoNwynxPNE/2WbrsPSDLl4pfTDf49GvJKg+VPy+8lP5ivecqM9rG +4jWFaqZpTvw57cVUULGvcfMdtYFk7Ac3Ua3VHGAI/XLk+jNK/LfSLS0SK4JYqDSGCkUCV3PBVAPX +vtXwzWT7TlfoAA+11f5Xi3mTIo608meV/wBL2lnLbSSLcc/92sB8Kk70IOU5+0s4xSmCPT5NuDRY +pZBEjmyu2/KnydcFgliF4ip5TT/wY5ov5f1f877B+p2/8kaf+b9pVv8AlT3lL/lkT/kdcf1w/wAv +az+d9kf1I/kjTfzftLR/J/yl/wAsif8AI65/rj/L2s/nfZH9S/yRpv5v2lafyg8p/wDLKn/I65/r +h/l3Wfzvsj+pf5J03837S0fyh8p/8sqf8jrn+uP8u6z+d9kf1L/JOm/m/aWj+UXlP/llj/5HXP8A +XH+XdZ/O+yP6l/knTfzftLX/ACqPyn/yzR/8jrn+uH+XNb/O+yP6l/knTd32lr/lUflX/lmj/wCR +1z/XB/Lmt/nfZH9S/wAk6bu+0u/5VD5W/wCWaP8A5HXP9cf5d1n877I/qX+SdN/N+0u/5VB5Y/5Z +ov8Akdc/1x/l3Wfzvsj+pf5J03837S7/AJU/5a/5Zov+R1z/AFx/l3Wfzvsj+pf5J03837S7/lT3 +lv8A5Zov+R1z/XB/L2s/nfZH9S/yRpv5v2l3/KnfLv8AyzRf8jrn+uP8vaz+d9kf1L/JGm/m/aXf +8qc8v/8ALNF/yOuf64/y9rP532R/Uv8AJGm/m/aXf8qb0H/lmh/5HXP9cf5f1n877I/qX+SNN/N+ +0u/5U1oP/LND/wAjrn+uD+X9Z/O+wfqT/JGn/m/aVk/5P6BDBJM1rEVjUswE1xWg8KnH/RBq/wCd +9g/Uv8kaf+b9pYp5i8oeXLOGBoLQo0j8SRJIe3+Uxza9ldq6jNKQnLkO4Ov1/Z2HGAYj7SkreXdK +IoEZD/Mrmo+Vaj8M3I1eR1fgRee/mD+W8NxE91ZIPrhq0UygL6rbt6ctNubfssevy6XwmJjbYjo5 +ml1csUhGRuB+xJP+cfvzGvfJvny1T1T+iNXdLTUbcn4SWNIpPZkduvgTmq7Z0gy4Sf4obj9L0WOV +F93xSJLGsiGqOAyn2O+cK5K7FXYq7FXYq7FXYq+R/wDnM65lbzjoFsT+6i05pEG/2pJ2VvbpGM6/ +2cH7uR/pfocfNzb/ACCs7caXZzBAJPQuJS3fn9ZMXL/gNs2uvkRirvl+h0GffUm+kfx972EnNKyU +LXfzNpZ/4y/8QOOo/wAWn8PvbdN/fRei6SPjl/1R+vOWDvyjyMsQsIwoWkYVWEYULSMKFhGSVrFV +wOBVwOBVwOBK4HFVwOBK4HAq4HAlcDgVQ1I/7jrn/jE36siUh5X5uH+j23tL/DN52F9U/c6vtX6Q +x0nOidEgNZodNmBAP2aE9jzG4+jL9P8AWGrL9JfNGuSmDzPqEsICGK9maNRsF4ykgCnhmRKArhel +08iccT5B+iHk+4afQbcsalBx+8Bv+Ns8wdknWKuxV2KuxV2KuxV8hf8AOZn/ACneif8AbLH/AFES +52Hs7/dS/rfoDj5uaO/IUf7gbI/8ulx/1GnNlr/7v/O/Q6DN/jEv6v6nqxOahksshXzJpv8Az0/4 +gcjqf8Xn8PvbdL/exei6SPjk/wBUfrzlw9AmBGTYrSMKrCMKFpGFVhGFC0jChYRklaxVcDgVcDgV +cDgSuBxVcDgSuBwKuBwJUdRP+4+5/wCMTfqyJSHlvmwf6Lb+0n8M3XYX1S9zq+1fpDwzzXoX1nzD +eT8a82U1/wBgBm1y6fikS6qGfhFJt5T076lomoJSnOSM/dTMzQYuCTj6rJxh4h5k/wCUi1T/AJjJ +/wDk62bM83fab+6j/VH3P0N8jf8AHBj+Y/5NpnlztGQYq7FXYq7FXYq7FXyF/wA5mf8AKd6J/wBs +sf8AURLnYezv91L+t+gOPm5ph+Q4/wCddsj/AMutx/1Gtmx1/wBH+d+h0Gb/ABiX9X9T1InNUl2n +b+Y9P/56f8QOQ1X+Lz+H3t+l/vYvRtJH7yT/AFR+vOWDv0xIySFhGSQtIwqsIwoWkYVWEYULSMKF +hGSVrFVwOBVwOBVwOBK4HFVwOBK4HAqjf/8AHPuf+MTfqyEkh5j5rH+iQ/65/Uc3XYf1y9zre1Pp +DDpbGzkcu8QZ26k50weeMQoXVvDDZyrEgQNQkD5jLMX1BhMbPmrzN/ykmrf8xlx/ydbMp6XTf3cf +6o+5+hnkb/jgx/Mf8m0zy52bIMVdirsVdirsVdir5C/5zM/5TvRP+2WP+oiXOw9nf7qX9b9AcfNz +TL8iR/zrFif+Xa4/6jWzYa76f879Doc/9/L3fqenE5rEL9KFfMNh85P+IHK9X/cT+H3uRpP72L0f +SR+8k/1f45yzv0xIwqtIwoWEZJC0jCqwjChaRhVYRhQtIwoWEZJWsVXA4FXA4FXA4ErgcVXA4EqV +9/vBc/8AGJv1ZCXJIea+ah/ocfsx/wCInNx2H9cvcHW9qfQGIE507z6HvN7dx8v1jLMfNhPk+Z/N +H/KTav8A8xtx/wAnWzJek0/93H+qPufoX5G/44MfzH/JtM8vdmyDFXYq7FXYq7FXYq+Qv+czP+U7 +0T/tlj/qIlzsPZ3+6l/W/QHHzc0z/Isf86nYH/l3uP8AqNbM/W8v879Doc/9/L3fqelk5rkK2j76 +/ZfN/wDiBynWf3Evx1cjSf3oej6UP3r/AOr/ABzl3fpliq0jCq0jChYRkkLSMKrCMKFpGFVhGFC0 +jChYRklaxVcDgVcDgVcDgSuBxVTvP94rn/jE36shPkyDzjzUP9BX5n/iJzbdifXL4Ou7U+gfFhhO +dS86pXG8TD5frycebGXJ8z+av+Un1j/mNuf+TrZkh6TT/wB3H+qPufoV5G/44MfzH/JtM8vdmyDF +XYq7FXYq7FXYq+Qv+czP+U70T/tlj/qIlzsPZ3+6l/W/QHHzc01/I0f86fp5/wCKLj/qNbM7W8v8 +79Dos/8AfH3fqejE5gMEVoe+u2fzf/iByjW/3Evx1cnR/wB4Ho+l/wB4/wAv45y7v0xxV2KrSMKr +SMKFhGSQtIwqsIwoWkYVWEYULSMKFhGSVrFVwOBVwOBVwOBKy6P+h3H/ABib9WQnySHnnmkf6APY +t/xE5texPrPwdf2n9A+LByc6t5xTfcEZIIL5p82f8pTrP/Mdc/8AJ5syRyek0/8Adx9w+5+hPkb/ +AI4MfzH/ACbTPL3ZsgxV2KuxV2KuxV2KvkL/AJzM/wCU70T/ALZY/wCoiXOw9nf7qX9b9AcfNzTf +8jx/zpWnH/im4/6jHzO1n6f0Oi1H98fd+p6ETmE1o3y/vrdr82/4gcxtd/cycrR/3gej6b/eP8v4 +5y7v0wxV2KuxVaRhVaRhQsIySFpGFVhGFC0jCqwjChaRhQsIyStYquBwKuBwKtuT/olx/wAYm/Vk +J8mUXn/mkf7jj/sv+InNp2L/AHh+Dr+0/oHxYGTnWvONDdgMUPmnzb/yletf8x9z/wAnmzIjyelw +f3cfcH6EeRv+ODH8x/ybTPMHZMgxV2KuxV2KuxV2KvkL/nMz/lO9E/7ZY/6iJc7D2d/upf1v0Bx8 +3NOPyRH/ADo2mn/im4/6jHzN1fP4/odHqP70+5n5OYjUmHlzfWrb5t/xA5ia7+5k5Wi/vA9H07+8 +f5fxzmHfo/FXYq7FXYqtIwqtIwoWEZJC0jCqwjChaRhVYRhQtIwoWEZJWsVXA4Fan/3luP8AjE36 +shk5MosD80D/AHGt8m/4gc2XY394fg4Haf0fN56TnXvNLod5VHz/AFYJclD5p83/APKWa3/zH3X/ +ACebMiPIPS4P7uPuD9CPI3/HBj+Y/wCTaZ5g7JkGKuxV2KuxV2KuxV8hf85mf8p3on/bLH/URLnY +ezv91L+t+gOPm5p1+SYp5B0w/wDFVx/1GPmZq/q+P6HR6n+9PuZ0TmM0pr5Y31iD5t/xA5h6/wDu +i5mi/vA9G0/7b/LOYd8jsVdirsVdirsVWkYVWkYULCMkhaRhVYRhQtIwqsIwoWkYULCMkrWKul/3 +mn/4xt+rK8nJMebB/NA/3Fyf6r/8QObHsb+8Pw+9we0/o+bzgnOxeZVLXe4QfP8AUcjPkmPN81ec +f+Uu1z/toXX/ACebL4fSHpcH0R9wfoP5G/44MfzH/JtM8xdkyDFXYq7FXYq7FXYq+Qv+czP+U70T +/tlj/qIlzsPZ3+6l/W/QHHzc08/JUf8AIPNLP/Fdx/1GSZl6r6z7/wBDpNT/AHh9zNicocdOPKu+ +rQ/M/wDEGzB7Q/ui5uh+sPRbEhXappt3zmXfI3mn8w+/FXeon8w+/FWvUj/mH3jFXepH/MPvGKu9 +WP8AnH3jFXepF/Ov3jFVpeP+dfvGG1Wl4/51+8YbQtLJ/Mv3jDa0tJT+ZfvGHiCKWnj/ADL/AMEP +64eILS08f5l/4If1w8QRS0qP5l/4If1w8YWlpUfzL/wS/wBceMIorCn+Uv8AwS/1w8YXhKyai289 +WXeNgPiB3I+eRnIEJiGFeZx/uKm/1H/4gc2PY/8AefL73B7S+j5vNCc7N5dWsN7uMfP/AIichl+k +so83zX5z/wCUw13/ALaF1/yffL8f0j3PS4foj7g/QbyN/wAcGP5j/k2meYuyZBirsVdirsVdirsV +fIX/ADmZ/wAp3on/AGyx/wBREudh7O/3Uv636A4+bmnv5Lj/AJBxpZ/yLj/qMkzK1X1n3/odJqv7 +w+5mZOVOOmvly5jtrwTyAlIzuFpXdSO9Mw9bjM4cI6uVpJiMrLK/8T2H++5fuX/mrNL/ACdk7x+P +g7b85DuLX+JbD/fcv3L/AM1Y/wAnZO8fj4L+ch3Fr/Elj/vuX7l/5qx/k7J3j8fBfzkO4tf4jsf9 +9y/cv/NWP8nZO8fj4L+ch3Fo+YrH/fcv3L/zVj/J2TvH4+C/nIdxW/4hsv5JPuX/AJqx/k7J3j8f +BfzkO4tfp+y/kk+5f+asf5Oyd4/HwX85DuLX6es/5JPuX/mrH+TsnePx8F/OQ7i1+nbP+ST7l/5q +x/k7J3j8fBfzkO4tfpy0/kk+5f64/wAnZO8fj4L+ch3Fr9N2n8kn3L/XH+TsnePx8F/OQ7i0datf +5JPuX+uP8nZO8fj4L+ch3Fb+mLX+R/uH9cf5Oyd4/HwX85DuLX6Xtv5H+4f1x/k7J3j8fBfzkO4t +fpa2/lf7h/XH+TsnePx8F/OQ7i0dVt/5X+4f1x/k7J3j8fBfzkO4tHVLf+V/uH9cf5Oyd4/HwX85 +DuKW6/dxz6XcKgYFY5DvT+Q++bDs7TSx5Bdbkfe4etzicNvN5sTnWPOojTN7+If63/ETleb6Cyhz +fNnnX/lMte/7aN3/AMn3y/H9I9z02H6B7g/QXyN/xwY/mP8Ak2meYuxZBirsVdirsVdirsVfIX/O +Zn/Kd6J/2yx/1ES52Hs7/dS/rfoDj5uaf/kyP+QZ6Uf8m4/6jJMytT/eH8dHS6r6z7mXk5W4rSyy +JXgxWvWhIxMQVEiOTjdXH+/X/wCCOPAO5eM9603Vz/v1/wDgjh4I9y8Z71pu7n/fz/8ABHDwR7kc +Z71pu7r/AH8//BH+uHw49y8cu9aby6/39J/wR/rh8OPcEccu9ab27/3/ACf8E39cPhx7gjjl3rTe +3f8Av+T/AINv64fDj3BfEl3rTfXn+/5P+Db+uHw49wR4ku8rTfXv/LRJ/wAG39cPhR7gviS7ytN/ +e/8ALRJ/wbf1w+FHuCPEl3ladQvv+WiX/g2/rh8KPcEeJLvK06hff8tMv/Bt/XD4Ue4L4ku8rTqN +/wD8tMv/AAbf1w+FDuCPEl3ladRv/wDlpl/4Nv64fBh3D5L4ku8rTqWof8tUv/Bt/XD4MO4fJHiy +7ytOp6h/y1Tf8jG/rh8GHcPkjxZd5aOp6j/y1Tf8jG/rh8GHcPkviy7ypvqN+6lWuZWVhRlLsQQe +xFcIwwHQfJByS7yhScta0Xo++pQj/W/4icq1H0Fnj+p82+d/+Uz1/wD7aN3/AMn3y7F9I9z02H6B +7g/QTyN/xwY/mP8Ak2meZOxZBirsVdirsVdirsVfIX/OZn/Kd6J/2yx/1ES52Hs7/dS/rfoDj5ub +IfybH/ILtJPtcf8AUZLmTqP70/jo6XVfWWVE5FxFpOFVpOFDCLz82fLtrdz2slteGSCRonKpFQlC +VNKyDbbLRjLLgKgfzh8tf8s17/wEX/VXD4ZXwytP5weWv+Wa9/4CL/qrjwFHhlo/m95b/wCWa8/4 +CL/qrh4Cvhlo/m75b/5Zrz/gIv8Aqrh4V8Mrf+Vt+XD/AMe15/wEX/VXCIFHhF3/ACtjy6f+Pa8/ +4CL/AKqZMYijwy1/ytXy8f8Aj3u/+Ai/6qZYNPJHhl3/ACtPy+f+Pe7/AOAj/wCqmTGll5I8Mtf8 +rQ0A/wDHvd/8BH/1UywaKfkjwy7/AJWboR/497r/AICP/qpkx2fPvCOAtf8AKytDP+6Lr/gI/wDq +pkx2bk7x+PgjgLY/MXRT0guf+Bj/AOa8P8nZO8fj4LwFseftIPSG4/4FP+a8f5Pn3j8fBHAUTY+b +dOvbqO2iimWSQkKXVQNhXejHwyGTSSiLNIMSE4JzGYLCcKFpOFCN0PfVYB/rf8QOU6n+7LZi+oPm +7zx/ymvmD/tpXn/J98uxfQPcHpsX0D3B+gfkb/jgx/Mf8m0zzJ2LIMVdirsVdirsVdir5C/5zM/5 +TvRP+2WP+oiXOw9nf7qX9b9AcfNzZF+To/5BVpB9rj/qMlzI1H98fx0dNq/qLJycXDWk4ULScKEq +/IbT7OTVvMty0S/Wm1BoRPQcxHVmKqT0BPXNL25M3EdKd52bEUS9s/RNv/O/3j+maC3Zu/RNv/O/ +3j+mNq79E2/87/eP6Y2rv0Tb/wA7/eP6Y2rv0Tb/AM7/AHj+mNq79E2/87/eP6Y2rv0Tb/zv94/p +jau/RNv/ADv94/pjau/RNv8Azv8AeP6Y2rv0Tb/zv94/pjau/RNv/O/3j+mNq80/PXTbMeUJmaMP +LbyQvBKwBZC8gRqEU6qc6L2YyyjqwAdpA38nA7RiDiJ7nzykeekEvOpz5cSmsWx9z/xE5jak+gsZ +cmeE5qWhaThQtJwqj/L2+sW4/wBf/iDZRq/7s/jq2YfqD5v89f8AKb+Yf+2nef8AUQ+W4foHuD02 +L6R7n6BeRv8Ajgx/Mf8AJtM8zdiyDFXYq7FXYq7FXYq+Qv8AnMz/AJTvRP8Atlj/AKiJc7D2d/up +f1v0Bx83Nkn5Pj/kEujn/mI/6jJcvz/35/HR02r+osjJyThLScKFhOSQgvyCamo+YR46o3/G2aHt +z6o+533Zv0l7pmhdk7FXYq7FXYq7FXYq7FXYq7FXYq8w/PPfytdr7wf8nRm/9m/8bj7pfc4PaP8A +cn4PntI89IJebTXQUpqlufc/8ROY+c+gsZcmZk5rWhaThVaThQmPlrfW7Yf6/wDybbMfWf3R/HVt +wfWHzh58/wCU58xf9tO8/wCoh8twfRH3B6fH9I9z9AfI3/HBj+Y/5NpnmbsGQYq7FXYq7FXYq7FX +yF/zmZ/yneif9ssf9REudh7O/wB1L+t+gOPm5sm/KEf8gh0Y+9x/1GTZdm/vz+OgdPrOZT8nLHAW +E5JC0nCqX/kO9NT8wf8AbUb/AI2zQ9ufVH3O+7N+kvdPUzQ07Jg/5n+a7ny3o9zq0CGY20cREHMx +hvUnEfUA9OVemZmh03jZRC6u/utpz5eCBl3PIv8AoY3V/wDq1j/pKf8A5ozoR7NxP8f2ftdf/KR/ +m/ay/wDLf81dQ826lcW0tsbQWypJyWZpOXJuNKELmu7U7JGliJCXFZ7nJ0ur8UkVVPZvUzR05rvU +xpXepjSu9TGld6mNK71MaV3qY0rzP8625eXrlf8AjB/ydGb32c/xuPul9zg9o/3J+DwdI89FJebT +PRkpqEJ9z+o5RmPpLCXJlJOYLStJwoWE4UJp5V31+1H/ABk/5NtmNrf7o/D727T/AFh84efv+U68 +x/8AbUvf+oh8swf3cfcHp8f0j3P0B8jf8cGP5j/k2meaOwZBirsVdirsVdirsVfIX/OZn/Kd6J/2 +yx/1ES52Hs7/AHUv636A4+bmyf8AKMf8gc0U/wCVcf8AUZNl2b/GD+OgdPrOZTsnLnXrScKrScKE +s/I1qanr3/bTb/jbND22PVH3O/7N+kvb/UzROyeYfny9fJmoj/iu2/6i0zbdiD/CofH/AHJcTW/3 +R+H3vmQDPQ4wefep/kEeOuah/wAYov8Ak5nOe1Eaxw/rH7nZdmfUfc+l/UziXcu9TFXepirvUxV3 +qYq71MVd6mKvOPzhblolwPaH/k5m79nv8aj7j9zgdo/3J+DxdI89BJebTDTEpeRH3P6jlOQ7MZck +/JzFaFhOFC0nCqbeUd/MVoP+Mn/Jpsxdf/cy+H3hu031h84/mB/ynnmT/tqXv/UQ+Waf+7j/AFR9 +z0+P6R7n6AeRv+ODH8x/ybTPNHYMgxV2KuxV2KuxV2KvkL/nMz/lO9E/7ZY/6iJc7D2d/upf1v0B +x83NlP5TD/kC+iH/AC7n/qMmy3L/AIzL8dA6jWcym5OZDrlpOFC0nChKfyUbjqmue+pN/wAbZpO3 +h6of1Xf9m/SXtXqZz9Oyeafnm9fKOoD/AIrt/wDqKXNz2CP8Lh/nf7kuJrv7o/D73zaFz0mMHnre +nfkWeOt33/GKP/k5nMe1kaxQ/rH7nZ9l/Ufc+j/UzhKdy71MaV3qY0rvUxpXepjSu9TGld6mNK8/ +/NduWlzL7Rf8nM3XYH+NR+P3OD2l/cn4PJEjzvSXmkbYpS4Q/wCfTKpnZjLkmpOUtC0nCq0nJITj +ybv5lsx/xk/5NPmH2h/cy+H3hv0394Hzl+YP/KfeZf8Atq3v/US+Waf+7j/VH3PTw+kPv/yN/wAc +GP5j/k2meaOwZBirsVdirsVdirsVfIX/ADmZ/wAp3on/AGyx/wBREudh7O/3Uv636A4+bmyv8qB/ +yBPRD/xZc/8AUZNlmT/GpfjoHUa1MycynWrScKFhOFUn/JxuOqa1/wBtJv8AjbNR7QD1Q/qu+7M+ +kvZfUznKdm83/Ox+XlW/H/Fdv/1Erm69nh/hkP8AO/3JcTXf3J+H3vncLnp8YvOPSvyUHDWL0+Mc +f/E85P2u/uof1j9ztOy/qPufQ3qZwVO6d6mNK71MaV3qY0rvUxpXepjSu9TGlYJ+ZjcrGUe0X/E8 +3HYX+Mx+P3OB2l/cn4PNEjzuSXmkVbpSRTlZLGXJFk5FpWk5JC0nChOvJG/miyH/ABl/5MvmF2l/ +cS+H3hyNL/eD8dHzn+Yf/Kf+Zv8AtrX3/US+T0391H+qPueoh9Iff3kb/jgx/Mf8m0zzVz2QYq7F +XYq7FXYq7FXyF/zmZ/yneif9ssf9REudh7O/3Uv636A4+bmyz8qv/JHaGf8Aiy5/6jJ8nk/xuXu/ +QHUa1MCczHWLCcKrScKEk/KN+Gqaz/20W/42zV+0Y3x/1Xfdl/SXr31gZzVO0Yv520E+YLSSwbms +EyIHkjKhgUk9Tbl8hmXodXLTZRliATG+fmKas2IZImJ6sFH5J2Q/3ddffF/TOh/0W5/5kPt/W4P8 +lw7ynvlX8v18vXbz25mkMoVX9QpQBWrtxAzV9pdsZNXERkAOHutyNPpI4iSDzei/WBmnpy3fWBjS +u+sDGld9YGNK76wMaV31gY0rvrAxpWGfmA4kt5B/kx/8Tzbdi/4wPj9zgdpf3J+DAkjztCXmldEp +vkbYy5Licm0LScKFhOFU98ib+a7H/nr/AMmXzB7T/wAXl8PvDkaT+8H46PnT8xf/ACYPmf8A7a19 +/wBRL5PTf3Uf6o+56iHIPv3yN/xwY/mP+TaZ5q57IMVdirsVdirsVdir5C/5zMB/x1oh7fosf9RE +udh7O/3Uv636A4+bmyz8qv8AyRuh07S3Ffb/AEyfJz/xuXu/QHUa3kjSczXWLScKFpOFDH/ywfhq +OsH/AJf2/W2a72lG+P8AqO+7L+kvT/rXvnMU7R31r3xpXfWvfGld9a98aV31r3xpXfWvfGld9a98 +aV31r3xpXfWvfGld9a98aV31r3xpWM+bpPUiYeyf8Szadj/4wPj9zg9pf3J+DFUjzsCXmVVkpGTg +id2MuSHJy9oWE4VWk4UJ95CqfNljQbD1a/8AIl8wO1P8Xl8PvDkaP+8H46PnX8xf/Jg+Z/8AtrX3 +/US+T0v91H+qPuephyD798jf8cGP5j/k2meaueyDFXYq7FXYq7FXYq+b/wDnMvyrcXGj6F5ngQtH +YSSWV6QK8VuOLxMfBQ8bLXxYZ0vs7nAlLGeu4+DTmHVif/OOXm+xvdGvfImoTiO5LvdaSXbZlIDS +RINt0ZfUp1ILeGbPtDGYTGUfF12pxcQZ/fafeWUhjuIytDQPT4W+Ry3FljMWC6acDHmhCcta1hOF +Uo/KW39fzBf2/X1dQYU/4LNf7UHfH/Ud92V9Je4/4U/yPwzkuN2tO/wp/kfhjxrTv8Kf5H4Y8a07 +/Cn+R+GPGtO/wp/kfhjxrTv8Kf5H4Y8a07/Cn+R+GPGtO/wp/kfhjxrTv8Kf5H4Y8a07/Cn+R+GP +GtO/wp/kfhjxrTz78wrH6lf/AFelKxI1Pmx/pm27GN5x8fucDtP+5PwYmkedcS8wuuEpbufb+OMD +6mMuSWE5ltK0nChyJJK4jjUu7bKqgkk+wGJIAsqBfJldi1p5F0G982+Yf3BjjMdlZsQsskjbqig/ +tvxoB2FSds0Wu1H5iQxY9+8u20OlINl82eV7HUPNvny1WWs1zqF4bm8cDqC5lmb2rvT3zK1mUYMB +PdGh9wd/AWafoD5TtzBo6L2LEj5ABf8AjXPPHLTjFXYq7FXYq7FXYql/mDQdL8waLeaLqsIuNPv4 +mhuIj3Vu4PZlO6nsd8sxZZY5CUeYQRb4V/NL8oPNv5a656pEs2kiX1NL1uDko+FqpzZf7qVdtvHd +Sc7vQ9o49TGuUusfxzDjTgQmOjf85K/mRp1klrMbLUymy3F5C5loBQAtDJCG+ZFfE4z7KxSN7j3O +OcUSj/8Aoaf8wf8Aq36T/wAibn/soyH8kYu+X2fqR4Ad/wBDT/mD/wBW/Sf+RNz/ANlGP8kYu+X2 +fqXwAoN/zkl5puryK6v9OtRJACIHsXmtXUk9SzvcfgBlObsSEuUiPfv+puxejkjP+hnPMn++bz/u +JS/9U8xv9Dw/n/7H9rd4rv8AoZzzJ/vm8/7iUv8A1Tx/0PD+f/sf2r4rv+hnPMn++bz/ALiUv/VP +H/Q8P5/+x/aviu/6Gc8yf75vP+4lL/1Tx/0PD+f/ALH9q+K7/oZzzJ/vm8/7iUv/AFTx/wBDw/n/ +AOx/aviu/wChnPMn++bz/uJS/wDVPH/Q8P5/+x/aviu/6Gc8yf75vP8AuJS/9U8f9Dw/n/7H9q+K +7/oZzzJ/vm8/7iUv/VPH/Q8P5/8Asf2r4rv+hnPMn++bz/uJS/8AVPH/AEPD+f8A7H9q+K7/AKGc +8yf75vP+4lL/ANU8f9Dw/n/7H9q+K7/oZzzJ/vm8/wC4lL/1Tx/0PD+f/sf2r4qEm/5yR8yi8jvr +awikvEBQyahNLdjgRSg4mBh1/mPyy7D2FCJ3kT7hX62vJLjFK3/Q0/5g/wDVv0n/AJE3P/ZRmT/J +GLvl9n6nH8AO/wChp/zB/wCrfpP/ACJuf+yjH+SMXfL7P1L4Ad/0NP8AmD/1b9J/5E3P/ZRj/JGL +vl9n6l8AO/6Gn/MH/q36T/yJuf8Asox/kjF3y+z9S+AGj/zlP+YJH/HP0ke/o3P/AGUY/wAkYu+X +2fqXwQwPXvM/nfz/AKxF9emm1O7qRa2cS0jiDHf040AVR0qx32+I5lxhi08L2iO9tjCtg+ifyJ/J +ubQF+u36q+tXajmRusEXXiD+vxNPAE8f2r2l+YlUfoH2+f6nKhCn0XBCkEKQxiiRgKv0ZqGxfirs +VdirsVdirsVdiqhfWFlf2slpewpcW0o4yQyKGVh7g4QSNwryzXP+cZ/yy1G4a4i0xIGY1McTyQrX +5RMo/wCFzYY+1tTAUJn40fvYHGEp/wChVPy+/wCWAf8ASXdf1yf8tar+f9kf1L4cXf8AQqn5ff8A +LAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/ +rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n +/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF +3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff +8sA/6S7r+uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r ++uP8tar+f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+ +f9kf1L4cXf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4c +Xf8AQqn5ff8ALAP+ku6/rj/LWq/n/ZH9S+HF3/Qqn5ff8sA/6S7r+uP8tar+f9kf1L4cW1/5xW/L +9WDCwWo33urkj7icT2zqv5/2R/UvhxZl5Z/KLy9oKcLG1t7RduRgT42p4sQN/c5g5tRkym5yMmQA +DNrOytrSL04E4j9o9ST7nKUq+KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K +uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku +xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux +V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV//2Q== + + + + + + +uuid:f3c53255-be8a-4b04-817b-695bf2c54c8b + + + +image/svg+xml + + + +filesave.ai + + + + + + end='w' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/icons/undo-cross.png b/icons/undo-cross.png new file mode 100644 index 0000000000000000000000000000000000000000..7d57dcbd0f63427cd0de28a6108660e366b984e5 GIT binary patch literal 2004 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 AmH+?% literal 0 HcmV?d00001 diff --git a/icons/zoom-in.png b/icons/zoom-in.png new file mode 100644 index 0000000000000000000000000000000000000000..1ac4864d4a0c95a022e19ef38b4544711de39f1e GIT binary patch literal 1099 zcmV-R1ho5!P)af{SP@!vXJ%)ntuV;yBK7U0vPNwY9Zh{xzVtw>Ncs zeEdS!^^)P?VQOk>C@n2T2!ZRm*tU&nntb^1f#=Vkv%0$KM5EE+gM))>vk4THp`oD% z*=+Ww$B!SEjE|2KkH?8bB2-mX5s$~IuC68)ixCco35Ub9w6tIthJ5qp&B(ob_kKJ* zJw3h=P$(3>({;URVq$`DI7~DerMkMBa5zjb7$gt~5C{Ya27^Q*5kjF5&CSj1?d{3^ z{r%4^%lhV101436)|PTzw`Xi@jPmkwqR}YvcpOdB2m}H=di02afdL;Pr6d#z(bUvL zI-SPzyq>D6s?@cBTrM|~N~Nf+ttAu+QBhHW5CSPBLj2h#Ap}AQA0nlst*wn@GKpar zBi8~f%hJ2MyU{d_NF;&~0?+gCJnt{gMcY-o5Q6^xew0%BrvN1YN~wnW`g(%FpdWl- zV89P>Wj1_3CX?~?`}gkyG~5J02ti3n2}&uHQh1){!#9vmD5V19lc$8k_fVVWkkZBr-|*xlVlDRp>l4?NFXSz21c zG))SH0+wY_C=`6%bzNN7^=+nUVi*RNWnozsi;Ii6uDfzAKuVd(WHMy4Sq#GRMv$L~knue4TP1F272qFCb6j#Q@ z#RZd-lWc8mEd#wbP4aJ2%B`cLqpv=G{3zSo+x_Mh%VijbU!HtE&)L}-Gcz-+uC6-3 z*Fg5hRpGj>CWKht-Q6A8+}xD)_4SmMmHEMo^*%p8XM1~_>FH@+zkclidEiUn6!`hJ zb)5iWLWpNl%ASW0AJWy;MPp+l00##Lyn6MDmoHxeECWx07rQWzN|_ygF>@YIfg RUN-;$002ovPDHLkV1jl}0RjL3 literal 0 HcmV?d00001 diff --git a/icons/zoom-out.png b/icons/zoom-out.png new file mode 100644 index 0000000000000000000000000000000000000000..d67a87de533e307cb0e95ab2623259d98eb1adae GIT binary patch literal 1074 zcmV-21kL-2P)ZcG>Ma%D2N{kj*D)b>fpvF=zwm5 z5E-mXbGYn7^T$p^GpsN-Jnrg5T1P7C|(AOa;G)2(2OS^S;-Oc{m-T zrPvDx4(A=t@1Aow=RWwKkErw^ola*8g~FI=nwsM{ZAvMCBVg&#qer>*_4ObB6JUIN z{ORWA=36P{z~JB@Po6v>9*^U?E`>sYwY4>7XJ>I7XTG_)`Q_^B>TmxV@a);M%<1Xr zdri}-Mn^|!Y;2^ux*8z_uIpmkHiltva&p4EckftUUUp)!*y#TLe#LA8Wo2Y!N*^MnBpeRY-ri0&o5l0I zf%^LTOhrJUP#DW(GBh^|6Wo(=@fdzCMD% zAkk$*6OgHj5^FtBYK%d*(n*+D6FRIvx1=Pk|6&0!b@mStg@CYELSdRfXg!!Xcw z-M7!q&f>c6QbmB2GMCHc$mjFux=yK7Lf7?A#57GxrIIhEX`<^o+uPgB%*+7fDh`@u zS%wgz`{3XpH8?nk>$+H$<*x_JvaoI2&!P+~7K^-k^@_8zvw2|Zu1Wq=O8NWo@$on3 z=jXD!yW4MGIjFAdetAlz5?5DOym|A6<>h4u_zuY5xhh=O4GJOVcXoEhK79BfTU%SH zsj2aUm+M_D7TMa`;`Qs-tgNg!KneI7xCDN^Z(S#WxDev4lyacIzn|XTUQ($P0Q>v< zEG{mxu&@9y54;5417BQU_5%18`02g}CkcE7i~-t>AvywFLpdzpl%ce8{Ia30zH0O({*&9N-ElJ|v`^m66S6?PM}( sKQ!PbiK~#9!wU*CoR96(oKljb}2AN4rGl?J?Uud%EMjJ&JKEVVG z!nl};q=TD^kVeR+1>N}r;}nZUq?AL44q-HL)Vj{^+{y=l%Wtq*5sw8X9PBZYGsVkw_$n#bU%_F%pRcb#-+llS$gz z+L)f6wq|E%zX*ch`+4NpV`KJXxh;Tlxtz~tvm82fh-5NJUtix}PRl|FK{lHu zm&+l9KnTI*%a^PEj*bp8nGBxiNLje2sXyh)6=tKT?j#U zcQ;BYwcv{TLv=2|x%z zJRV0Wg)s&pM0LJpN~!9aF@`9LkWvyw(LbvFdj*U0^YhhjU2Bcj8Yv}GN^-dzxm<2X zvaQ%K44ImmLMgRa6JU%Pe){w&zV8!;AzEvUF@#}A5CmwgQA!bpAz>JzltODw5CjB4 zK(SavYdu_3BFnN0g+k%$d_GTmdwW#|&+`yMaPQtdgb-9J6{M6q{BPgB<;jyL0EOLJ zg=5?H52sI`?!0^VF1BrBSr)c!BZSy-CQ7Ml%lPo&1J|!#XJTSv2+9UUeVdVy5ea+;%= self.maxRecent: + self.recentFiles.pop() + self.recentFiles.insert(0, filename) + + def beginner(self): + return self._beginner + + def advanced(self): + return not self.beginner() + + ## Callbacks ## + def tutorial(self): + subprocess.Popen([self.screencastViewer, self.screencast]) + + def createShape(self): + assert self.beginner() + self.canvas.setEditing(False) + self.actions.create.setEnabled(False) + + def toggleDrawingSensitive(self, drawing=True): + """In the middle of drawing, toggling between modes should be disabled.""" + self.actions.editMode.setEnabled(not drawing) + if not drawing and self.beginner(): + # Cancel creation. + print 'Cancel creation.' + self.canvas.setEditing(True) + self.canvas.restoreCursor() + self.actions.create.setEnabled(True) + + def toggleDrawMode(self, edit=True): + self.canvas.setEditing(edit) + self.actions.createMode.setEnabled(edit) + self.actions.editMode.setEnabled(not edit) + + def setCreateMode(self): + assert self.advanced() + self.toggleDrawMode(False) + + def setEditMode(self): + assert self.advanced() + self.toggleDrawMode(True) + + def updateFileMenu(self): + current = self.filename + def exists(filename): + return os.path.exists(unicode(filename)) + menu = self.menus.recentFiles + menu.clear() + files = [f for f in self.recentFiles if f != current and exists(f)] + for i, f in enumerate(files): + icon = newIcon('labels') + action = QAction( + icon, '&%d %s' % (i+1, QFileInfo(f).fileName()), self) + action.triggered.connect(partial(self.loadRecent, f)) + menu.addAction(action) + + def popLabelListMenu(self, point): + self.menus.labelList.exec_(self.labelList.mapToGlobal(point)) + + def editLabel(self, item=None): + if not self.canvas.editing(): + return + item = item if item else self.currentItem() + text = self.labelDialog.popUp(item.text()) + if text is not None: + item.setText(text) + self.setDirty() + + # React to canvas signals. + def shapeSelectionChanged(self, selected=False): + if self._noSelectionSlot: + self._noSelectionSlot = False + else: + shape = self.canvas.selectedShape + if shape: + self.labelList.setItemSelected(self.shapesToItems[shape], True) + else: + self.labelList.clearSelection() + self.actions.delete.setEnabled(selected) + self.actions.copy.setEnabled(selected) + self.actions.edit.setEnabled(selected) + self.actions.shapeLineColor.setEnabled(selected) + self.actions.shapeFillColor.setEnabled(selected) + print 'shapeSelectionChanged' + + def addLabel(self, shape): + item = QListWidgetItem(shape.label) + item.setFlags(item.flags() | Qt.ItemIsUserCheckable) + item.setCheckState(Qt.Checked) + self.itemsToShapes[item] = shape + self.shapesToItems[shape] = item + self.labelList.addItem(item) + for action in self.actions.onShapesPresent: + action.setEnabled(True) + + def remLabel(self, shape): + item = self.shapesToItems[shape] + self.labelList.takeItem(self.labelList.row(item)) + del self.shapesToItems[shape] + del self.itemsToShapes[item] + + def loadLabels(self, shapes): + s = [] + for label, points, line_color, fill_color in shapes: + shape = Shape(label=label) + for x, y in points: + shape.addPoint(QPointF(x, y)) + shape.close() + s.append(shape) + self.addLabel(shape) + if line_color: + shape.line_color = QColor(*line_color) + if fill_color: + shape.fill_color = QColor(*fill_color) + self.canvas.loadShapes(s) + + def saveLabels(self, filename): + lf = LabelFile() + def format_shape(s): + return dict(label=unicode(s.label), + line_color=s.line_color.getRgb()\ + if s.line_color != self.lineColor else None, + fill_color=s.fill_color.getRgb()\ + if s.fill_color != self.fillColor else None, + points=[(p.x(), p.y()) for p in s.points]) + + shapes = [format_shape(shape) for shape in self.canvas.shapes] + try: + if self.usingPiscalVocFormat is True: + print 'savePascalVocFormat save to:' + filename + lf.savePascalVocFormat(filename, shapes, unicode(self.filename), self.imageData, + self.lineColor.getRgb(), self.fillColor.getRgb()) + else: + lf.save(filename, shapes, unicode(self.filename), self.imageData, + self.lineColor.getRgb(), self.fillColor.getRgb()) + self.labelFile = lf + self.filename = filename + return True + except LabelFileError, e: + self.errorMessage(u'Error saving label data', + u'%s' % e) + return False + + def copySelectedShape(self): + self.addLabel(self.canvas.copySelectedShape()) + #fix copy and delete + self.shapeSelectionChanged(True) + + def labelSelectionChanged(self): + item = self.currentItem() + if item and self.canvas.editing(): + self._noSelectionSlot = True + self.canvas.selectShape(self.itemsToShapes[item]) + + def labelItemChanged(self, item): + shape = self.itemsToShapes[item] + label = unicode(item.text()) + if label != shape.label: + shape.label = unicode(item.text()) + self.setDirty() + else: # User probably changed item visibility + self.canvas.setShapeVisible(shape, item.checkState() == Qt.Checked) + + ## Callback functions: + def newShape(self): + """Pop-up and give focus to the label editor. + + position MUST be in global coordinates. + """ + text = self.labelDialog.popUp() + if text is not None: + self.addLabel(self.canvas.setLastLabel(text)) + if self.beginner(): # Switch to edit mode. + self.canvas.setEditing(True) + self.actions.create.setEnabled(True) + else: + self.actions.editMode.setEnabled(True) + self.setDirty() + else: + #self.canvas.undoLastLine() + self.canvas.resetAllLines() + + def scrollRequest(self, delta, orientation): + units = - delta / (8 * 15) + bar = self.scrollBars[orientation] + bar.setValue(bar.value() + bar.singleStep() * units) + + def setZoom(self, value): + self.actions.fitWidth.setChecked(False) + self.actions.fitWindow.setChecked(False) + self.zoomMode = self.MANUAL_ZOOM + self.zoomWidget.setValue(value) + + def addZoom(self, increment=10): + self.setZoom(self.zoomWidget.value() + increment) + + def zoomRequest(self, delta): + units = delta / (8 * 15) + scale = 10 + self.addZoom(scale * units) + + def setFitWindow(self, value=True): + if value: + self.actions.fitWidth.setChecked(False) + self.zoomMode = self.FIT_WINDOW if value else self.MANUAL_ZOOM + self.adjustScale() + + def setFitWidth(self, value=True): + if value: + self.actions.fitWindow.setChecked(False) + self.zoomMode = self.FIT_WIDTH if value else self.MANUAL_ZOOM + self.adjustScale() + + def togglePolygons(self, value): + for item, shape in self.itemsToShapes.iteritems(): + item.setCheckState(Qt.Checked if value else Qt.Unchecked) + + def loadFile(self, filename=None): + """Load the specified file, or the last opened file if None.""" + self.resetState() + self.canvas.setEnabled(False) + if filename is None: + filename = self.settings['filename'] + filename = unicode(filename) + if QFile.exists(filename): + if LabelFile.isLabelFile(filename): + try: + self.labelFile = LabelFile(filename) + except LabelFileError, e: + self.errorMessage(u'Error opening file', + (u"

%s

" + u"

Make sure %s is a valid label file.")\ + % (e, filename)) + self.status("Error reading %s" % filename) + return False + self.imageData = self.labelFile.imageData + self.lineColor = QColor(*self.labelFile.lineColor) + self.fillColor = QColor(*self.labelFile.fillColor) + else: + # Load image: + # read data first and store for saving into label file. + self.imageData = read(filename, None) + self.labelFile = None + image = QImage.fromData(self.imageData) + if image.isNull(): + self.errorMessage(u'Error opening file', + u"

Make sure %s is a valid image file." % filename) + self.status("Error reading %s" % filename) + return False + self.status("Loaded %s" % os.path.basename(unicode(filename))) + self.image = image + self.filename = filename + self.canvas.loadPixmap(QPixmap.fromImage(image)) + if self.labelFile: + self.loadLabels(self.labelFile.shapes) + self.setClean() + self.canvas.setEnabled(True) + self.adjustScale(initial=True) + self.paintCanvas() + self.addRecentFile(self.filename) + self.toggleActions(True) + return True + return False + + def resizeEvent(self, event): + if self.canvas and not self.image.isNull()\ + and self.zoomMode != self.MANUAL_ZOOM: + self.adjustScale() + super(MainWindow, self).resizeEvent(event) + + def paintCanvas(self): + assert not self.image.isNull(), "cannot paint null image" + self.canvas.scale = 0.01 * self.zoomWidget.value() + self.canvas.adjustSize() + self.canvas.update() + + def adjustScale(self, initial=False): + value = self.scalers[self.FIT_WINDOW if initial else self.zoomMode]() + self.zoomWidget.setValue(int(100 * value)) + + def scaleFitWindow(self): + """Figure out the size of the pixmap in order to fit the main widget.""" + e = 2.0 # So that no scrollbars are generated. + w1 = self.centralWidget().width() - e + h1 = self.centralWidget().height() - e + a1 = w1/ h1 + # Calculate a new scale value based on the pixmap's aspect ratio. + w2 = self.canvas.pixmap.width() - 0.0 + h2 = self.canvas.pixmap.height() - 0.0 + a2 = w2 / h2 + return w1 / w2 if a2 >= a1 else h1 / h2 + + def scaleFitWidth(self): + # The epsilon does not seem to work too well here. + w = self.centralWidget().width() - 2.0 + return w / self.canvas.pixmap.width() + + def closeEvent(self, event): + if not self.mayContinue(): + event.ignore() + s = self.settings + # If it loads images from dir, don't load it at the begining + if self.dirname is None: + s['filename'] = self.filename if self.filename else QString() + else: + s['filename'] = '' + + s['window/size'] = self.size() + s['window/position'] = self.pos() + s['window/state'] = self.saveState() + s['line/color'] = self.lineColor + s['fill/color'] = self.fillColor + s['recentFiles'] = self.recentFiles + s['advanced'] = not self._beginner + if self.defaultSaveDir is not None: + s['savedir'] = str(self.defaultSaveDir) + else: + s['savedir'] = '' + # ask the use for where to save the labels + #s['window/geometry'] = self.saveGeometry() + + ## User Dialogs ## + + def loadRecent(self, filename): + if self.mayContinue(): + self.loadFile(filename) + + def scanAllImages(self, folderPath): + extensions = {'.jpeg','.jpg', '.png'} + images = [] + + for root, dirs, files in os.walk(folderPath): + for file in files: + if file.lower().endswith(tuple(extensions)): + relatviePath = os.path.join(root, file) + images.append(os.path.abspath(relatviePath)) + return images + + def changeSavedir(self, _value=False): + path = os.path.dirname(unicode(self.filename))\ + if self.filename else '.' + + if self.defaultSaveDir is not None and len(str(self.defaultSaveDir)) > 0: + path = unicode(self.defaultSaveDir) + + dirpath = unicode(QFileDialog.getExistingDirectory(self, + '%s - Save to the directory' % __appname__, path, QFileDialog.ShowDirsOnly + | QFileDialog.DontResolveSymlinks)) + self.defaultSaveDir = str(dirpath) + + def openDir(self, _value=False): + if not self.mayContinue(): + return + path = os.path.dirname(unicode(self.filename))\ + if self.filename else '.' + + dirpath = unicode(QFileDialog.getExistingDirectory(self, + '%s - Open Directory' % __appname__, path, QFileDialog.ShowDirsOnly + | QFileDialog.DontResolveSymlinks)) + + self.dirname = dirpath + self.mImgList = self.scanAllImages(dirpath) + self.openNextImg() + + def openNextImg(self, _value=False): + if not self.mayContinue(): + return + if len(self.mImgList) <= 0: + return + filename = self.mImgList.pop(0) + if filename: + self.loadFile(filename) + + def openFile(self, _value=False): + if not self.mayContinue(): + return + path = os.path.dirname(unicode(self.filename))\ + if self.filename else '.' + formats = ['*.%s' % unicode(fmt).lower()\ + for fmt in QImageReader.supportedImageFormats()] + filters = "Image & Label files (%s)" % \ + ' '.join(formats + ['*%s' % LabelFile.suffix]) + filename = unicode(QFileDialog.getOpenFileName(self, + '%s - Choose Image or Label file' % __appname__, path, filters)) + if filename: + self.loadFile(filename) + + def saveFile(self, _value=False): + assert not self.image.isNull(), "cannot save empty image" + if self.hasLabels(): + if self.defaultSaveDir is not None and len(str(self.defaultSaveDir)): + print 'handle the image:' + self.filename + imgFileName = os.path.basename(self.filename) + savedFileName = os.path.splitext(imgFileName)[0] + LabelFile.suffix + savedPath = os.path.join(str(self.defaultSaveDir), savedFileName) + self._saveFile(savedPath) + else: + self._saveFile(self.filename if self.labelFile\ + else self.saveFileDialog()) + + def saveFileAs(self, _value=False): + assert not self.image.isNull(), "cannot save empty image" + if self.hasLabels(): + self._saveFile(self.saveFileDialog()) + + def saveFileDialog(self): + caption = '%s - Choose File' % __appname__ + filters = 'File (*%s)' % LabelFile.suffix + openDialogPath = self.currentPath() + dlg = QFileDialog(self, caption, openDialogPath, filters) + dlg.setDefaultSuffix(LabelFile.suffix[1:]) + dlg.setAcceptMode(QFileDialog.AcceptSave) + dlg.setConfirmOverwrite(True) + dlg.setOption(QFileDialog.DontUseNativeDialog, False) + if dlg.exec_(): + return dlg.selectedFiles()[0] + return '' + #return unicode(QFileDialog.getSaveFileName(self, + # '%s - Choose File', self.currentPath(), + # 'Label files (*%s)' % LabelFile.suffix)) + + def _saveFile(self, filename): + if filename and self.saveLabels(filename): + self.addRecentFile(filename) + self.setClean() + + def closeFile(self, _value=False): + if not self.mayContinue(): + return + self.resetState() + self.setClean() + self.toggleActions(False) + self.canvas.setEnabled(False) + self.actions.saveAs.setEnabled(False) + + # Message Dialogs. # + def hasLabels(self): + if not self.itemsToShapes: + self.errorMessage(u'No objects labeled', + u'You must label at least one object to save the file.') + return False + return True + + def mayContinue(self): + return not (self.dirty and not self.discardChangesDialog()) + + def discardChangesDialog(self): + yes, no = QMessageBox.Yes, QMessageBox.No + msg = u'You have unsaved changes, proceed anyway?' + return yes == QMessageBox.warning(self, u'Attention', msg, yes|no) + + def errorMessage(self, title, message): + return QMessageBox.critical(self, title, + '

%s

%s' % (title, message)) + + def currentPath(self): + return os.path.dirname(unicode(self.filename)) if self.filename else '.' + + def chooseColor1(self): + color = self.colorDialog.getColor(self.lineColor, u'Choose line color', + default=DEFAULT_LINE_COLOR) + if color: + self.lineColor = color + # Change the color for all shape lines: + Shape.line_color = self.lineColor + self.canvas.update() + self.setDirty() + + def chooseColor2(self): + color = self.colorDialog.getColor(self.fillColor, u'Choose fill color', + default=DEFAULT_FILL_COLOR) + if color: + self.fillColor = color + Shape.fill_color = self.fillColor + self.canvas.update() + self.setDirty() + + def deleteSelectedShape(self): + yes, no = QMessageBox.Yes, QMessageBox.No + msg = u'You are about to permanently delete this Box, proceed anyway?' + if yes == QMessageBox.warning(self, u'Attention', msg, yes|no): + self.remLabel(self.canvas.deleteSelected()) + self.setDirty() + if self.noShapes(): + for action in self.actions.onShapesPresent: + action.setEnabled(False) + + def chshapeLineColor(self): + color = self.colorDialog.getColor(self.lineColor, u'Choose line color', + default=DEFAULT_LINE_COLOR) + if color: + self.canvas.selectedShape.line_color = color + self.canvas.update() + self.setDirty() + + def chshapeFillColor(self): + color = self.colorDialog.getColor(self.fillColor, u'Choose fill color', + default=DEFAULT_FILL_COLOR) + if color: + self.canvas.selectedShape.fill_color = color + self.canvas.update() + self.setDirty() + + def copyShape(self): + self.canvas.endMove(copy=True) + self.addLabel(self.canvas.selectedShape) + self.setDirty() + + def moveShape(self): + self.canvas.endMove(copy=False) + self.setDirty() + + +class Settings(object): + """Convenience dict-like wrapper around QSettings.""" + def __init__(self, types=None): + self.data = QSettings() + self.types = defaultdict(lambda: QVariant, types if types else {}) + + def __setitem__(self, key, value): + t = self.types[key] + self.data.setValue(key, + t(value) if not isinstance(value, t) else value) + + def __getitem__(self, key): + return self._cast(key, self.data.value(key)) + + def get(self, key, default=None): + return self._cast(key, self.data.value(key, default)) + + def _cast(self, key, value): + # XXX: Very nasty way of converting types to QVariant methods :P + t = self.types[key] + if t != QVariant: + method = getattr(QVariant, re.sub('^Q', 'to', t.__name__, count=1)) + return method(value) + return value + + +def inverted(color): + return QColor(*[255 - v for v in color.getRgb()]) + + +def read(filename, default=None): + try: + with open(filename, 'rb') as f: + return f.read() + except: + return default + +def main(argv): + """Standard boilerplate Qt application code.""" + app = QApplication(argv) + app.setApplicationName(__appname__) + app.setWindowIcon(newIcon("app")) + win = MainWindow(argv[1] if len(argv) == 2 else None) + win.show() + return app.exec_() + +if __name__ == '__main__': + sys.exit(main(sys.argv)) + diff --git a/lib.py b/lib.py new file mode 100644 index 00000000..821733b2 --- /dev/null +++ b/lib.py @@ -0,0 +1,63 @@ +from math import sqrt + +from PyQt4.QtGui import * +from PyQt4.QtCore import * + + +def newIcon(icon): + return QIcon(':/' + icon) + +def newButton(text, icon=None, slot=None): + b = QPushButton(text) + if icon is not None: + b.setIcon(newIcon(icon)) + if slot is not None: + b.clicked.connect(slot) + return b + +def newAction(parent, text, slot=None, shortcut=None, icon=None, + tip=None, checkable=False, enabled=True): + """Create a new action and assign callbacks, shortcuts, etc.""" + a = QAction(text, parent) + if icon is not None: + a.setIcon(newIcon(icon)) + if shortcut is not None: + if isinstance(shortcut, (list, tuple)): + a.setShortcuts(shortcut) + else: + a.setShortcut(shortcut) + if tip is not None: + a.setToolTip(tip) + a.setStatusTip(tip) + if slot is not None: + a.triggered.connect(slot) + if checkable: + a.setCheckable(True) + a.setEnabled(enabled) + return a + + +def addActions(widget, actions): + for action in actions: + if action is None: + widget.addSeparator() + elif isinstance(action, QMenu): + widget.addMenu(action) + else: + widget.addAction(action) + +def labelValidator(): + return QRegExpValidator(QRegExp(r'^[^ \t].+'), None) + + +class struct(object): + def __init__(self, **kwargs): + self.__dict__.update(kwargs) + +def distance(p): + return sqrt(p.x() * p.x() + p.y() * p.y()) + +def fmtShortcut(text): + mod, key = text.split('+', 1) + return '%s+%s' % (mod, key) + diff --git a/piscal_voc_writer.py b/piscal_voc_writer.py new file mode 100644 index 00000000..6d8f0d3a --- /dev/null +++ b/piscal_voc_writer.py @@ -0,0 +1,110 @@ +import sys +from xml.etree import ElementTree +from xml.etree.ElementTree import Element, SubElement +from xml.dom import minidom +from lxml import etree + +class PiscalVocWriter: + def __init__(self, foldername, filename, imgSize, databaseSrc='Unknown', localImgPath=None): + self.foldername = foldername + self.filename = filename + self.databaseSrc = databaseSrc + self.imgSize = imgSize + self.boxlist = [] + self.localImgPath = localImgPath + + def prettify(self, elem): + """ + Return a pretty-printed XML string for the Element. + """ + rough_string = ElementTree.tostring(elem,'utf8') + reparsed = minidom.parseString(rough_string) + return reparsed.toprettyxml(indent="\t") + + def genXML(self): + """ + Return XML root + """ + # Check conditions + if self.filename is None or \ + self.foldername is None or \ + self.imgSize is None or \ + len(self.boxlist) <= 0: + return None + + top = Element('annotation') + folder = SubElement(top,'folder') + folder.text = self.foldername + + filename = SubElement(top,'filename') + filename.text = self.filename + + localImgPath = SubElement(top,'path') + localImgPath.text = self.localImgPath + + source = SubElement(top,'source') + database = SubElement(source,'database') + database.text = self.databaseSrc + + size_part = SubElement(top,'size') + width = SubElement(size_part,'width') + height = SubElement(size_part,'height') + depth = SubElement(size_part,'depth') + width.text = str(self.imgSize[1]) + height.text = str(self.imgSize[0]) + if len(self.imgSize)==3: + depth.text = str(self.imgSize[2]) + else: + depth.text = '1' + + segmented = SubElement(top,'segmented') + segmented.text ='0' + + return top + + def addBndBox(self, xmin, ymin, xmax, ymax, name): + bndbox = {'xmin':xmin, 'ymin':ymin, 'xmax':xmax, 'ymax':ymax} + bndbox['name'] = name + self.boxlist.append(bndbox); + + def appendObjects(self, top): + for each_object in self.boxlist: + object_item = SubElement(top,'object') + name = SubElement(object_item, 'name') + name.text = str(each_object['name']) + pose = SubElement(object_item, 'pose') + pose.text = "Unspecified" + truncated = SubElement(object_item, 'truncated') + truncated.text = "0" + difficult = SubElement(object_item, 'difficult') + difficult.text = "0" + bndbox = SubElement(object_item, 'bndbox') + xmin = SubElement(bndbox, 'xmin') + xmin.text = str(each_object['xmin']) + ymin = SubElement(bndbox, 'ymin') + ymin.text = str(each_object['ymin']) + xmax = SubElement(bndbox, 'xmax') + xmax.text = str(each_object['xmax']) + ymax = SubElement(bndbox, 'ymax') + ymax.text = str(each_object['ymax']) + + def save(self, targetFile = None): + root = self.genXML() + self.appendObjects(root) + out_file = None + if targetFile is None: + out_file = open(self.filename + '.xml','w') + else: + out_file = open(targetFile, 'w') + + out_file.write(self.prettify(root)) + out_file.close() + +""" +# Test +tmp = PiscalVocWriter('temp','test', (10,20,3)) +tmp.addBndBox(10,10,20,30,'chair') +tmp.addBndBox(1,1,600,600,'car') +tmp.save() +""" + diff --git a/resources.qrc b/resources.qrc new file mode 100644 index 00000000..8875f58e --- /dev/null +++ b/resources.qrc @@ -0,0 +1,31 @@ + + + +icons/help.png +icons/expert2.png +icons/expert2.png +icons/done.png +icons/file.png +icons/labels.png +icons/objects.png +icons/close.png +icons/fit-width.png +icons/fit-window.png +icons/undo.png +icons/eye.png +icons/quit.png +icons/copy.png +icons/edit.png +icons/open.png +icons/save.png +icons/save-as.png +icons/color.png +icons/color_line.png +icons/zoom.png +icons/zoom-in.png +icons/zoom-out.png +icons/cancel.png +icons/next.png + + + diff --git a/shape.py b/shape.py new file mode 100644 index 00000000..8f6c237f --- /dev/null +++ b/shape.py @@ -0,0 +1,179 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +from PyQt4.QtGui import * +from PyQt4.QtCore import * + +from lib import distance + +DEFAULT_LINE_COLOR = QColor(0, 255, 0, 128) +DEFAULT_FILL_COLOR = QColor(255, 0, 0, 128) +DEFAULT_SELECT_LINE_COLOR = QColor(255, 255, 255) +DEFAULT_SELECT_FILL_COLOR = QColor(0, 128, 255, 155) +DEFAULT_VERTEX_FILL_COLOR = QColor(0, 255, 0, 255) +DEFAULT_HVERTEX_FILL_COLOR = QColor(255, 0, 0) + +class Shape(object): + P_SQUARE, P_ROUND = range(2) + + MOVE_VERTEX, NEAR_VERTEX = range(2) + + ## The following class variables influence the drawing + ## of _all_ shape objects. + line_color = DEFAULT_LINE_COLOR + fill_color = DEFAULT_FILL_COLOR + select_line_color = DEFAULT_SELECT_LINE_COLOR + select_fill_color = DEFAULT_SELECT_FILL_COLOR + vertex_fill_color = DEFAULT_VERTEX_FILL_COLOR + hvertex_fill_color = DEFAULT_HVERTEX_FILL_COLOR + point_type = P_ROUND + point_size = 8 + scale = 1.0 + + def __init__(self, label=None, line_color=None): + self.label = label + self.points = [] + self.fill = False + self.selected = False + + self._highlightIndex = None + self._highlightMode = self.NEAR_VERTEX + self._highlightSettings = { + self.NEAR_VERTEX: (4, self.P_ROUND), + self.MOVE_VERTEX: (1.5, self.P_SQUARE), + } + + self._closed = False + + if line_color is not None: + # Override the class line_color attribute + # with an object attribute. Currently this + # is used for drawing the pending line a different color. + self.line_color = line_color + + def close(self): + assert len(self.points) > 2 + self._closed = True + + def reachMaxPoints(self): + if len(self.points) >=4: + return True + return False + + def addPoint(self, point): + if self.points and point == self.points[0]: + self.close() + else: + self.points.append(point) + + def popPoint(self): + if self.points: + return self.points.pop() + return None + + def isClosed(self): + return self._closed + + def setOpen(self): + self._closed = False + + def paint(self, painter): + if self.points: + color = self.select_line_color if self.selected else self.line_color + pen = QPen(color) + # Try using integer sizes for smoother drawing(?) + pen.setWidth(max(1, int(round(2.0 / self.scale)))) + painter.setPen(pen) + + line_path = QPainterPath() + vrtx_path = QPainterPath() + + line_path.moveTo(self.points[0]) + # Uncommenting the following line will draw 2 paths + # for the 1st vertex, and make it non-filled, which + # may be desirable. + #self.drawVertex(vrtx_path, 0) + + for i, p in enumerate(self.points): + line_path.lineTo(p) + self.drawVertex(vrtx_path, i) + if self.isClosed(): + line_path.lineTo(self.points[0]) + + painter.drawPath(line_path) + painter.drawPath(vrtx_path) + painter.fillPath(vrtx_path, self.vertex_fill_color) + if self.fill: + color = self.select_fill_color if self.selected else self.fill_color + painter.fillPath(line_path, color) + + def drawVertex(self, path, i): + d = self.point_size / self.scale + shape = self.point_type + point = self.points[i] + if i == self._highlightIndex: + size, shape = self._highlightSettings[self._highlightMode] + d *= size + if self._highlightIndex is not None: + self.vertex_fill_color = self.hvertex_fill_color + else: + self.vertex_fill_color = Shape.vertex_fill_color + if shape == self.P_SQUARE: + path.addRect(point.x() - d/2, point.y() - d/2, d, d) + elif shape == self.P_ROUND: + path.addEllipse(point, d/2.0, d/2.0) + else: + assert False, "unsupported vertex shape" + + def nearestVertex(self, point, epsilon): + for i, p in enumerate(self.points): + if distance(p - point) <= epsilon: + return i + return None + + def containsPoint(self, point): + return self.makePath().contains(point) + + def makePath(self): + path = QPainterPath(self.points[0]) + for p in self.points[1:]: + path.lineTo(p) + return path + + def boundingRect(self): + return self.makePath().boundingRect() + + def moveBy(self, offset): + self.points = [p + offset for p in self.points] + + def moveVertexBy(self, i, offset): + self.points[i] = self.points[i] + offset + + def highlightVertex(self, i, action): + self._highlightIndex = i + self._highlightMode = action + + def highlightClear(self): + self._highlightIndex = None + + def copy(self): + shape = Shape("Copy of %s" % self.label ) + shape.points= [p for p in self.points] + shape.fill = self.fill + shape.selected = self.selected + shape._closed = self._closed + if self.line_color != Shape.line_color: + shape.line_color = self.line_color + if self.fill_color != Shape.fill_color: + shape.fill_color = self.fill_color + return shape + + def __len__(self): + return len(self.points) + + def __getitem__(self, key): + return self.points[key] + + def __setitem__(self, key, value): + self.points[key] = value + diff --git a/toolBar.py b/toolBar.py new file mode 100644 index 00000000..c0f370d5 --- /dev/null +++ b/toolBar.py @@ -0,0 +1,32 @@ +from PyQt4.QtGui import * +from PyQt4.QtCore import * + +class ToolBar(QToolBar): + def __init__(self, title): + super(ToolBar, self).__init__(title) + layout = self.layout() + m = (0, 0, 0, 0) + layout.setSpacing(0) + layout.setContentsMargins(*m) + self.setContentsMargins(*m) + self.setWindowFlags(self.windowFlags() | Qt.FramelessWindowHint) + + def addAction(self, action): + if isinstance(action, QWidgetAction): + return super(ToolBar, self).addAction(action) + btn = ToolButton() + btn.setDefaultAction(action) + btn.setToolButtonStyle(self.toolButtonStyle()) + self.addWidget(btn) + + +class ToolButton(QToolButton): + """ToolBar companion class which ensures all buttons have the same size.""" + minSize = (60, 60) + def minimumSizeHint(self): + ms = super(ToolButton, self).minimumSizeHint() + w1, h1 = ms.width(), ms.height() + w2, h2 = self.minSize + ToolButton.minSize = max(w1, w2), max(h1, h2) + return QSize(*ToolButton.minSize) + diff --git a/zoomWidget.py b/zoomWidget.py new file mode 100644 index 00000000..7c3d160f --- /dev/null +++ b/zoomWidget.py @@ -0,0 +1,20 @@ +from PyQt4.QtGui import * +from PyQt4.QtCore import * + +class ZoomWidget(QSpinBox): + def __init__(self, value=100): + super(ZoomWidget, self).__init__() + self.setButtonSymbols(QAbstractSpinBox.NoButtons) + self.setRange(1, 500) + self.setSuffix(' %') + self.setValue(value) + self.setToolTip(u'Zoom Level') + self.setStatusTip(self.toolTip()) + self.setAlignment(Qt.AlignCenter) + + def minimumSizeHint(self): + height = super(ZoomWidget, self).minimumSizeHint().height() + fm = QFontMetrics(self.font()) + width = fm.width(str(self.maximum())) + return QSize(width, height) +