HYTOS

# coding: utf-8

""" This is TextItemFactor module """

from SingletonInstance import SingletonInstance

import re

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import *

        from PyQt4.QtGui import *

    except ImportError:

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

from AppDocData import *

import sys, os

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\Shapes')

from EngineeringTextItem import QEngineeringTextItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from EngineeringNoteItem import QEngineeringNoteItem

from QEngineeringSizeTextItem import QEngineeringSizeTextItem

from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

from EngineeringReservedWordTextItem import QEngineeringReservedWordTextItem

from SpecialItemTypesDialog import SpecialItemTypes

class TextItemFactory(SingletonInstance):

    """ This is TextItemFactor class """

    def __init__(self):

        self.delimiter = '"'

        self.lineNoDelimiter = '!-!'

    '''

        @history    2018.04.27  Jeongwoo    Add condition on elif-statement (delimiter != '' and lineNoConfig != '')

                    humkyung 2018.05.02 create engineering size text item if condition matches

                    humkyung 2018.06.19 set line no's color

                    kyouho 2018.07.04 edit for isLineNo method (add parameter)

                    humkyung 2018.08.08 fill linePropertyData and tagSeqNoPattern if given data is None

                    euisung 2018.11.19  now textitemfactory set plain text in createTextItem() for allowables

    '''

    def createTextItem(self, textInfo):

        from Configs import LineNoConfig, TagNoConfig

        item = None

        try:

            text = textInfo.getText()

            docData = AppDocData.instance()

            configs = docData.getConfigs('Size', 'Delimiter')

            sizeDelimiter = configs[0].value.upper() if 1 == len(configs) else None

            # check is line no

            line_no_configs = LineNoConfig.instance()

            if line_no_configs:

                for line_no_config in line_no_configs:

                    result = line_no_config.parse(text)

                    if result[0]:

                        sizeUnit = line_no_config.unit

                        break

            else:

                result = (False,)

            # check is tag no

            tag_no_configs = TagNoConfig.instance(tag=True)

            if tag_no_configs:

                for tag_no_config in tag_no_configs:

                    tagResult = tag_no_config.parse(text)

                    if tagResult[0]:

                        sizeUnit = tag_no_config.unit

                        break

            else:

                tagResult = (False,)

            if result[0]:

                item = QEngineeringLineNoTextItem()

                text = ''.join(result[1])

                for i in result[2]:

                    text = text[:i] + '\n' + text[i:]

                item.setPlainText(text)

                # get color option

                configs = docData.getConfigs('Line Color', 'Visible Option')

                if configs:

                    visibleOption = configs[0].value

                else:

                    visibleOption = 'Random'

                configs = docData.getConfigs('Color Property', 'State')

                if configs:

                    color_property = configs[0].value

                # set line no color

                if visibleOption == 'Random':

                    rgb = docData.colors

                    item.change_color(QColor(rgb.red, rgb.green, rgb.blue).name())

                    # item.setColor(QColor(rgb.red, rgb.green, rgb.blue).name())

                else:

                    configs = docData.getConfigs('Line No', 'Configuration')

                    configs = configs[0].value.split(self.delimiter)

                    values = result[1]

                    index = configs.index(color_property)

                    if index >= 0:

                        value = values[index]

                        line_properties = docData.getLinePropertiesByUID(color_property)

                        if line_properties[0].Attribute.replace(' ', '') == 'NominalDiameter':

                            if sizeUnit == "Inch":

                                value = docData.convertInchToMetric(value)

                        configs = docData.getConfigs(color_property, value)

                        if configs:

                            data = configs[0].value

                            rgb = data.split(',')

                            item.change_color(QColor(int(rgb[0]), int(rgb[1]), int(rgb[2])).name())

                    # up to here

                docData.tracerLineNos.append(item)

            elif tagResult[0]:

                item = QEngineeringTagNoTextItem()

                item.setToolTip('TAG NO = {}'.format(text))

                item.setPlainText(text)

            else:

                item = self.create_note_no_text(textInfo)

                sizeText = self.isSizeText(text, sizeDelimiter)

                if item:

                    pass

                elif self.is_reserved_word(text):

                    item = QEngineeringReservedWordTextItem()

                    item.setToolTip('Reserved Word = {}'.format(text))

                    item.setPlainText(text)

                elif sizeText:

                    item = QEngineeringSizeTextItem()

                    item.setToolTip('SIZE = {}'.format(sizeText))

                    item.setPlainText(sizeText)

                #elif self.isTagNoText(text):

                #    item = QEngineeringTagNoTextItem()

                #    item.setToolTip('TAG NO = {}'.format(text))

                #    item.setPlainText(text)

                elif self.is_valve_operation_code(text):

                    item = QEngineeringValveOperCodeTextItem()

                    item.setToolTip('Valve Operation Code = {}'.format(text))

                    item.setPlainText(text)

                else:

                    text = self.fix_dictionary_word(text)

                    item = QEngineeringTextItem()

                    item.setToolTip(text)

                    item.setPlainText(text)

                    item.special_item_type = SpecialItemTypes.instance().find_match_exactly(item)

                #docData.texts.append(item)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

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

        return item

    '''

        @brief      Check Text startwith word

        @author     kyouho

        @date       2018.07.04

    '''

    def isStartWithWord(self, text, word):

        sliceText = text[0:len(word[0])]

        if sliceText == word[0]:

            return (True, text[len(sliceText):len(text)], word[1])

        else:

            return (False,)

    '''

        @brief      Check Text startwith number

        @author     kyouho

        @date       2018.07.05

    '''

    def isStartWithNumber(self, text):

        sliceText = text[0:1]

        num = ''

        if self.isNumber(sliceText):

            text = text[1:len(text)]

            num += text

            while len(text) > 0:

                sliceText = text[0:1]

                if self.isNumber(sliceText):

                    text = text[1:len(text)]

                    num += text

                else:

                    break

            return (True, text, num)

        else:

            return (False,)

    '''

        @brief      Check Number

        @author     kyouho

        @date       2018.07.05

        @history    kyouho 2018.07.09   add Refular Expression

    '''

    def isNumber(self, num):

        p = re.compile('(^[0-9]+$)')

        result = p.match(num)

        if result:

            return True

        else:

            return False

    '''

        @brief      Check Number

        @author     kyouho

        @date       2018.07.05

    '''

    def isTagSeqNo(self, text, pattern):

        try:

            if pattern is not None:

                attr = text

                result = eval(pattern)

                if self.isNumber(result):

                    sliceText = text[0:len(result)]

                    return (True, text[len(sliceText):len(text)], sliceText)

                else:

                    return (False,)

            else:

                return (False,)

        except Exception as ex:

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

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

    '''

        @brief      Check Number

        @author     kyouho

        @date       2018.07.05

    '''

    def isLimitWord(self, text, pattern):

        try:

            if pattern is not None:

                attr = text

                length = pattern[0]

                isNumber = pattern[1]

                if length:  # Length가 있으면 Length만큼 문자열을 가져와 길이를 검사한다.

                    result = eval('attr[:' + str(length) + ']')

                    if int(length) != len(result):

                        return (False,)

                elif isNumber:

                    match = re.search(re.compile('^[0-9]+'), attr)

                    if match:

                        result = match.group(match.start())

                    else:

                        return (False,)

                else:

                    result = attr

                if isNumber:

                    if self.isNumber(result):

                        sliceText = text[0:len(result)]

                        return (True, text[len(sliceText):len(text)], sliceText)

                    else:

                        return (False,)

                else:

                    sliceText = text[0:len(result)]

                    return (True, text[len(sliceText):len(text)], sliceText)

            else:

                return (False,)

        except Exception as ex:

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

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

    '''

        @brief      Check if given text is Note No Text (ex : NOTE 1, NOTE 2, ...)

        @author     Jeongwoo

        @date       2018.04.26

        @history    2018.05.16  Jeongwoo    Modify Validator flag

    '''

    def create_note_no_text(self, textInfo):

        item = None

        appDocData = AppDocData.instance()

        configs = appDocData.getConfigs('Note No Tag Rule', 'Note No Expression')

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

            expression = configs[0].value

            match = re.search(re.compile(expression), textInfo.getText())

            if match:

                configs = appDocData.getConfigs('Note No Tag Rule', 'Note No Symbol Name')

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

                    symbol_names = configs[0].value.split(',')

                    for symbol in appDocData.symbols:

                        if symbol.name in symbol_names and symbol.includes(

                                textInfo.center) and '"' not in textInfo.getText():

                            item = QEngineeringNoteItem(symbol=symbol)

                            item.owner = symbol

                            symbol.add_assoc_item(item, 0)

                            break

                else:

                    item = QEngineeringNoteItem()

                if item:

                    item.setToolTip(textInfo.getText())

                    item.setPlainText(textInfo.getText())

        return item

    '''

        @brief  check if given text is size text

        @author humkyung

        @date   2018.05.02

    '''

    def isSizeText(self, text, delimiter='X'):

        from NominalPipeSize import NominalPipeSizeTable

        sizeUnit = None

        configs = AppDocData.instance().getConfigs('Project', 'Unit')

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

        pipe_sizes = NominalPipeSizeTable.instance().pipe_sizes

        text = text.replace("'", '"').replace(' ', '').upper()

        first, second = None, None

        # for imperial

        if text.find('"') is not -1:

            first = text[:text.find('"') + 1]

            second = text[text.find('"') + 1:].replace(delimiter.upper(), '',

                                                       1).strip() if delimiter is not None else text[text.find(

                '"') + 1:].strip()

        # for metric

        else:

            split_text = text.strip().split(delimiter.upper())

            if len(split_text) > 2:

                return False

            first = split_text[0]

            second = split_text[1] if len(split_text) is 2 else None

        tokens = [first, second] if second is not None and len(second) is not 0 else [first]

        index = 0

        for token in tokens:

            matches = [(sizeData.find(token, sizeUnit) if sizeUnit else sizeData.find(token)) for sizeData in pipe_sizes

                       if (sizeData.find(token, sizeUnit) if sizeUnit else sizeData.find(token))]

            if matches:

                tokens[index] = matches[0]

            else:

                return False

            index += 1

        if len(tokens) == 2:

            if self.inch_to_number(tokens[0]) < self.inch_to_number(tokens[1]):

                tokens[0], tokens[1] = tokens[1], tokens[0]

        return delimiter.join(tokens)

    def inch_to_number(self, inch_str):

        inchs = inch_str.replace('"', '').split('-')

        number = 0

        for inch in inchs:

            if '/' not in inch:

                number += float(inch)

            else:

                fraction = inch.split('/')

                number += float(fraction[0]) / float(fraction[1])

        return number

    '''

        @brief  check if given text is tag no

        @author humkyung

        @date   2018.05.03

    '''

    def isTagNoText(self, text):

        from CodeTables import CodeTable

        found = CodeTable.instance('EqpTagNames').find_match_exactly(text)

        return True if found else False

    def is_valve_operation_code(self, text):

        """

        check if given text is valve operation code

        """

        from CodeTables import CodeTable

        found = CodeTable.instance('ValveOperCodes').find_match_exactly(text)

        return True if found else False

    def fix_dictionary_word(self, text):

        """ fix if given text is in dictionary """

        from CodeTables import CodeTable

        found = CodeTable.instance('Dictionary').find_match_exactly(text)

        return found if found else text

    def is_reserved_word(self, text):

        """ check if given text is reserved words """

        from CodeTables import CodeTable

        found = CodeTable.instance('ReservedWords').find_match_exactly(text)

        return True if found else False