HYTOS

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

class AreaZoomCommand(AbstractCommand.AbstractCommand):

    onRejected = pyqtSignal(AbstractCommand.AbstractCommand)

    '''

        @history    2018.06.27  Jeongwoo    Add variables [startPoint, endPoint]

    '''

    def __init__(self, imageViewer):

        super(AreaZoomCommand, self).__init__(imageViewer)

        self.imageViewer.setCursor(QCursor(Qt.CrossCursor))

        self._rubberBand = QRubberBand(QRubberBand.Rectangle, self.imageViewer)

        self._origin = QPoint()

        self.isLeftClicked = False

    '''

        @brief      pan image by left click and drag

        @history    2018.06.27  Jeongwoo    Add if-statement for panning after zoom in / Add variable [startPoint, endPoint]

                    humkyung 2018.08.29 use rubberband to select area

    '''

    def execute(self, param):

        event = param[1]

        scenePos = param[2]

        self.isTreated = False

        if 'mousePressEvent' == param[0]:

            if event.button() == Qt.LeftButton:

                    self._origin = event.pos()

                    self._rubberBand.setGeometry(QRect(self._origin, QSize()))

                    self._rubberBand.show()

                self.imageViewer.leftMouseButtonPressed.emit(scenePos.x(), scenePos.y())

        elif 'mouseMoveEvent' == param[0] and event.buttons() == Qt.LeftButton:

            if self._rubberBand.isVisible():

                    self._rubberBand.hide()

                    topLeft = self.imageViewer.mapToScene(self._rubberBand.geometry().topLeft())

                    bottomRight = self.imageViewer.mapToScene(self._rubberBand.geometry().bottomRight())

                    self.imageViewer.updateViewer()

                elif event.button() == Qt.RightButton:

                        self.onRejected.emit(self)

            finally:

                pass

        scenePos2 = self.imageViewer.mapToScene(pos.x() + 300, pos.y() + 300)

        if isZoomIn:

            zoomArea = QRectF(QPointF(scenePos1.x(), scenePos1.y()), QPointF(scenePos2.x(), scenePos2.y()))

            selectionBBox = zoomArea.intersected(viewBBox)

            self.imageViewer.scene.setSelectionArea(QPainterPath())  # Clear current selection area.

            if selectionBBox.isValid() and (selectionBBox != viewBBox):

            self.imageViewer.scene.setSelectionArea(QPainterPath())  # Clear current selection area.

            if len(self.imageViewer.zoomStack):

                self.imageViewer.zoomStack.pop()

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import Qt, QPointF, QRectF, pyqtSignal, QT_VERSION_STR

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QCursor

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

class ZoomCommand(AbstractCommand.AbstractCommand):

    def __init__(self, imageViewer):

        super(ZoomCommand, self).__init__(imageViewer)

        self.imageViewer.setCursor(QCursor(Qt.PointingHandCursor))

    '''

        @brief  pan image by left click and drag

    '''

    def execute(self, param):

        event = param[1]

        if 'mousePressEvent' == param[0]:

            if self.imageViewer.canZoom:

                    self.zoomImage(False, event.pos())

                else:

                    self.zoomImage(True, event.pos())

        scenePos1 = self.imageViewer.mapToScene(pos.x() - 300, pos.y() - 300)

        scenePos2 = self.imageViewer.mapToScene(pos.x() + 300, pos.y() + 300)

        if isZoomIn:

            zoomArea = QRectF(QPointF(scenePos1.x(), scenePos1.y()), QPointF(scenePos2.x(), scenePos2.y()))

            selectionBBox = zoomArea.intersected(viewBBox)

            self.imageViewer.scene.setSelectionArea(QPainterPath())  # Clear current selection area.

            if selectionBBox.isValid() and (selectionBBox != viewBBox):

                self.imageViewer.zoomStack.append(selectionBBox)

                self.imageViewer.updateViewer()

        else:

            self.imageViewer.scene.setSelectionArea(QPainterPath())  # Clear current selection area.

            if len(self.imageViewer.zoomStack):

                self.imageViewer.zoomStack.pop()

            self.actionOptions.triggered.connect(self.onOptions)

            self.actionZoom.triggered.connect(self.onAreaZoom)

            self.actionFitWindow.triggered.connect(self.fitWindow)

            self.actionSymbol_Editor.triggered.connect(self.showSymbolEditor)

            self.actionHelp.triggered.connect(self.on_help)

            self.actionAbout.triggered.connect(self.on_about)

    def eventFilter(self, source, event):

        """ display mouse position of graphics view """

            pos = self.graphicsView.mapToScene(event.pos())

            self._label_mouse.setText('mouse pos : ({},{})'.format(round(pos.x()), round(pos.y())))

        return QWidget.eventFilter(self, source, event)

    def load_stylesheet(self, file):

        QtWidgets.qApp.loadStyleSheet(os.path.join(os.path.dirname(os.path.realpath(__file__)), file))

            action.setChecked(False)

    def load_language(self, file):

        try:

            qm_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'translate', '{0}.qm'.format(file))

        self.graphicsView.useDefaultCommand()

        self.graphicsView.zoomImageInit()

    def scene_changed(self):

        """update modified flag"""

            if image_path:

                self.graphicsView.save_as_image(image_path)

                file_name = os.path.join(workspace, app_doc_data.activeDrawing.name + '.xlsx')

                options = QFileDialog.Options()

                options |= QFileDialog.DontUseNativeDialog

        from datetime import datetime

        from Drawing import Drawing

        options = QFileDialog.Options()

        options |= QFileDialog.DontUseNativeDialog

        self.save_drawing_if_necessary()

        options = QFileDialog.Options()

        options |= QFileDialog.DontUseNativeDialog

            self.load_data(drawing)

    def on_open_drawing(self):

        self.save_drawing_if_necessary()

        options = QFileDialog.Options()

        options |= QFileDialog.DontUseNativeDialog

        name, _ = QFileDialog.getOpenFileName(self, self.tr('Open'), workspace, 'HYTOS File(*.hytos)', options=options)

            self.open_drawing(name)

    def open_drawing(self, name):

        import uuid

        from Drawing import Drawing

        from datetime import datetime

        # connect scene changed signal

        self.graphicsView.scene.contents_changed.connect(self.scene_changed)

        app_doc_data = AppDocData.instance()

        configs = app_doc_data.getAppConfigs('option', 'WorkSpace')

            return os.getcwd()

    def changeViewCheckedState(self, checked, clear=True):

        if clear:

            self.initTableWidgetHMB()

            # self.clear_data()

                                                           sys.exc_info()[-1].tb_lineno)

            self.addMessage.emit(MessageType.Error, message)

    def on_item_removed(self, item):

        try:

            matches = [_item for _item in self.graphicsView.scene.items() if hasattr(_item, 'connectors') and \

                       [connector for connector in _item.connectors if

                        connector.connectedItem is not None and connector.connectedItem.parentItem() is item]]

            for match in matches:

                for connector in match.connectors:

            matches = [_item for _item in self.graphicsView.scene.items() if hasattr(_item, 'owner')]

            for match in matches:

                item.scene().removeItem(item)

                del item

        except Exception as ex:

                                                           sys.exc_info()[-1].tb_lineno)

            self.addMessage.emit(MessageType.Error, message)

        font.setFamily("맑은 고딕")

        self.actionSave.setFont(font)

        self.actionSave.setObjectName("actionSave")

        icon11 = QtGui.QIcon()

        icon11.addPixmap(QtGui.QPixmap(":/newPrefix/Rotate_Minus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)

        self.actioncoffee = QtWidgets.QAction(MainWindow)

        self.actioncoffee.setObjectName("actioncoffee")

        self.actionEnglish = QtWidgets.QAction(MainWindow)

        self.menu.addAction(self.actionClose)

        self.menu_3.addAction(self.actionZoom)

        self.menu_3.addAction(self.actionFitWindow)

        self.menuTool.addAction(self.actionLine)

        self.menuTool.addAction(self.actionInitialize)

        self.menuTool.addSeparator()

        self.actionSave.setText(_translate("MainWindow", "Save"))

        self.actionSave.setToolTip(_translate("MainWindow", "Save"))

        self.actionSave.setShortcut(_translate("MainWindow", "Ctrl+S"))

        self.actioncoffee.setText(_translate("MainWindow", "coffee"))

        self.actionEnglish.setText(_translate("MainWindow", "English"))

        self.actionViewInconsistency.setText(_translate("MainWindow", "Inconsistency (6)"))

        self._hover = False

        self._area = None

        self.connectors = []

        self._associations = {'Text Item':[], 'Symbol Item':[]} # associated items

    @property

import os.path

import copy, sys

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

from EngineeringAbstractItem import QEngineeringAbstractItem

class NozzleData:

    """ this is nozzle data class """

            from App import App

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

"""

    A {ConnectorItem} is the graphical representation of a {Symbol.Connectors}.

"""

class QEngineeringConnectorItem(QGraphicsEllipseItem):

    """ This is engineering connector item class """

    SMALL_SIZE = 10

        @history        humkyung 2018.07.27 add member for connectedItem

                        humkyung 2018.09.03 remove code to add connector item

    '''

    def __init__(self, uid=None, parent=None, index=-1):

        import uuid

        from SymbolSvgItem import SymbolSvgItem

        self._direction = 'AUTO'

        self._symbol_idx = '0'

        self._connectedItem = None

        self.connectPoint = None

        self._hoverItem = None

        self._data = None

    @staticmethod

    def find_connector(uid):

        """ find a connector which has given uid """

        import uuid

        res = None

                self._connectedItem = None

        return self._connectedItem

    @connectedItem.setter

    def connectedItem(self, value):

        """ setter of connectedItem """

        @author     humkyung

        @date       2018.09.01

    '''

    @property

    def direction(self):

        return self._direction

        @author     humkyung

        @date       2018.09.01

    '''

    @direction.setter

    def direction(self, value):

        self._direction = value

    @property

    def symbol_idx(self):

        """ """

        @author     humkyung

        @date       2018.09.01

    '''

    def dir(self):

        if self._direction == 'LEFT':

            return (-1, 0)

        @author humkyung

        @date   2018.05.02

    '''

    def buildItem(self):

        color = Qt.blue

        self.setBrush(color)

        @author     humkyung

        @date       2018.07.23

    '''

    def center(self):

        pt = self.sceneBoundingRect().center()

        return (pt.x(), pt.y())

    '''

        @brief  set position of connector

        @author humkyung

        @date   2018.05.02

    '''

    def setPos(self, pos):

        self.update()

        if hasattr(self, '_label'):

            """ set label positon at center of connector """

    def connect(self, item, at=QEngineeringAbstractItem.CONNECTED_AT_PT):

        if item:

            self.connectedItem = item

        self.setBrush(Qt.yellow) if self.connectedItem else self.setBrush(Qt.blue)

    def hoverEnterEvent(self, event):

        try:

        finally:

            QApplication.setOverrideCursor(Qt.CrossCursor)

    def hoverLeaveEvent(self, event):

        try:

            self.highlight(False)

        finally:

            QApplication.restoreOverrideCursor()

    def highlight(self, flag):

        if flag:

            c = QColor()

            c.setNamedColor(QEngineeringConnectorItem.HIGHLIGHT)

            self.setPen(Qt.red)

                font = self._label.font()

                font.setBold(True)

                self._label.setFont(font)

        else:

            self.setPen(Qt.black)

            self.setBrush(Qt.yellow) if self.connectedItem else self.setBrush(Qt.blue)

            if hasattr(self, '_label'):

                font.setBold(False)

                self._label.setFont(font)

        if self.scene() and self.scene().sceneRect().contains(self.sceneBoundingRect()):

            self.update()

            if self.scene(): self.scene().update()

        @author     humkyung

        @date       2018.07.27

    '''

    def mousePressEvent(self, event):

        if self.parentItem() is not None:

            if event.buttons() == Qt.LeftButton:

                self._savedPos = self._loc

                self._savedConnectedItem = self.connectedItem

        QGraphicsEllipseItem.mousePressEvent(self, event)

    '''

        @date       2018.07.27

        @history    humkyung 2018.08.23 unhighlight item if underitem exists

    '''

    def mouseReleaseEvent(self, event):

        import shapely

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringArrowItem import QEngineeringArrowItem

        from EngineeringTextItem import QEngineeringTextItem

            if self.parentItem() is not None and self._savedPos is not None:

                if items and type(items[0]) is QEngineeringConnectorItem:

                    self.setPos(items[0].center())

                    if self.connectedItem is not None:

                        self.connectedItem.connect(None)

                    items[0].connect(self)

                else:

                    pt = [event.scenePos().x(), event.scenePos().y()]

                    self.setPos(pt)

                    if self.connectedItem is not None:

                        self.connectedItem.connect(None)

                    symbol.transfer.on_pos_changed.connect(self.parent.on_symbol_pos_changed)

            if self.parentItem() is not None:

                self._savedConnectedItem = None

        finally:

            pass

        QGraphicsEllipseItem.mouseReleaseEvent(self, event)

        @date       2018.07.27

        @history    humkyung 2018.08.23 hightlight underitem

    '''

    def mouseMoveEvent(self, event):

        import shapely

        from SymbolSvgItem import SymbolSvgItem

        if self.parentItem() is not None and self._savedPos is not None:

            if event.buttons() == Qt.LeftButton:

                ## highlight underitem

                if len(items) > 0:

                    if not hasattr(self, '_underItem') or self._underItem is not items[0]:

                    self.setPos(items[0].center())

                else:

                    pt = [event.scenePos().x(), event.scenePos().y()]

                    self.setPos(pt)

                self.update()

        QGraphicsEllipseItem.mouseMoveEvent(self, event)

    def hasConnectedItem(self):

        if self.connectedItem is not None:

            return True

        return False

    '''

        @brief      reject if user press Escape key

        @author     humkyung

        @date       2018.07.27

    '''

    def keyPressEvent(self, event):

        if event.key() == Qt.Key_Escape:

            if hasattr(self, '_savedPos') and self._savedPos is not None:

        @author humkyung

        @date   2018.04.21

    '''

    def paint(self, painter, options=None, widget=None):

        from SymbolSvgItem import SymbolSvgItem

        @author     kyouho

        @date       2018.08.30

    '''

        from shapely.geometry import Point

        x1 = self.center()[0]

            if 'UID' in node.attrib: self.uid = uuid.UUID(node.attrib['UID'], version=4)

            if 'CONNECTED_AT' in node.attrib:

            else:

                self._connected_at = QEngineeringAbstractItem.CONNECTED_AT_PT

            self.setBrush(Qt.yellow) if self._connectedItem else self.setBrush(Qt.blue)

        except Exception as ex:

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    def toSql(self, index):

                else:

                    over_design_cv = float(over_design_cv)

                param = [str(self.uid), pressure, pressure_drop, elevation, over_design_cv]

                sql = 'insert or replace into Nozzles({}) values({})'.format(','.join(cols), ','.join(values))

                res.append((sql, tuple(param)))

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(repr(ex), sys.exc_info()[-1].tb_frame.f_code.co_filename,

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        return res

'''

    @brief      The class transfer pyqtSignal Event. Cause Subclass of QGraphicsRectItem can't use pyqtSignal

    @author     Jeongwoo

    @date       2018.06.18

'''

class Transfer(QObject):

    onPosChanged = pyqtSignal(QGraphicsItem)

    onRemoved = pyqtSignal(QGraphicsItem)

        QObject.__init__(self, parent)

                connector = QEngineeringConnectorItem(uid=None, parent=self, index=index + 1)

            connector.setPos(vertex)

            connector.connectPoint = vertex

            connector.sceneConnectPoint = vertex

class SymbolSvgItem(QGraphicsSvgItem, QEngineeringAbstractItem):

    clicked = pyqtSignal(QGraphicsSvgItem)

    ZVALUE = 100

        self.setZValue(SymbolSvgItem.ZVALUE)

        self._desc_label = QEngineeringEqpDescTextItem('eqp name<br>pressure drop<br>elevation', self)

    def has_attribute(self):

        if len(self.attribute) > 0:

            return True

    </property>

    <addaction name="actionZoom"/>

    <addaction name="actionFitWindow"/>

   </widget>

   <widget class="QMenu" name="menuTool">

    <property name="title">

    <string>Ctrl+S</string>

   </property>

  </action>

   <property name="icon">

    <iconset>

     <normaloff>:/newPrefix/Rotate_Minus.png</normaloff>:/newPrefix/Rotate_Minus.png</iconset>

   </property>

   <property name="text">

   </property>

   <property name="toolTip">

   </property>

   <property name="shortcut">

   </property>

  </action>

  <action name="actioncoffee">