Esempio n. 1
0
    def __init__(self, parent, edge):
        """ EdgeLabelEmbed is for editing edge labels, but it takes Edge as its host,
        because there may be problems if the host item is not subclass of Saved. Use self.label
        to get access to edge.label_item.
        :param parent:
        :param ui_manager:
        :param edge:
        :param ui_key:
        """

        UIEmbed.__init__(self, parent, edge, 'Edit edge text')
        self.marker = None
        self.label = edge.label_item
        layout = QtWidgets.QVBoxLayout()
        layout.addLayout(self.top_row_layout)  # close-button from UIEmbed
        tt = 'Label for arrow'
        f = QtGui.QFont(qt_prefs.get_font(g.MAIN_FONT))
        f.setPointSize(f.pointSize() * 2)
        self.input_line_edit = EmbeddedLineEdit(self, tip=tt, font=f, prefill='label')
        hlayout = QtWidgets.QHBoxLayout()
        hlayout.addWidget(self.input_line_edit)
        self.enter_button = QtWidgets.QPushButton("↩")  # U+21A9 ↩
        self.ui_manager.connect_element_to_action(self.enter_button, 'edit_edge_label_enter_text')

        hlayout.addWidget(self.enter_button)
        layout.addLayout(hlayout)
        self.setLayout(layout)
        self.assumed_width = 200
        self.assumed_height = 37
        self.update_position()
Esempio n. 2
0
    def __init__(self, parent, edge):
        """ ArrowLabelEmbed is for editing arrow labels, but it takes Arrow as its host,
        because there may be problems if the host item is not subclass of Saved. Use self.label
        to get access to edge.label_item.
        :param parent:
        :param ui_manager:
        :param edge:
        :param ui_key:
        """

        UIEmbed.__init__(self, parent, edge, 'Edit edge text')
        self.marker = None
        self.label = edge.label_item
        layout = self.vlayout
        tt = 'Label for arrow'
        f = QtGui.QFont(qt_prefs.get_font(g.MAIN_FONT))
        f.setPointSize(f.pointSize() * 2)
        hlayout = box_row(layout)
        self.input_line_edit = KatajaLineEdit(self, tooltip=tt, font=f, prefill='label'
                                              ).to_layout(hlayout)
        # U+21A9 ↩
        self.enter_button = PushButtonBase(self, text="↩",
                                           action='edit_edge_label_enter_text'
                                           ).to_layout(hlayout)
        self.assumed_width = 200
        self.assumed_height = 37
        self.update_position()
Esempio n. 3
0
    def __init__(self, parent):
        UIEmbed.__init__(self, parent, None, 'Create new node')
        self.marker = None
        self.guess_mode = True
        layout = self.vlayout
        tt = 'Text for new node'
        smaller_font = qt_prefs.get_font(g.MAIN_FONT)
        big_font = QtGui.QFont(smaller_font)
        big_font.setPointSize(big_font.pointSize() * 2)
        self.input_line_edit = ExpandingLineEdit(self, tooltip=tt, big_font=big_font,
                                                 smaller_font=smaller_font, prefill='label',
                                                 on_edit=self.guess_type_for_input)
        layout.addWidget(self.input_line_edit)
        hlayout = box_row(layout)
        self.node_type_selector = SelectionBox(self)
        self.node_type_selector.currentIndexChanged.connect(self.changed_node_type)

        self.node_types = [(g.GUESS_FROM_INPUT, 'Guess from input')]
        for key in classes.node_types_order:
            add_action_name = f'add_{key}_node'
            add_action = add_action_name in ctrl.ui.actions and ctrl.ui.get_action(add_action_name)
            if add_action and add_action.enabler():
                node_class = classes.nodes.get(key, None)
                self.node_types.append((key, 'New %s' % node_class.display_name[0].lower()))
        self.node_type_selector.add_items(self.node_types)
        hlayout.addWidget(self.node_type_selector)
        hlayout.addStretch(0)
        # U+21A9 ↩
        self.enter_button = PushButtonBase(parent=self, text="Create ↩",
                                           action='create_new_node_from_text'
                                           ).to_layout(hlayout)
        self.assumed_width = 200
        self.assumed_height = 117
Esempio n. 4
0
    def __init__(self, parent, node):
        nname = node.display_name[0].lower()
        UIEmbed.__init__(self, parent, node, 'Edit ' + nname)
        layout = self.vlayout
        ui_p = ctrl.cm.get_qt_palette_for_ui()
        self.setPalette(ui_p)
        ui_s = QtGui.QPalette(ui_p)
        ui_s.setColor(QtGui.QPalette.Text, ctrl.cm.secondary())
        smaller_font = qt_prefs.get_font(g.MAIN_FONT)
        big_font = QtGui.QFont(smaller_font)
        big_font.setPointSize(big_font.pointSize() * 2)
        tt = 'Label used in syntactic computations, plain string. Visible in <i>syntactic mode</i> ' \
             'or if <i>Displayed label</i> is empty.'
        title = 'Syntactic label'
        self.synlabel = KatajaLineEdit(self, tooltip=tt, font=big_font, prefill='label',
                                       on_edit=self.synlabel_edited,
                                       on_finish=self.synlabel_finished,
                                       on_return=self.synlabel_finished)
        make_label(title, self, layout, tt, self.synlabel, ui_s)
        self.synlabel.setPalette(ui_p)
        layout.addWidget(self.synlabel)

        tt = 'Optional index for announcing link between multiple instances.'
        title = 'Index'
        self.index = KatajaLineEdit(self, tooltip=tt, font=big_font, prefill='i',
                                    on_finish=self.index_finished
                                    ).to_layout(layout, with_label=title, label_first=True)
        self.index.setPalette(ui_p)
        self.index.setMaximumWidth(20)

        self.update_embed()
        self.update_position()
        self.hide()
Esempio n. 5
0
    def __init__(self, parent):
        UIEmbed.__init__(self, parent, None, 'Create new node')
        self.marker = None
        self.guess_mode = True
        layout = QtWidgets.QVBoxLayout()
        layout.addLayout(self.top_row_layout)
        hlayout = box_row(layout)
        ui = self.ui_manager
        self.new_arrow_button = icon_text_button(ui, hlayout, self, '', '',
                                                 " &Arrow", 'new_arrow', size=QtCore.QSize(48, 20),
                                                 draw_method=arrow)
        self.divider_button = icon_text_button(ui, hlayout, self, '', '',
                                               " &Divider", 'new_divider',
                                               size=QtCore.QSize(48, 20), draw_method=divider)
        self.new_arrow_button.setFlat(False)
        self.divider_button.setFlat(False)
        self.new_arrow_button.hide()
        self.divider_button.hide()
        tt = 'Text for new node'
        smaller_font = qt_prefs.get_font(g.MAIN_FONT)
        big_font = QtGui.QFont(smaller_font)
        big_font.setPointSize(big_font.pointSize() * 2)
        self.input_line_edit = ExpandingLineEdit(self,
                                                 tip=tt,
                                                 big_font=big_font,
                                                 smaller_font=smaller_font,
                                                 prefill='label',
                                                 on_edit=self.guess_type_for_input)
        layout.addWidget(self.input_line_edit)
        hlayout = QtWidgets.QHBoxLayout()
        self.node_type_selector = SelectionBox(self)
        self.node_type_selector.currentIndexChanged.connect(self.changed_node_type)

        self.node_types = [('Guess from input', g.GUESS_FROM_INPUT)]
        for key in classes.node_types_order:
            # we have dedicated buttons for arrows and dividers
            #if key not in (g.ARROW, g.DIVIDER):
            node_class = classes.nodes.get(key, None)
            if (not node_class) or node_class.is_syntactic and not ctrl.free_drawing_mode:
                continue
            self.node_types.append(('New %s' % node_class.display_name[0].lower(), key))
        self.node_types.append(('New arrow', g.ARROW))
        #self.node_types.append(('New divider', g.DIVIDER))
        self.node_type_selector.add_items(self.node_types)
        hlayout.addWidget(self.node_type_selector)
        hlayout.addStretch(0)
        self.enter_button = QtWidgets.QPushButton("Create ↩")  # U+21A9 &#8617;
        ui.connect_element_to_action(self.enter_button, 'create_new_node_from_text')

        hlayout.addWidget(self.enter_button)
        layout.addLayout(hlayout)
        self.setLayout(layout)
        self.assumed_width = 200
        self.assumed_height = 117
Esempio n. 6
0
    def __init__(self, parent, node):
        nname = node.display_name[0].lower()
        UIEmbed.__init__(self, parent, node, 'Edit ' + nname)
        layout = self.vlayout
        ui_p = ctrl.cm.get_qt_palette_for_ui()
        self.setPalette(ui_p)
        ui_s = QtGui.QPalette(ui_p)
        ui_s.setColor(QtGui.QPalette.Text, ctrl.cm.secondary())
        ui_g = QtGui.QPalette(ui_p)
        ui_g.setColor(QtGui.QPalette.Text, ctrl.cm.get('accent5'))
        smaller_font = qt_prefs.get_font(g.MAIN_FONT)
        big_font = QtGui.QFont(smaller_font)
        big_font.setPointSize(big_font.pointSize() * 2)
        tt = 'Label used in syntactic computations, plain string. Visible in <i>syntactic mode</i> ' \
             'or if <i>Displayed label</i> is empty.'
        title = 'Syntactic label'
        self.synlabel = KatajaLineEdit(self, tooltip=tt, font=big_font, prefill='label')
        make_label(title, self, layout, tt, self.synlabel, ui_s)
        self.synlabel.setPalette(ui_p)
        layout.addWidget(self.synlabel)
        self.synlabel.setReadOnly(True)

        tt = 'Index to connect several copies of the same node in a tree.'
        title = 'Index'
        self.index = KatajaLineEdit(self, tooltip=tt, font=big_font, prefill='i'
                                    ).to_layout(layout, with_label=title, label_first=True)
        self.index.setReadOnly(True)
        self.index.setPalette(ui_p)
        self.index.setMaximumWidth(20)

        tt = 'Gloss is syntactically inert translation or explanation for the constituent'
        title = 'Gloss'
        self.gloss_label = KatajaLineEdit(self, tooltip=tt, font=big_font, prefill='gloss',
                                          on_finish=self.gloss_finished)
        self.gloss_label.setPalette(ui_g)
        make_label(title, self, layout, tt, self.gloss_label, ui_s)
        layout.addWidget(self.gloss_label)

        self.update_embed()
        self.update_position()
        self.hide()
Esempio n. 7
0
    def __init__(self, parent, node):
        nname = node.display_name[0].lower()
        UIEmbed.__init__(self, parent, node, 'Edit ' + nname)
        self.setMinimumWidth(220)
        self.editable = {}
        ui_p = self._palette
        ui_s = QtGui.QPalette(ui_p)
        ui_s.setColor(QtGui.QPalette.Text, ctrl.cm.secondary())
        smaller_font = qt_prefs.get_font(g.MAIN_FONT)
        big_font = QtGui.QFont(smaller_font)
        big_font.setPointSize(big_font.pointSize() * 2)
        self.prepare_template()
        sortable = [(item.get('order', 100), key) for key, item in self.editable.items()]
        sortable.sort()
        field_names = [key for order, key in sortable]
        self.fields = {}
        self.resize_target = None
        hlayout = None

        # Generate edit elements based on data, expand this as necessary
        for field_name in field_names:
            d = self.editable.get(field_name, {})
            # if d.get('hidden', False) or not self.host.check_conditions(d):
            #    continue
            tt = d.get('tooltip', '')
            itype = d.get('input_type', 'text')
            prefill = d.get('prefill', '')
            syntactic = d.get('syntactic', False)
            on_edit = d.get('on_edit', None)
            if on_edit and isinstance(on_edit, str):
                on_edit = getattr(node, on_edit, None)
            field_first = False
            if itype == 'text':
                width = d.get('width', 140)
                field = KatajaLineEdit(self, tooltip=tt, font=big_font, prefill=prefill,
                                       on_edit=on_edit)
                field.setMaximumWidth(width)
            elif itype == 'textarea':
                self._disable_effect = True
                template_width = d.get('width', 0)
                field = KatajaTextarea(self, tooltip=tt, font=smaller_font, prefill=prefill,
                                       on_edit=on_edit)
                max_w = 200
                if node.resizable and node.user_size:
                    w = node.user_size[0]
                elif template_width:
                    w = template_width
                else:
                    w = node.label_object.document().idealWidth()
                field.setFixedWidth(min(w, max_w))
                self.resize_target = field
            elif itype == 'expandingtext':
                field = ExpandingTextArea(self, tip=tt, font=smaller_font, prefill=prefill,
                                          on_edit=on_edit)
                template_width = d.get('width', 0)
                if template_width:
                    field.setFixedWidth(template_width)
                self.resize_target = field
            elif itype == 'checkbox':
                field = QtWidgets.QCheckBox(self)
            elif itype == 'preview':
                field = PreviewLabel(self, tip=tt, font=smaller_font)
            elif itype == 'spinbox':
                field = QtWidgets.QSpinBox(self)
                field.setMinimum(d.get('min', -1))
                field.setMaximum(d.get('max', 4))
            else:
                raise NotImplementedError

            if field:
                action = d.get('select_action')
                if action:
                    self.ui_manager.connect_element_to_action(field, action)
                if syntactic:
                    field.setPalette(ui_s)
                else:
                    field.setPalette(ui_p)

            align = d.get('align', 'newline')
            if align == 'newline':
                # new hlayout means new line, but before starting a new hlayout,
                # end the previous one.
                hlayout = box_row(self.vlayout)
            self.fields[field_name] = field
            if field_first:
                hlayout.addWidget(field)
            ui_name = d.get('name', field_name)
            if ui_name:
                if syntactic:
                    palette = ui_s
                else:
                    palette = ui_p
                make_label(ui_name, self, hlayout, tt, field, palette)
            if not field_first:
                hlayout.addWidget(field)
        hlayout = box_row(self.vlayout)
        hlayout.addStretch(0)
        # U+21A9 &#8617;
        self.enter_button = PushButtonBase(parent=self, text="Keep ↩",
                                           action='finish_editing_node')
        hlayout.addWidget(self.enter_button, 0, QtCore.Qt.AlignRight)
        if self.resize_target:
            self.resize_handle = ResizeHandle(self, self.resize_target)
            hlayout.addWidget(self.resize_handle, 0, QtCore.Qt.AlignRight)
        self.update_embed()
        self.update_position()
        self.hide()
Esempio n. 8
0
    def __init__(self, parent, node):
        nname = node.display_name[0].lower()
        UIEmbed.__init__(self, parent, node, 'Edit ' + nname)
        layout = QtWidgets.QVBoxLayout()
        layout.addLayout(self.top_row_layout)
        layout.addSpacing(4)
        ui_p = self._palette
        self.setPalette(ui_p)
        ui_s = QtGui.QPalette(ui_p)
        ui_s.setColor(QtGui.QPalette.Text, ctrl.cm.secondary())
        smaller_font = qt_prefs.get_font(g.MAIN_FONT)
        big_font = QtGui.QFont(smaller_font)
        big_font.setPointSize(big_font.pointSize() * 2)
        self.view_buttons = QtWidgets.QButtonGroup(self)
        self.view_buttons.setExclusive(True)

        self.synframebutton = EyeButton(
            'synlabels', 'All nodes show their syntactic labels')
        self.synframebutton.setChecked(True)
        self.ui_manager.connect_element_to_action(self.synframebutton,
                                                  'set_synlabels_visible')
        self.view_buttons.addButton(self.synframebutton)
        hlayout = QtWidgets.QHBoxLayout()
        hlayout.addWidget(self.synframebutton)
        vlayout = QtWidgets.QVBoxLayout()
        hlayout.addLayout(vlayout)
        tt = 'Label used in syntactic computations, plain string. Visible in <i>syntactic mode</i> ' \
             'or if <i>Displayed label</i> is empty.'
        title = 'Syntactic label'
        self.synlabel = EmbeddedLineEdit(self,
                                         tip=tt,
                                         font=big_font,
                                         prefill='label',
                                         on_edit=self.synlabel_edited,
                                         on_finish=self.synlabel_finished,
                                         on_return=self.synlabel_finished)
        make_label(title, self, vlayout, tt, self.synlabel, ui_s)
        self.synlabel.setPalette(ui_p)
        vlayout.addWidget(self.synlabel)
        layout.addLayout(hlayout)

        self.nodeframebutton = EyeButton(
            'nodelabels', 'All nodes show their user-given labels')
        self.view_buttons.addButton(self.nodeframebutton)
        self.ui_manager.connect_element_to_action(self.nodeframebutton,
                                                  'set_node_labels_visible')
        tt = "Freeform label or text for node, has no effect for syntactic computation"
        title = 'User label'
        self.label = ExpandingTextArea(self,
                                       tip=tt,
                                       font=smaller_font,
                                       prefill='label',
                                       on_edit=self.label_edited,
                                       label=title,
                                       on_focus_out=self.label_finished)
        self.label.setPalette(ui_p)
        self.resize_target = self.label
        hlayout = QtWidgets.QHBoxLayout()
        hlayout.addWidget(self.nodeframebutton)
        hlayout.addWidget(self.label)
        layout.addLayout(hlayout)

        self.autoframebutton = EyeButton(
            'autolabels', 'All nodes show their autogenerated x-bar '
            'labels')
        self.ui_manager.connect_element_to_action(self.autoframebutton,
                                                  'set_autolabels_visible')
        self.view_buttons.addButton(self.autoframebutton)
        hlayout = QtWidgets.QHBoxLayout()
        hlayout.addWidget(self.autoframebutton)
        vlayout = QtWidgets.QVBoxLayout()
        hlayout.addLayout(vlayout)
        tt = "These are either XBar or Bare phrase structure labels that are updated " \
             "automatically based on projections."
        title = 'Generated label'
        self.autolabel = EmbeddedLineEdit(self,
                                          tip=tt,
                                          font=big_font,
                                          prefill='autolabel')
        self.autolabel.setReadOnly(True)
        make_label(title, self, vlayout, tt, self.autolabel)
        vlayout.addWidget(self.autolabel)

        vlayout = QtWidgets.QVBoxLayout()
        tt = 'Optional index for announcing link between multiple instances.'
        title = 'Index'
        self.index = EmbeddedLineEdit(self,
                                      tip=tt,
                                      font=big_font,
                                      prefill='i',
                                      on_finish=self.index_finished)
        self.index.setPalette(ui_p)
        self.index.setMaximumWidth(20)
        make_label(title, self, vlayout, tt, self.index)
        vlayout.addWidget(self.index)
        hlayout.addLayout(vlayout)
        layout.addLayout(hlayout)

        hlayout = QtWidgets.QHBoxLayout()
        hlayout.addSpacing(28)
        tt = 'Node can be projection from either or both of its children if those children are ' \
             'heads or projections from their children.'
        title = 'Projects from'
        self.projections = ProjectionButtons(self)
        self.projections.setMaximumWidth(200)

        vlayout = QtWidgets.QVBoxLayout()
        if not self.projections.empty:
            make_label(title, self, vlayout, tt)
        vlayout.addWidget(self.projections)
        hlayout.addLayout(vlayout)
        layout.addLayout(hlayout)
        self.ui_manager.connect_element_to_action(
            self.projections,
            'set_projection_at_embed_ui',
            connect_slot=self.projections.connect_slot)
        if self.resize_target:
            self.resize_handle = ResizeHandle(self, self.resize_target)
            layout.addWidget(self.resize_handle, 0, QtCore.Qt.AlignRight)
        self.setLayout(layout)
        self.update_embed()
        self.update_position()
        self.hide()
Esempio n. 9
0
    def __init__(self, parent, node):
        nname = node.display_name[0].lower()
        UIEmbed.__init__(self, parent, node, 'Edit ' + nname)
        layout = QtWidgets.QVBoxLayout()
        layout.addLayout(self.top_row_layout)
        layout.addSpacing(4)
        ui_p = self._palette
        ui_s = QtGui.QPalette(ui_p)
        ui_s.setColor(QtGui.QPalette.Text, ctrl.cm.secondary())
        smaller_font = qt_prefs.get_font(g.MAIN_FONT)
        big_font = QtGui.QFont(smaller_font)
        big_font.setPointSize(big_font.pointSize() * 2)
        ed = node.get_editing_template()
        sortable = [(item.get('order', 100), key) for key, item in ed.items()]
        sortable.sort()
        field_names = [key for order, key in sortable]
        self.fields = {}
        self.resize_target = None
        hlayout = None

        # Generate edit elements based on data, expand this as necessary
        for field_name in field_names:
            d = ed.get(field_name, {})
            if d.get('hidden', False) or not self.host.check_conditions(d):
                continue
            tt = d.get('tooltip', '')
            itype = d.get('input_type', 'text')
            prefill = d.get('prefill', '')
            syntactic = d.get('syntactic', False)
            on_edit = d.get('on_edit', None)
            if on_edit and isinstance(on_edit, str):
                on_edit = getattr(node, on_edit, None)
            field_first = False
            field = None
            if itype == 'text':
                width = d.get('width', 140)
                field = EmbeddedLineEdit(self,
                                         tip=tt,
                                         font=big_font,
                                         prefill=prefill,
                                         on_edit=on_edit)
                field.setMaximumWidth(width)
            elif itype == 'textarea':
                self._disable_effect = True
                template_width = d.get('width', 0)
                field = EmbeddedTextarea(self,
                                         tip=tt,
                                         font=smaller_font,
                                         prefill=prefill,
                                         on_edit=on_edit)
                max_w = 200
                if node.user_size:
                    w = node.user_size[0]
                elif template_width:
                    w = template_width
                else:
                    w = node.label_object.document().idealWidth()
                field.setFixedWidth(min(w, max_w))
                self.resize_target = field
            elif itype == 'expandingtext':
                field = ExpandingTextArea(self,
                                          tip=tt,
                                          font=smaller_font,
                                          prefill=prefill,
                                          on_edit=on_edit)
                template_width = d.get('width', 0)
                if template_width:
                    field.setFixedWidth(template_width)
                self.resize_target = field
            elif itype == 'multibutton':
                width = d.get('width', 200)
                op_func = d.get('option_function')
                op_func = getattr(self.host, op_func, None) or getattr(
                    self.syntactic_object, op_func, None)
                field = EmbeddedMultibutton(self, options=op_func())
                field.setMaximumWidth(width)
            elif itype == 'projection_buttons':
                width = d.get('width', 200)
                field = ProjectionButtons(self)
                field.setMaximumWidth(width)
            elif itype == 'checkbox':
                field = QtWidgets.QCheckBox(self)
            elif itype == 'radiobutton':
                width = d.get('width', 200)
                op_func = d.get('option_function')
                op_func = getattr(self.host, op_func, None) or \
                          getattr(self.syntactic_object, op_func, None)
                field = EmbeddedRadiobutton(self, options=op_func())
                field.setMaximumWidth(width)
                field_first = False
            elif itype == 'preview':
                field = PreviewLabel(self, tip=tt, font=smaller_font)
            elif itype == 'spinbox':
                field = QtWidgets.QSpinBox(self)
                field.setMinimum(d.get('min', -1))
                field.setMaximum(d.get('max', 4))
            else:
                raise NotImplementedError

            if field:
                action = d.get('select_action')
                if action:
                    connect_slot = getattr(field, 'connect_slot', None)
                    self.ui_manager.connect_element_to_action(
                        field, action, connect_slot=connect_slot)
                if syntactic:
                    field.setPalette(ui_s)
                else:
                    field.setPalette(ui_p)

            align = d.get('align', 'newline')
            if align == 'newline':
                # new hlayout means new line, but before starting a new hlayout,
                # end the previous one.
                if hlayout:
                    layout.addLayout(hlayout)
                hlayout = QtWidgets.QHBoxLayout()
            self.fields[field_name] = field
            if field_first:
                hlayout.addWidget(field)
            ui_name = d.get('name', field_name)
            if ui_name:
                if syntactic:
                    palette = ui_s
                else:
                    palette = ui_p
                make_label(ui_name, self, hlayout, tt, field, palette)
            if not field_first:
                hlayout.addWidget(field)
        if hlayout:
            layout.addLayout(hlayout)
        hlayout = QtWidgets.QHBoxLayout()
        self.enter_button = QtWidgets.QPushButton("Keep ↩")  # U+21A9 &#8617;
        self.enter_button.setParent(self)
        self.ui_manager.connect_element_to_action(self.enter_button,
                                                  'finish_editing_node')
        hlayout.addStretch(0)
        hlayout.addWidget(self.enter_button, 0, QtCore.Qt.AlignRight)
        if self.resize_target:
            self.resize_handle = ResizeHandle(self, self.resize_target)
            hlayout.addWidget(self.resize_handle, 0, QtCore.Qt.AlignRight)
        layout.addLayout(hlayout)
        self.setLayout(layout)
        self.update_embed()
        self.update_position()
        self.hide()
Esempio n. 10
0
    def __init__(self, parent, edge):
        UIEmbed.__init__(self, parent, edge, 'Highlight a group of nodes')
        self.marker = None
        ui = self.ui_manager
        layout = QtWidgets.QVBoxLayout()
        layout.addLayout(self.top_row_layout)  # close-button from UIEmbed
        smaller_font = qt_prefs.get_font(g.ITALIC_FONT)
        big_font = QtGui.QFont(smaller_font)
        big_font.setPointSize(big_font.pointSize() * 2)
        self.input_line_edit = ExpandingLineEdit(self,
                                                 big_font=big_font,
                                                 smaller_font=smaller_font,
                                                 prefill='label')
        hlayout = QtWidgets.QHBoxLayout()
        hlayout.addWidget(self.input_line_edit)
        label = make_label('Name for the group (optional)',
                           parent=self,
                           layout=hlayout,
                           tooltip='Group of nodes can be singled out and named, e.g. as phases',
                           buddy=self.input_line_edit)
        layout.addLayout(hlayout)
        hlayout = QtWidgets.QHBoxLayout()
        self.color_select = ColorSelector(self)
        ui.connect_element_to_action(self.color_select, 'change_group_color')
        hlayout.addWidget(self.color_select, 1, QtCore.Qt.AlignRight)
        label = make_label('Color',
                           parent=self,
                           layout=hlayout,
                           tooltip='Select color for highlight',
                           buddy=self.color_select,
                           align=QtCore.Qt.AlignLeft)
        self.fill_checkbox = QtWidgets.QCheckBox()
        ui.connect_element_to_action(self.fill_checkbox, 'change_group_fill')
        hlayout.addWidget(self.fill_checkbox, 1, QtCore.Qt.AlignRight)
        label = make_label('Fill',
                           parent=self,
                           layout=hlayout,
                           tooltip="Group area is marked with translucent color",
                           buddy=self.fill_checkbox,
                           align=QtCore.Qt.AlignLeft)
        self.outline_checkbox = QtWidgets.QCheckBox()
        ui.connect_element_to_action(self.outline_checkbox, 'change_group_outline')
        hlayout.addWidget(self.outline_checkbox, 1, QtCore.Qt.AlignRight)
        label = make_label('Outline',
                           parent=self,
                           layout=hlayout,
                           tooltip="Group is marked by line drawn around it",
                           buddy=self.outline_checkbox,
                           align=QtCore.Qt.AlignLeft)

        self.include_children_checkbox = QtWidgets.QCheckBox()
        ui.connect_element_to_action(self.include_children_checkbox, 'change_group_children')
        hlayout.addWidget(self.include_children_checkbox, 1, QtCore.Qt.AlignRight)
        label = make_label('Include children',
                           parent=self,
                           layout=hlayout,
                           tooltip="Automatically add child nodes to group's scope",
                           buddy=self.include_children_checkbox,
                           align=QtCore.Qt.AlignLeft)
        self.allow_overlap_checkbox = QtWidgets.QCheckBox()
        ui.connect_element_to_action(self.allow_overlap_checkbox, 'change_group_overlaps')
        hlayout.addWidget(self.allow_overlap_checkbox, 1, QtCore.Qt.AlignRight)
        label = make_label('Allow groups to overlap',
                           parent=self,
                           layout=hlayout,
                           tooltip="Can group include members of other group. If not, lower group "
                                   "has priority",
                           buddy=self.allow_overlap_checkbox,
                           align=QtCore.Qt.AlignLeft)

        layout.addLayout(hlayout)
        hlayout = QtWidgets.QHBoxLayout()
        self.delete_button = QtWidgets.QPushButton("Delete")  # U+21A9 &#8617;
        self.delete_button.setMaximumWidth(60)
        ui.connect_element_to_action(self.delete_button, 'delete_group')

        hlayout.addWidget(self.delete_button)
        self.enter_button = QtWidgets.QPushButton("Keep ↩")  # U+21A9 &#8617;
        self.enter_button.setMaximumWidth(60)
        ui.connect_element_to_action(self.enter_button, 'save_group_changes')
        hlayout.addStretch(0)
        hlayout.addWidget(self.enter_button)
        layout.addLayout(hlayout)
        self.setLayout(layout)
        #self.assumed_width = 200
        #self.assumed_height = 37
        self.update_position()
        self.setEnabled(True)