HYTOS

    def execute(self, items, rules):

            for item in items:

                    errors.extend(item.validate(rules))

                errors = cmd.execute(self.graphicsView.scene().items(), dlg.rules)

    def validate(self, rules):

        from ValidateCommand import LineValidation

                if LineValidation.DisconnectionWarning in rules:

                    if connector.connectedItem is None:

                        error.msg = _translate('Disconnection warning', 'Disconnection warning')

                        error.name = 'Warning'

                # check line to symbol

                elif issubclass(type(connector.connectedItem), SymbolSvgItem) and type(

                        connector.connectedItem) is not QEngineeringEquipmentItem:

                    matches = [conn for conn in connector.connectedItem.connectors if conn.connectedItem is self]

                    # check if two items are connected each other

                    if not matches:

                        if LineValidation.DisconnectedFromOppositeSide in rules:

                    # check connection position

                    elif not self.isOverlap(connector.sceneBoundingRect(), matches[0].sceneBoundingRect()):

                        if LineValidation.MismatchedPositionError in rules:

                            error.msg = _translate('Mismatched position error', 'Mismatched position error')

                elif issubclass(type(connector.connectedItem), QEngineeringLineItem):

                    # check if connected two lines has same direction

                    if connector._connected_at == QEngineeringAbstractItem.CONNECTED_AT_PT:

                        indices = [0, 0]

                        indices[0] = 1 if QPointF(center[0], center[1]) == self.line().p1() else 2

                        matches = [conn for conn in connector.connectedItem.connectors if

                                   conn.connectedItem == self and conn._connected_at == QEngineeringAbstractItem.CONNECTED_AT_PT]

                        if matches:

                            indices[1] = 1 if QPointF(matches[0].center()[0], matches[0].center()[

                                1]) == connector.connectedItem.line().p1() else 2

                        else:

                            if LineValidation.DisconnectedFromOppositeSide in rules:

                                error = SymbolSvgItem.createItem('Error', None, dataPath)

                                error.setPosition(list(connector.center()))

                                error.parent = self

                                error.msg = _translate('Disconnected from opposite side', 'Disconnected from opposite side')

                                error.setToolTip(error.msg)

                                error.area = 'Drawing'

                                error.name = 'Error'

                                error.items = [ connector.connectedItem ]

                                errors.append(error)

                        if LineValidation.FlowDirectionError in rules:

                            if indices[0] == indices[1]:

                                error = SymbolSvgItem.createItem('Error', None, dataPath)

                                error.setPosition(list(connector.center()))

                                error.parent = self

                                error.msg = _translate('Flow direction error', 'Flow direction error')

                                error.setToolTip(error.msg)

                                error.area = 'Drawing'

                                error.name = 'Error'

                                error.items = [ connector.connectedItem ]

                                errors.append(error)

                        if LineValidation.LineTypeError in rules:

                            if self.lineType != connector.connectedItem.lineType:

                                error = SymbolSvgItem.createItem('Error', None, dataPath)

                                error.setPosition(list(connector.center()))

                                error.parent = self

                                error.msg = _translate('Line type error', 'Line type error')

                                error.setToolTip(error.msg)

                                error.area = 'Drawing'

                                error.name = 'Error'

                                error.items = [ connector.connectedItem ]

                                errors.append(error)

                    else:

                        if LineValidation.LinePositionError in rules:

                            center = connector.center()

                            line = connector.connectedItem

                            configs = docdata.getConfigs('Line Detector', 'Length to connect line')

                            toler = int(configs[0].value) if configs else 20

                            if line.distanceTo(center) > toler * 2:

                                error = SymbolSvgItem.createItem('Error', None, dataPath)

                                error.setPosition(list(connector.center()))

                                error.parent = self

                                error.msg = _translate('Line position error', 'Line position error')

                                error.setToolTip(error.msg)

                                error.area = 'Drawing'

                                error.name = 'Error'

                                error.items = [ line ]

                                errors.append(error)

                #errors.extend(connector.validate())

            if LineValidation.DuplicatedConnectionError in rules:

                if len(connectedUid) is not len(set(connectedUid)):

                    error.msg = _translate('Duplicated connection error', 'Duplicated connection error')

                    error.name = 'Error'

            # check overlapping

            if LineValidation.LineOverlappingWarning in rules:

                lines = [item for item in self.scene().items() if item is not self and type(item) is QEngineeringLineItem]

                for line in lines:

                    lineRect = line.sceneBoundingRect()

                    rect1 = QRectF(lineRect.left() - 3, lineRect.top() - 3, lineRect.width() + 6, lineRect.height() + 6)

                    if rect1.contains(self.sceneBoundingRect()) or (not (self.isVertical() ^ line.isVertical()) and lineRect.contains(self.sceneBoundingRect().center())):

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

                        error.parent = self

                        error.msg = _translate('Line overlapping warning', 'Line overlapping warning')

                        error.setToolTip(error.msg)

                        error.area = 'Drawing'

                        error.name = 'Warning'

                        error.items = [ line ]

                        errors.append(error)

                if LineValidation.LineAngleWarning in rules:

                    angle = self.angle()

                    allowed_error = 0.0008726646#0.0175

                    isAngleError = True

                    #degree 0

                    if abs(angle - 0) <= allowed_error:

                        isAngleError = False

                    #degree 90

                    elif abs(angle - math.pi / 2) <= allowed_error:

                        isAngleError = False

                    #degree 180

                    elif abs(angle - math.pi) <= allowed_error:

                        isAngleError = False

                    #degree 270

                    elif abs(angle - math.pi * 3 / 2) <= allowed_error:

                        isAngleError = False

                    if isAngleError:

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

                        error.parent = self

                        error.msg = _translate('Line angle warning', 'Line angle warning')

                        error.setToolTip(error.msg)

                        error.area = 'Drawing'

                        error.name = 'Warning'

                        errors.append(error)

            # loop check

            if LineValidation.LoopPathError in rules:

                visited = self.find_connected_objects_size(self)

                if visited.index(self) == 1 and type(visited[0]) is QEngineeringLineItem and visited[0].connectors[1].connectedItem is self and \

                        visited[0].connectors[0].connectedItem and visited[0].connectors[0].connectedItem in visited:

                    visited.pop(1)

                    error.msg = _translate('Loop path error', 'Loop path error')

                    error.name = 'Error'

                    error.items = visited

    def validate(self, rules):

        from ValidateCommand import LineNoValidation

            _error = super().validate(rules)

            if LineNoValidation.BranchSizeError in rules or LineNoValidation.SizeChangeError in rules:

                size_errors = []

                branch_errors = []

                for run in self.runs:

                    sizes = []

                    for item in run.items:

                        item_size = None

                        attrs = item.getAttributes()

                        for prop, value in attrs.items():

                            if prop.Attribute.upper() == 'Size'.upper() or prop.Attribute.upper() == 'NominalDiameter'.upper():

                                if value and value != 'None':

                                    item_size = value

                                    if type(item) is QEngineeringReducerItem or (issubclass(type(item), SymbolSvgItem) and item.iType == 22): # Relief Valve

                                        sizes.append([item, item.mainSubSize[0], item.mainSubSize[1]])

                                        break

                                    else:

                                        sizes.append([item, value, value])

                                        break

                        if item_size and type(item) is QEngineeringLineItem:

                            for conn in item.connectors:

                                if conn.connectedItem and type(conn.connectedItem) is QEngineeringLineItem and \

                                    conn._connected_at == QEngineeringAbstractItem.CONNECTED_AT_BODY:

                                    _item_size = None

                                    attrs = conn.connectedItem.getAttributes()

                                    for prop, value in attrs.items():

                                        if prop.Attribute.upper() == 'Size'.upper() or prop.Attribute.upper() == 'NominalDiameter'.upper():

                                            if value and value != 'None':

                                                _item_size = value

                                                break

                                    if _item_size and self.inch_to_number(item_size) > self.inch_to_number(_item_size):

                                        branch_errors.append(item)

                                        branch_errors.append(conn.connectedItem)

                    if len(sizes) > 1:

                        for index in range(len(sizes) - 1):

                            if sizes[index][2] != sizes[index + 1][1] and \

                                type(sizes[index][0]) is not QEngineeringReducerItem and type(sizes[index + 1][0]) is not QEngineeringReducerItem \

                                and (hasattr(sizes[index][0], 'iType') and sizes[index][0].iType != 22) and \

                                (hasattr(sizes[index + 1][0], 'iType') and sizes[index + 1][0].iType != 22):

                                    size_errors.append(sizes[index][0])

                                    size_errors.append(sizes[index + 1][0])

                            elif sizes[index][1] not in sizes[index + 1] and sizes[index][2] not in sizes[index + 1]:

                                    size_errors.append(sizes[index][0])

                                    size_errors.append(sizes[index + 1][0])

                if LineNoValidation.SizeChangeError in rules:

                    for size in size_errors:

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.setPosition([size.sceneBoundingRect().center().x(), size.sceneBoundingRect().center().y()])

                        error.parent = size

                        error.msg = _translate('Size change error', 'Size change error')

                        error.setToolTip(error.msg)

                        error.area = 'Drawing'

                        error.name = 'Error'

                        errors.append(error)

                if LineNoValidation.BranchSizeError in rules:

                    for size in branch_errors:

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.setPosition([size.sceneBoundingRect().center().x(), size.sceneBoundingRect().center().y()])

                        error.parent = size

                        error.msg = _translate('Branch size error', 'Branch size error')

                        error.setToolTip(error.msg)

                        error.area = 'Drawing'

                        error.name = 'Error'

                        errors.append(error)

            if LineNoValidation.MainRunSizeWarning in rules:

                if self.runs and self.runs[0].items:

                    _size = self.Size

                    found = False

                    if _size:

                        for item in self.runs[0].items:

                            if type(item) is QEngineeringReducerItem or (issubclass(type(item), SymbolSvgItem) and item.iType == 22):

                                continue

                            _size2 = item.EvaluatedSize

                            if _size2 and _size2 != 'None' and _size2 == _size:

                                found = True

                                break

                            #attrs = item.getAttributes()

                            #for prop, value in attrs.items():

                            #    if prop.Attribute.upper() == 'Size'.upper() or prop.Attribute.upper() == 'NominalDiameter'.upper():

                            #        if value and value != 'None' and _size != value:

                            #            found = True

                            #            break

                            if found:

                                break

                    if not found:

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

                        error.parent = self

                        error.msg = _translate('Main run size warning', 'Main run size warning')

                        error.setToolTip(error.msg)

                        error.area = 'Drawing'

                        error.name = 'Warning'

                        errors.append(error)

            if LineNoValidation.FromToError in rules:

                if lineNoError:

                    error.msg = _translate('From/ To error', 'From/ To error')

                    error.name = 'Error'

    def validate(self, rules):

        from ValidateCommand import SymbolValidation

        errors = []

            if SymbolValidation.UpStreamOrDownStreamIsDisconnected in rules:

                error.msg = self.tr('UpStream or DownStream is disconnected')

        elif self.up_stream and self.down_stream:

            up_stream_item = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(self.up_stream)]

            down_stream_item = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(self.down_stream)]

            if not (up_stream_item and down_stream_item):

                if SymbolValidation.UpStreamOrDownStreamIsNone in rules:

                    error.msg = self.tr('UpStream or DownStream is None')

            else:

                if SymbolValidation.UpStreamAndDownStreamIsMisconnected in rules:

                    connected = [False, False]

                    for connector in up_stream_item[0].connectors:

                        if connector.connectedItem == down_stream_item[0]:

                            connected[0] = True

                            if connector._connected_at == QEngineeringAbstractItem.CONNECTED_AT_BODY:

                                connected[1] = True

                    if connected[1] == False:

                        for connector in down_stream_item[0].connectors:

                            if connector.connectedItem == up_stream_item[0]:

                                connected[1] = True

                                if connector._connected_at == QEngineeringAbstractItem.CONNECTED_AT_BODY:

                                    connected[0] = True

                    if not (connected[0] and connected[1]):

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = self.tr('UpStream and DownStream is misconnected')

                        error.setToolTip(error.msg)

                        error.area = 'Drawing'

                        error.name = 'Error'

                        error.items = [ up_stream_item[0], down_stream_item[0] ]

                        errors.append(error)

    def validate(self, rules):

        from ValidateCommand import TextValidation

            if TextValidation.TextOverlappingWarning in rules:

                texts = [item for item in self.scene().items() if item is not self and issubclass(type(item), QEngineeringTextItem)]

                for text in texts:

                    textRect = text.sceneBoundingRect()

                    rect1 = QRectF(textRect.left() - 3, textRect.top() - 3, textRect.width() + 6, textRect.height() + 6)

                    rect2 = QRectF(textRect.left() + 3, textRect.top() + 3, textRect.width() - 6, textRect.height() - 6)

                    if rect1.contains(self.sceneBoundingRect()) or rect2.contains(self.sceneBoundingRect().center()):

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = self.tr('Text overlapping warning')

                        error.setToolTip(error.msg)

                        error.area = self.area

                        error.name = 'Warning'

                        error.items = [ text ]

                        errors.append(error)

                        error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

                lines = [item for item in self.scene().items() if item is not self and issubclass(type(item), QEngineeringLineItem)]

                for line in lines:

                    lineRect = line.sceneBoundingRect()

                    if lineRect.intersects(self.sceneBoundingRect()):

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = self.tr('Text overlapping waring')

                        error.setToolTip(error.msg)

                        error.area = self.area

                        error.name = 'Warning'

                        error.items = [ line ]

                        errors.append(error)

                        error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

            if TextValidation.AssociationError in rules:

                if self.owner:

                    if self not in self.owner.associations():

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = self.tr('Association error')

                        error.setToolTip(error.msg)

                        error.area = self.area

                        error.name = 'Error'

                        error.items = [ self.owner ]

                        errors.append(error)

                        error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

    def validate(self, rules):

        from ValidateCommand import SymbolValidation

            #for connector in self.connectors:

            #    errors.extend(connector.validate())

            if SymbolValidation.FlowDirectionError in rules:

                if len(self.connectors) is 2:

                    if (type(self.connectors[0].connectedItem) is QEngineeringLineItem and

                        self.connectors[0]._connected_at == QEngineeringAbstractItem.CONNECTED_AT_PT) and \

                            (type(self.connectors[1].connectedItem) is QEngineeringLineItem and

                            self.connectors[1]._connected_at == QEngineeringAbstractItem.CONNECTED_AT_PT):

                        indices = [0, 0]

                        center = self.connectors[0].center()

                        dx, dy = [0, 0], [0, 0]

                        dx[0] = center[0] - self.connectors[0].connectedItem.line().p1().x()

                        dy[0] = center[1] - self.connectors[0].connectedItem.line().p1().y()

                        dx[1] = center[0] - self.connectors[0].connectedItem.line().p2().x()

                        dy[1] = center[1] - self.connectors[0].connectedItem.line().p2().y()

                        indices[0] = 1 if (dx[0] * dx[0] + dy[0] * dy[0]) < (dx[1] * dx[1]) + (dy[1] * dy[1]) else 2

                        center = self.connectors[1].center()

                        dx[0] = center[0] - self.connectors[1].connectedItem.line().p1().x()

                        dy[0] = center[1] - self.connectors[1].connectedItem.line().p1().y()

                        dx[1] = center[0] - self.connectors[1].connectedItem.line().p2().x()

                        dy[1] = center[1] - self.connectors[1].connectedItem.line().p2().y()

                        indices[1] = 1 if (dx[0] * dx[0] + dy[0] * dy[0]) < (dx[1] * dx[1]) + (dy[1] * dy[1]) else 2

                        if indices[0] == indices[1]:

                            error = SymbolSvgItem.createItem('Error', None, dataPath)

                            error.parent = self

                            error.msg = self.tr('Flow direction error')

                            error.setToolTip(error.msg)

                            error.area = 'Drawing'

                            error.name = 'Error'

                            errors.append(error)

            # check disconnected point

            attrs = self.getAttributes()

            matches = [(attr, value) for attr, value in attrs.items() if attr.Attribute == 'OWNERSYMBOL']

            if matches:

                if SymbolValidation.NotCombined in rules:

                    if not matches[0][1]:

                        error.msg = 'Not combined'

                if SymbolValidation.DisconnectionError in rules:

                    disconnect = False

                    if len(self.connectors) is not 0:

                        disconnect = True

                        for connector in self.connectors:

                            if connector.connectedItem is not None:

                                disconnect = False

                                break

                    if disconnect:

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = 'Disconnection error'

                        error.setToolTip(error.msg)

                        error.area = 'Drawing'

                        error.name = 'Error'

                        errors.append(error)

            if SymbolValidation.AssociationError in rules:

                for assoc in self.associations():

                    if issubclass(type(assoc), QEngineeringTextItem) and not assoc.owner:

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = self.tr('Association error')

                        error.setToolTip(error.msg)

                        error.area = self.area

                        error.name = 'Error'

                        error.items = [ assoc ]

                        errors.append(error)

            if SymbolValidation.NoSizeLabelWarning in rules:

                if type(self) is QEngineeringReducerItem:

                    if not [size for size in self.associations() if type(size) is QEngineeringSizeTextItem]:

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = self.tr('No size label warning')

                        error.setToolTip(error.msg)

                        error.area = self.area

                        error.name = 'Warning'

                        errors.append(error)

                if SymbolValidation.NoLabelWarning in rules:

                    if not self.EvaluatedLabel('OWNERSYMBOL'):

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = self.tr('No label warning')

                        error.setToolTip(error.msg)

                        error.area = self.area

                        error.name = 'Warning'

                        errors.append(error)

                if SymbolValidation.MultipleLabelError in rules:

                    labels = [item for item in self.scene().items() if issubclass(type(item), SymbolSvgItem) and (item.iType == 19 or item.iType == 29 or item.iType == 30)]

                    labels = [label for label in labels if label.EvaluatedAttribute('OWNERSYMBOL') == self or \

                            (type(label.EvaluatedAttribute('OWNERSYMBOL')) is str and label.EvaluatedAttribute('OWNERSYMBOL') == str(self.uid))]

                    if len(labels) > 1:

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = self.tr('Multiple label error')

                        error.setToolTip(error.msg)

                        error.area = self.area

                        error.name = 'Error'

                        error.items = labels

                        errors.append(error)

            if SymbolValidation.SymbolOverlappingWarning in rules:

                symbols = [item for item in self.scene().items() if item is not self and issubclass(type(item), SymbolSvgItem) and type(item) is not QEngineeringEquipmentItem and type(item) is not QEngineeringEndBreakItem and type(item) is not QEngineeringSpecBreakItem]

                for symbol in symbols:

                    symbolRect = symbol.sceneBoundingRect()

                    rect1 = QRectF(symbolRect.left() - 3, symbolRect.top() - 3, symbolRect.width() + 6, symbolRect.height() + 6)

                    rect2 = QRectF(symbolRect.left() + 3, symbolRect.top() + 3, symbolRect.width() - 6, symbolRect.height() - 6)

                    if rect1.contains(self.sceneBoundingRect()) or rect2.contains(self.mapToScene(self.transformOriginPoint())):

                        error = SymbolSvgItem.createItem('Error', None, dataPath)

                        error.parent = self

                        error.msg = self.tr('Symbol overlapping warning')

                        error.setToolTip(error.msg)

                        error.area = self.area

                        error.name = 'Warning'

                        error.items = [ symbol ]

                        errors.append(error)

                    if SymbolValidation.DisconnectedFromOppositeSide in rules:

                        if not matches:

                            error.setPosition(list(connector.center()))

                            error.msg = self.tr('Disconnected from opposite side')

                            error.items = [ connector.connectedItem ]

            # check duplicated connection

            if SymbolValidation.DuplicatedConnectionError in rules:

                if len(connectedUid) is not len(set(connectedUid)):

                    error = SymbolSvgItem.createItem('Error', None, dataPath)

                    error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

                    error.parent = self

                    error.msg = self.tr('Duplicated connection error')

                    error.setToolTip(error.msg)

                    error.area = self.area

                    error.name = 'Error'

                    errors.append(error)

            # check line type

            if SymbolValidation.LineTypeError in rules:

                if self.conn_type:

                    for index in range(len(self.conn_type)):

                        item = self.connectors[index].connectedItem

                        if item and type(item) is QEngineeringLineItem:

                            if (QEngineeringLineItem.check_piping(self.conn_type[index], True) and not item.is_piping()) or \

                                    (not QEngineeringLineItem.check_piping(self.conn_type[index]) and item.is_piping(True)):

                                error = SymbolSvgItem.createItem('Error', None, dataPath)

                                error.setPosition(list(self.connectors[index].center()))

                                error.parent = self

                                error.msg = self.tr('Line type error')

                                error.setToolTip(error.msg)

                                error.area = self.area

                                error.name = 'Error'

                                errors.append(error)

                    if SymbolValidation.XMismatchedConnectionPoint in rules:

                        for conn2 in conn.connectedItem.connectors:

                            if not conn2.connectedItem or conn2.connectedItem is not self:

                                continue

                            if abs(conn.center()[0] - conn2.center()[0]) > allowed_error or abs(conn.center()[1] - conn2.center()[1]) > allowed_error:

                                error = SymbolSvgItem.createItem('Error', None, dataPath)

                                error.setPosition([self.sceneBoundingRect().center().x(), self.sceneBoundingRect().center().y()])

                                error.parent = self

                                error.msg = self.tr('X Mismatched connection point')

                                error.setToolTip(error.msg)

                                error.area = self.area

                                error.name = 'Warning'

                                error.items = [ conn.connectedItem ]

                                errors.append(error)

                    if SymbolValidation.SymbolToSymbolConnectionWarning in rules:

                        if issubclass(type(conn.connectedItem), SymbolSvgItem):

                            error.msg = self.tr('Symbol to symbol connection warning')

    <widget class="QGroupBox" name="groupBox_3">

            <weight>50</weight>

            <bold>false</bold>

         <widget class="QCheckBox" name="checkBoxL_4">

         <widget class="QCheckBox" name="checkBoxL_5">

           <string>Mismatched position error</string>

         <widget class="QCheckBox" name="checkBoxL_6">

         <widget class="QCheckBox" name="checkBoxL_7">

         <widget class="QCheckBox" name="checkBoxL_1">

            <weight>50</weight>

            <bold>false</bold>

         <widget class="QCheckBox" name="checkBoxL_9">

         <widget class="QCheckBox" name="checkBoxL_8">

         <widget class="QCheckBox" name="checkBoxL_2">

         <widget class="QCheckBox" name="checkBoxL_3">

         <widget class="QCheckBox" name="checkBoxL_10">

    <widget class="QGroupBox" name="groupBox_1">

         <widget class="QCheckBox" name="checkBoxS_13">

         <widget class="QCheckBox" name="checkBoxS_14">

         <widget class="QCheckBox" name="checkBoxS_16">

         <widget class="QCheckBox" name="checkBoxS_15">

         <widget class="QCheckBox" name="checkBoxS_3">

         <widget class="QCheckBox" name="checkBoxS_2">

         <widget class="QCheckBox" name="checkBoxS_4">

         <widget class="QCheckBox" name="checkBoxS_1">

         <widget class="QCheckBox" name="checkBoxS_7">

         <widget class="QCheckBox" name="checkBoxS_8">

         <widget class="QCheckBox" name="checkBoxS_6">

         <widget class="QCheckBox" name="checkBoxS_5">

         <widget class="QCheckBox" name="checkBoxS_10">

         <widget class="QCheckBox" name="checkBoxS_9">

         <widget class="QCheckBox" name="checkBoxS_12">