HYTOS

    def find_connected_objects_size(self, start):

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringEquipmentItem import QEngineeringEquipmentItem

        from EngineeringInstrumentItem import QEngineeringInstrumentItem

        from SymbolSvgItem import SymbolSvgItem

        visited = [start]

        try:

            pool = []

            pool.append((0, start))

            while len(pool) > 0:

                sign, obj = pool.pop()

                match = False

                if issubclass(type(obj), QEngineeringEquipmentItem):

                    visited.pop(visited.index(obj))

                    continue

                elif match:

                    continue

                # nextmatches list always has one item

                if type(obj) is QEngineeringLineItem:

                    symbolMatches = [x.connectedItem for x in obj.connectors if x.connectedItem and issubclass(type(x.connectedItem), SymbolSvgItem) and \

                                        (x.connectedItem not in visited) and obj.is_connected(x.connectedItem)]

                    lineMatches = [x.connectedItem for x in obj.connectors if x.connectedItem and issubclass(type(x.connectedItem), QEngineeringLineItem) and \

                                        x.connectedItem.is_piping() and (x.connectedItem not in visited) and obj.is_connected(x.connectedItem)]

                    nextMatches = symbolMatches + lineMatches

                elif issubclass(type(obj), SymbolSvgItem):

                    # symbol can be connected with line and another symbol at the same time

                    lineMatches = [x.connectedItem for x in obj.connectors if x.connectedItem and issubclass(type(x.connectedItem), QEngineeringLineItem) and \

                                        x.connectedItem.is_piping() and (x.connectedItem not in visited) and obj.is_connected(x.connectedItem)]

                    symbolMatches = [x.connectedItem for x in obj.connectors if x.connectedItem and issubclass(type(x.connectedItem), SymbolSvgItem) and \

                                        (x.connectedItem not in visited) and obj.is_connected(x.connectedItem)]

                    nextMatches = symbolMatches + lineMatches

                    if len(visited) > 1: # symbol must pass straight, choose one if connected items are more than 2

                        matches = [x for x in visited if obj.is_connected(x)]

                        if matches:

                            next_connected = [x for x in nextMatches if obj.next_connected(x, matches[0])]

                            if next_connected:

                                nextMatches = next_connected

                            else:

                                nextMatches = []

                # order connected objects

                matches = []

                matches.extend(nextMatches)

                if sign == 0 and len(matches) > 1:

                    mid = int(len(matches) * 0.5)

                    lhs = matches[0:mid]

                    rhs = matches[mid:]

                elif sign == -1:

                    lhs = matches

                    rhs = []

                else:

                    lhs = []

                    rhs = matches

                for match in lhs:

                    pool.append((-1, match))

                    visited.insert(0, match)

                for match in rhs:

                    pool.append((1, match))

                    visited.append(match)

                # up to here

        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 visited

                    return self.owner.Size

                    connected_items = self.find_connected_objects_size(self)

                    if connected_items:

                        res1 = None

                        res2 = None

                        if type(connected_items[0]) is QEngineeringLineItem:

                            connectedItems = [conn.connectedItem for conn in connected_items[0].connectors if conn.connectedItem and conn.connectedItem not in connected_items]

                            if connectedItems:

                                connectedItems[0].sizeDepth = self.sizeDepth + 1

                                res1  = connectedItems[0].EvaluatedSize

                        if type(connected_items[-1]) is QEngineeringLineItem:

                            connectedItems = [conn.connectedItem for conn in connected_items[-1].connectors if conn.connectedItem and conn.connectedItem not in connected_items]

                            if connectedItems:

                                connectedItems[0].sizeDepth = self.sizeDepth + 1

                                res2  = connectedItems[0].EvaluatedSize

                        if res1 and res2:

                            self.sizeDepth = 0

                            return res1 if self.inch_to_number(res1) <= self.inch_to_number(res2) else res2

                        elif res1:

                            self.sizeDepth = 0

                            return res1

                        elif res2:

                            self.sizeDepth = 0

                            return res2

                if self.sizeDepth < 2: