HYTOS

from SingletonInstance import SingletonInstance

import symbol

from NominalPipeSize import NominalPipeSize

class Config:

        self._associationss = {}

        self._attributess = {}

    def clearTempDBData(self):

        self._connecterss = {}

        self._associationss = {}

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QPoint, QPointF, QRectF, pyqtSignal, QT_VERSION_STR, QMimeData

    except ImportError:

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

class ConnectionPointCommand(AbstractCommand.AbstractCommand):

    """

    ConnectionPointCommand class

    def __init__(self, imageViewer, connectionPointLineEdit, index=-1):

        super(ConnectionPointCommand, self).__init__(imageViewer)

        self.connectionPointLineEdit = connectionPointLineEdit

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

        self.imageWidth = self.imageViewer.image().width()

        self.initMinPoint = QPointF(self.imageWidth * -1, self.imageHeight * -1)

        self.connectionPointLineEdit.setText("")

        self.index = index

    '''

        @brief      pan image by left click and drag

        @history    2016.06.12  Jeongwoo    Make new point (newScenePos)

    '''

    def execute(self, param):

        from EngineeringOriginItem import QEngineeringOriginItem

        from EngineeringGuidelineItem import QEngineeringGuidelineItem

        scenePos = param[2]

        newScenePos = QPointF(round(scenePos.x()), round(scenePos.y()))

        originItem = None

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

            originItem = items[0]

        if originItem is not None:

            dx = scenePos.x() - center.x()

            dy = scenePos.y() - center.y()

            if abs(dx) < 1:

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

                if self.isOnImage(newScenePos.x(), newScenePos.y()):

                    ## drawCircle Method is static

                    text = "{},{}".format(newScenePos.x(), newScenePos.y())

                    self.connectionPointLineEdit.setText(text)

                    self.index += 1

                    self.onSuccess.emit(conn)

                else:

                QGraphicsView.mousePressEvent(self.imageViewer, event)

        elif 'mouseMoveEvent' == param[0]:

                self.connectionPointLineEdit.setText("")

            pass

        self.isTreated = False

    '''

        @history    2018.06.11  Jeongwoo    Shorten method to add Ellipse

                    2018.06.12  Jeongwoo    Modify RectF's coords

                    humkyung 2018.08.28 add connector item instead of QGraphicsEllipse

    '''

    @staticmethod

    def drawCircle(imageViewer, x, y, index=-1):

        from EngineeringConnectorItem import QEngineeringConnectorItem

        connector = QEngineeringConnectorItem(index=index)

        connector.setPos((float(x), float(y)))

        return connector

        @history    2018.06.11  Jeongwoo    Make area bigger (width/height 1px)

                    2018.06.12  Jeongwoo    Make area smaller (width/height 1px)

    '''

    def isOnImage(self, x, y):

        if (x >= 0 and x <= self.imageWidth) and (y >= 0 and y <= self.imageHeight):

            return True

        else:

            return False

    def undo(self):

        pass

    def redo(self):

        origin.setPos((float(x), float(y)))

        startPoint = (float(x), 0)

        vertical = QEngineeringGuidelineItem([startPoint, endPoint], origin)

        vertical.setParentItem(origin)

        vertical.setZValue(origin.zValue() + 1)

        startPoint = (0, float(y))

        horizontal = QEngineeringGuidelineItem([startPoint, endPoint], origin)

        horizontal.setParentItem(origin)

        horizontal.setZValue(origin.zValue() + 1)

        return origin

        from EngineeringOriginItem import QEngineeringOriginItem

        scenePos = QPointF(x, y)

            if type(item) is QEngineeringOriginItem]

        for item in items:

    '''

        @history    2018.06.11  Jeongwoo    Make area bigger (width/height 1px)

        self.ui.listWidgetTagNo.itemDoubleClicked.connect(self.tagNoItemDoubleCliced)

        self.ui.pushButtonClearAccessInfo.clicked.connect(self.clear_drawing_access_info_clicked)

    def set_page_segmentation_modes(self):

        """show page segmentation modes"""

        try:

                    self.viewTables[key].setColumnWidth(col, len(self.columnListAll[key][col]) * 8 + 10)

                # UID column hide

                self.viewTables[key].hideColumn(0)

            self.sortListOrder()

        except Exception as ex:

from AppDocData import AppDocData, Config

import ItemDataFormat_UI

dbListName = ['LINE_DATA_LIST', 'EQUIPMENT_DATA_LIST', 'VALVE_DATA_LIST', 'INSTRUMENT_DATA_LIST', 'NOTE_DATA_LIST']

class QItemDataFormatDialog(QDialog):

    """ This is QItemDataFormatDialog class """

        self.emptyCol = 'Empty Column'

        self.selectedCol = None

        self.equipmentHistory = []

        self.valveHistory = []

        self.instrumentHistory = []

        self.noteHistory = []

        self.colHistory = \

        self.listWidgets = \

        self.tableWidgets = \

        self.sections = \

        self.items = \

        self.drops = \

        self.deleteButtons = \

        self.deletes = \

        self.addButtons = \

        self.adds = \

        self.emptyButtons = \

        self.emptys = \

        self.colAddButtons = \

        self.colAdds = \

        self.colEditButtons = \

        self.colEdits = \

        # button en/disable setting

        self.ui.pushButtonLineColAdd.setDisabled(True)

            for col in range(len(headers)):

                self.tableWidgets[key].setItem(0, col, QTableWidgetItem(headers[col][1]))

                self.tableWidgets[key].horizontalHeaderItem(col).setSizeHint(QSize(25, 25))

            self.tableWidgets[key].horizontalHeader().sectionClicked.connect(self.sections[key])

            self.tableWidgets[key].cellClicked.connect(self.sections[key])

                self.listWidgets[key].addItem(item)

                for logical in range(self.tableWidgets[key].columnCount()):

                    if item.text() == self.tableWidgets[key].horizontalHeaderItem(logical).text():

                        self.listWidgets[key].takeItem(self.listWidgets[key].count() - 1)

                        break

        @author     euisung

        @date       2018.10.31

    '''

    def tabchanged(self, event):

        if self.selectedCol is not None:

            self.selectedCol[0].setCurrentCell(0, 0)

        @author     euisung

        @date       2018.10.30

    '''

    def dragEnterEvent(self, event):

        try:

            self.dragItem = self.focusWidget().item(self.focusWidget().indexAt(event.pos()).row()).text()

        except:

            self.dragItem = None

    def dropEvent(self, event, table, alist):

        if self.dragItem is None:

        logicalIndex = table.horizontalHeader().logicalIndex(visualIndex)

        table.setCurrentCell(0, logicalIndex)

        self.selectedCol = [table, logicalIndex, alist]

    def lineDropEvent(self, event):

        self.dropEvent(event, self.tableWidgets[0], self.listWidgets[0])

    def equipmentDropEvent(self, event):

        self.dropEvent(event, self.tableWidgets[1], self.listWidgets[1])

    def valveDropEvent(self, event):

        self.dropEvent(event, self.tableWidgets[2], self.listWidgets[2])

    def instrumentDropEvent(self, event):

        self.dropEvent(event, self.tableWidgets[3], self.listWidgets[3])

    def noteDropEvent(self, event):

        self.dropEvent(event, self.tableWidgets[4], self.listWidgets[4])

    def line_edit_clicked(self):

        data_list = QItemDataFormatDialog.DATA_LIST[0]

    def equipment_edit_clicked(self):

        data_list = QItemDataFormatDialog.DATA_LIST[1]

    def valve_edit_clicked(self):

        data_list = QItemDataFormatDialog.DATA_LIST[2]

    def instrument_edit_clicked(self):

        data_list = QItemDataFormatDialog.DATA_LIST[3]

    def note_edit_clicked(self):

        data_list = QItemDataFormatDialog.DATA_LIST[4]

    def add_column_clicked(self, tableName, alist, colList, history):

        '''

        item_data_format_dialog = QItemDataAddEditDialog(self, True, tableName, colList, history)

        isAccepted, newHistory = item_data_format_dialog.showDialog()

        if isAccepted:

            history.append(newHistory)

            item = QListWidgetItem(newHistory[1])

            item.setSizeHint(QSize(25, 25))

    def line_add_clicked(self):

        data_list = QItemDataFormatDialog.DATA_LIST[0]

    def equipment_add_clicked(self):

        data_list = QItemDataFormatDialog.DATA_LIST[1]

    def valve_add_clicked(self):

        data_list = QItemDataFormatDialog.DATA_LIST[2]

    def instrument_add_clicked(self):

        data_list = QItemDataFormatDialog.DATA_LIST[3]

    def note_add_clicked(self):

        data_list = QItemDataFormatDialog.DATA_LIST[4]

    '''

        @brief      add empty column

        @author     euisung

        @date       2018.10.29

    '''

    def emptyColumnClicked(self, table, alist):

        table.setColumnCount(table.columnCount() + 1)

        table.setHorizontalHeaderItem(table.columnCount() - 1, QTableWidgetItem(self.emptyCol))

        table.setItem(0, table.columnCount() - 1, QTableWidgetItem('add header'))

        if self.selectedCol is not None:

        else:

            table.horizontalHeader().moveSection(table.columnCount() - 1, 1)

        table.setCurrentCell(0, table.columnCount() - 1)

        @author     euisung

        @date       2018.10.25

    '''

    def pushButtonApplyClicked(self):

        docData = AppDocData.instance()

        configs = []

            addedCol = []

            editedCol = []

            for history in self.colHistory[key]:

                    isNewAddedCol = False

                    for index in range(len(addedCol)):

                        if addedCol[index] == history[0]:

                            break

                    if not isNewAddedCol:

                        editedCol.append(history)

                    addedCol.append(history[1])

            # save column order

            value = value[:-len(self.delimiter)]

            configs.append(Config('Order', key, value))

            docData.saveConfigs(configs)

        if reply == QMessageBox.Ok:

            QDialog.accept(self)

        @author     euisung

        @date       2018.10.25

    '''

        if item == None:

            return

        for index in range(table.columnCount()):

            if item.text() == table.horizontalHeaderItem(index).text():

                return

        table.setColumnCount(table.columnCount() + 1)

        table.setHorizontalHeaderItem(table.columnCount() - 1, QTableWidgetItem(item.text()))

            if self.selectedCol is None:

                table.horizontalHeader().moveSection(table.columnCount() - 1, 1)

            else:

        else:

            table.horizontalHeader().moveSection(table.columnCount() - 1, loc)

        table.setCurrentCell(0, table.columnCount() - 1)

            if item.text() == alist.item(logical).text():

                alist.takeItem(logical)

                break

    def lineItemDoubleCliked(self, item):

        data_list = QItemDataFormatDialog.DATA_LIST[0]

        self.listItemDoubleClicked(self.tableWidgets[data_list], item, self.listWidgets[data_list])

    def equipmentItemDoubleCliked(self, item):

        data_list = QItemDataFormatDialog.DATA_LIST[1]

        self.listItemDoubleClicked(self.tableWidgets[data_list], item, self.listWidgets[data_list])

    def valveItemDoubleCliked(self, item):

        data_list = QItemDataFormatDialog.DATA_LIST[2]

        self.listItemDoubleClicked(self.tableWidgets[data_list], item, self.listWidgets[data_list])

    def instrumentItemDoubleCliked(self, item):

        data_list = QItemDataFormatDialog.DATA_LIST[3]

        self.listItemDoubleClicked(self.tableWidgets[data_list], item, self.listWidgets[data_list])

    def noteItemDoubleCliked(self, item):

        data_list = QItemDataFormatDialog.DATA_LIST[4]

        self.listItemDoubleClicked(self.tableWidgets[data_list], item, self.listWidgets[data_list])

        @author     euisung

        @date       2018.10.25

    '''

    def pushButtonCloseClicked(self):

        QDialog.reject(self)

        @author     euisung

        @date       2018.10.25

    '''

    def keyPressEvent(self, event):

        try:

                visualIndex = self.selectedCol[0].horizontalHeader().visualIndex(self.selectedCol[0].currentColumn())

                    item.setSizeHint(QSize(25, 25))

                    self.selectedCol[2].addItem(item)

                #    if self.selectedCol[0].horizontalHeaderItem(self.selectedCol[1]).text() == self.selectedCol[2].item(logical).text():

                #        self.selectedCol[2].item(logical).setBackground(self.originBackground)

                #        break

                    logicalIndex = self.selectedCol[0].horizontalHeader().logicalIndex(visualIndex)

                    self.selectedCol[1] = logicalIndex

                    self.selectedCol[0].setCurrentCell(0, logicalIndex)

            QDialog.keyPressEvent(self, event)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

            return None

        @author     euisung

        @date       2018.10.25

    '''

    def addClicked(self, table, alist):

        item = alist.currentItem()

        self.listItemDoubleClicked(table, item, alist)

        @author     euisung

        @date       2018.10.25

    '''

    def deleteClicked(self, table, alist):

        if self.selectedCol is None:

            return

            item = QListWidgetItem(table.horizontalHeaderItem(table.currentColumn()).text())

            item.setSizeHint(QSize(25, 25))

            alist.addItem(item)

        #    if self.selectedCol[0].horizontalHeaderItem(self.selectedCol[1]).text() == self.selectedCol[2].item(logical).text():

        #        self.selectedCol[2].item(logical).setBackground(self.originBackground)

        #        break

        @author     euisung

        @date       2018.10.25

    '''

    def sectionClicked(self, table, logicalIndex, alist):

        if logicalIndex is not 0:

            table.setCurrentCell(0, logicalIndex)

        self.selectedCol = [table, None, alist]

    def lineSectionClicked(self, logicalIndex):

    def noteSectionClicked(self, logicalIndex):

        data_list = QItemDataFormatDialog.DATA_LIST[4]

        self.statusbar.addPermanentWidget(self.labelTextStatus)

        self.statusbar.addPermanentWidget(self.labelStatus)

        _translate = QCoreApplication.translate

        version = QCoreApplication.applicationVersion()

        # set title

        for condition in LineTypeConditions.items():

            self.lineComboBox.addItem(condition.name)

        value = configs[0].value if 1 == len(configs) else ''

        if value:

            at = self.lineComboBox.findText(value)

        self.graphicsView.useDefaultCommand()  # USE DEFAULT COMMAND

        self.graphicsView.setMouseTracking(True)

        self.graphicsView.viewport().installEventFilter(self)

        self._display_widget = QDisplayWidget()

        self._display_widget.radioButtonByGroup.toggled.connect(self.display_colors)

        self.pushButtonDetectSymbol.clicked.connect(self.show_detect_symbol_dialog)

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

        if configs and 1 == len(configs) and 'advanced' == configs[0].value:

            self.actionOCR_Training.triggered.connect(self.oCRTrainingClicked)

            self.actionSymbol_Training.triggered.connect(self.symbolTrainingClicked)

                self.progress.setValue(self.progress.value() + 1)

            QApplication.processEvents()

            for unknown in root.iter('UNKNOWN'):

            # up to here

            """ update scene """

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

            items = divide_chunks(_items, App.THREAD_MAX_WORKER if len(_items) > App.THREAD_MAX_WORKER else len(_items))

            with futures.ThreadPoolExecutor(max_workers=App.THREAD_MAX_WORKER) as pool:

                self.progress.setValue(self.progress.value() + 1)

            """

            for item in self.graphicsView.scene().items():

                item.setVisible(True)

            # collect items

            appDocData.lines.clear()

                                type(item) is QEngineeringLineItem and item.owner is None]

            appDocData.symbols.clear()

from App import App

from AppDocData import *

from TextInfo import TextInfo

class SpellTextEdit(QTextEdit):

            self.ui.pushButtonMakeTrainingImage.setVisible(False)

        self.graphicsView = QtImageViewer.QtImageViewer(App.mainWnd())

        self.graphicsView.useDefaultCommand()  # USE DEFAULT COMMAND

        self.graphicsView.setImage(self.image)

        self.ui.horizontalLayoutGraphicsView.addWidget(self.graphicsView)

    '''

    def __init__(self, mainWindow=None):

        QGraphicsView.__init__(self)

        self.mainWindow = mainWindow

        # Image is displayed as a QPixmap in a QGraphicsScene attached to this QGraphicsView.

        self.command = None

        self.scaleFactor = 1.0

        self.numScheduledScalings = 0

        item = None

        try:

                                                                               self.size[0], self.size[1]),

                                      QRect(self.loc[0], self.loc[1], self.size[0], self.size[1]), text_item=self)

            (res, textInfoList) = dialog.showDialog()

        boundingBox.transfer.onSizeChanged.connect(self.onBoundingBoxChanged)

        boundingBox.transfer.onRemoved.connect(self.itemRemoved)

        boundingBox.setPen(QPen(Qt.darkGray, THICKNESS, Qt.SolidLine))

        strArea = '({},{}),({},{})'.format(x, y, width, height)

        self.ui.textAreaLineEdit.setText(strArea)

    def removeArea(self, box):

        try:

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

    '''

    def setupImageViewer(self):

        x = self.ui.imageViewContainer.x()

        y = self.ui.imageViewContainer.y()

        width = self.ui.imageViewContainer.frameGeometry().width()

        height = self.ui.imageViewContainer.frameGeometry().height()

        self.ui.imageView.setGeometry(QtCore.QRect(0, y, height, height))

        self.ui.imageView.aspectRatioMode = QtCore.Qt.KeepAspectRatio

        self.ui.imageView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)

        imageWidth = self.ui.imageView.image().width()

        imageHeight = self.ui.imageView.image().height()

        items = [item for item in

                 if type(item) is QEngineeringConnectorItem]

        for item in items:

    '''^

        @brief  Display this QDialog

                    item = self.ui.tableWidgetConnList.item(item.row(), 0)

                    data = item.data(Qt.UserRole)

                    if data is not None:

                        model.removeRow(item.row())

                        self.conn_index -= 1

    def onCommandSuccess(self, pt):

        from EngineeringConnectorItem import QEngineeringConnectorItem

        if type(pt) is QEngineeringConnectorItem:

            rows = self.ui.tableWidgetConnList.rowCount()

            self.ui.tableWidgetConnList.setRowCount(rows + 1)

                item = self.ui.tableWidgetConnList.item(item.row(), 0)

                data = item.data(Qt.UserRole)

                if data is not None:

                    model.removeRow(item.row())

                    self.conn_index -= 1