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, lineNoConfig=None):

        from Configs import LineNoConfig, TagNoConfig

        import csv

        item = None

        try:

            text = textInfo.getText()

            docData = AppDocData.instance()

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

            sizeDelimiters = configs[0].value.upper().replace(' ', '').split(',') if 1 == len(configs) else None

            _no_config = None

            # check is line no

            line_no_configs = LineNoConfig.instance()

            if line_no_configs:

                if not lineNoConfig:

                    for line_no_config in line_no_configs:

                        result = line_no_config.parse(text)

                        if result[0]:

                            sizeUnit = line_no_config.unit

                            _no_config = line_no_config.value

                            break

                else:

                    matches = [line for line in line_no_configs if lineNoConfig in line.value]

                    if matches:

                        result = matches[0].parse(text)

                        if result[0]:

                            sizeUnit = matches[0].unit

                            _no_config = matches[0].value

                        else:

                            for line_no_config in line_no_configs:

                                result = line_no_config.parse(text)

                                if result[0]:

                                    sizeUnit = line_no_config.unit

                                    _no_config = line_no_config.value

                                    break

                    else:

                        for line_no_config in line_no_configs:

                            result = line_no_config.parse(text)

                            if result[0]:

                                sizeUnit = line_no_config.unit

                                _no_config = line_no_config.value

                                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()

                item.set_property('Config', self.delimiter.join(list(csv.reader([_no_config], delimiter=self.delimiter, escapechar='^'))[0]))

                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())

                else:

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

                    configs = list(csv.reader([_no_config], delimiter=self.delimiter, escapechar='^'))[0]

                    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()

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

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

                item.setPlainText(text)

            else:

                item = self.create_note_no_text(textInfo)

                for sizeDelimiter in sizeDelimiters:

                    sizeTextInfo = self.isSizeText(text, sizeDelimiter)

                    if sizeTextInfo:

                        break

                if item:

                    pass

                #elif self.is_reserved_word(text):

                #    item = QEngineeringReservedWordTextItem()

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

                #    item.setPlainText(text)

                elif sizeTextInfo:

                    item = QEngineeringSizeTextItem(mainSubSize=sizeTextInfo[1], sizeDelimiter=sizeTextInfo[2])

                    item.setToolTip('SIZE = {}'.format(sizeTextInfo[0]))

                    item.setPlainText(sizeTextInfo[0])

                #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

        try:

            sizeUnit = None

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

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

            pipe_sizes = NominalPipeSizeTable.instance().pipe_sizes

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

            if delimiter != '/' and delimiter in text:

                if len([_text for _text in text.split(delimiter.upper()) if len(_text) > 0]) < 2:

                    return False

                if text.count(delimiter) != 1:

                    return False

            first, second = None, None

            # for imperial

            if sizeUnit == 'Imperial' and text.find('"') is not -1 and delimiter == '/':

                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()

            elif sizeUnit == 'Imperial':

                first = text.split(delimiter.upper())[0]

                second = text.split(delimiter.upper())[1] if len(text.split(delimiter.upper())) == 2 else None

            # 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), tokens, delimiter]

        except Exception as ex:

            from App import App

            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 False

    def inch_to_number(self, inch_str):

        try:

            app_doc_data = AppDocData.instance()

            configs = app_doc_data.getConfigs('Size', 'Symbol')

            size_symbols = configs[0].value.replace(' ', '').split(',') if 1 == len(configs) else ['"']

            inchs = str(inch_str)

            for symbol in size_symbols:

                inchs = inchs.replace(symbol, '')

            inchs = inchs.lstrip('0').replace(' ', '-').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])

        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 0

        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