示例#1
0
    def __init__(self, scene, x, y, caption, answers, done_cb, parent=None):

        self.w = 0
        self.h = 0

        super(DialogItem, self).__init__(scene, x, y, parent=parent)

        self.sp = self.m2pix(0.01)
        self.done_cb = done_cb
        self.fixed = False

        self.desc = DescItem(scene, 0, 0, self)
        self.desc.set_content(caption)

        self.items = []

        self.w = (len(answers) + 1) * self.sp

        for answer in answers:

            btn = ButtonItem(self.scene(), 0, 0, answer, self, self.answer_cb)
            self.items.append(btn)
            self.w += btn._width()

        y = self.sp
        self._place_childs_horizontally(y, self.sp, [self.desc])
        y += self.desc._height() + self.sp
        self._place_childs_horizontally(y, self.sp, self.items)
        y += self.items[0]._height()
        y += self.sp

        self.h = y
        self.update()
        self.setZValue(300)
示例#2
0
    def __init__(self, scene, x, y, w, data, item_selected_cb=None, parent=None):

        self.w = 100
        self.h = 100
        self.sp = 0

        self.item_selected_cb = item_selected_cb

        super(ListItem, self).__init__(scene, x, y, parent)

        self.w = self.m2pix(w)
        self.h = self.m2pix(0.2)
        self.sp = self.m2pix(0.005)

        self.items = []

        self.middle_item_idx = 0
        self.selected_item_idx = None

        for d in data:

            self.items.append(ButtonItem(self.scene(), 0, 0,
                                         d, self, self.item_clicked_cb, width=w, push_button=True))

        rospack = rospkg.RosPack()
        icons_path = rospack.get_path('art_projected_gui') + '/icons/'

        self.up_btn = ButtonItem(self.scene(), 0, 0, translate(
            "ProgramItem", "Up"), self, self.up_btn_cb, width=w, image_path=icons_path + "arrow-up.svg")
        self.down_btn = ButtonItem(self.scene(), 0, 0, translate(
            "ProgramItem", "Down"), self, self.down_btn_cb, width=w, image_path=icons_path + "arrow-down.svg")

        self.up_btn.setPos(0,  0)
        self.down_btn.setPos(0, self.h - self.down_btn.boundingRect().height())

        self.set_current_idx(min(1, len(self.items) - 1))

        self.update()
示例#3
0
    def __init__(self, scene, x, y, w, data, item_selected_cb=None, parent=None):

        self.w = 100
        self.h = 100
        self.sp = 0

        self.item_selected_cb = item_selected_cb

        super(ListItem, self).__init__(scene, x, y, parent=parent)

        self.w = self.m2pix(w)
        self.h = self.m2pix(0.2)
        self.sp = self.m2pix(0.005)

        self.items = []

        self.middle_item_idx = 0
        self.selected_item_idx = None

        for d in data:

            self.items.append(ButtonItem(self.scene(), 0, 0,
                                         d, self, self.item_clicked_cb, width=w, push_button=True))

        # TODO down_btn is not properly aligned
        self.up_btn = ButtonItem(self.scene(), 0, 0, "", self, self.up_btn_cb, width=w / 2 - 0.005 / 2,
                                 image_path=icons_path + "arrow-up.svg")
        self.down_btn = ButtonItem(self.scene(), 0, 0, "", self, self.down_btn_cb, width=w / 2 - 0.005 / 2,
                                   image_path=icons_path + "arrow-down.svg")

        self.up_btn.setPos(0, self.h - self.down_btn.boundingRect().height())
        self.down_btn.setPos(self.up_btn.boundingRect().width() + self.sp,
                             self.h - self.down_btn.boundingRect().height())

        self.set_current_idx(min(1, len(self.items) - 1))

        self.update()
示例#4
0
    def __init__(self, scene, x, y, caption, answers, done_cb, parent=None):

        self.w = 0
        self.h = 0

        super(DialogItem, self).__init__(scene, x, y, parent=parent)

        self.sp = self.m2pix(0.01)
        self.done_cb = done_cb
        self.fixed = False

        self.desc = DescItem(scene, 0, 0, self)
        self.desc.set_content(caption, color=QtCore.Qt.white)

        self.items = []

        for answer in answers:

            btn = ButtonItem(self.scene(), 0, 0, answer, self, self.answer_cb)
            self.items.append(btn)

        self.w = max(self.desc.boundingRect().width(),
                     sum(btn.boundingRect().width() for btn in self.items)) + 2 * self.sp

        y = self.sp
        self._place_childs_horizontally(y, self.sp, [self.desc])
        y += self.desc._height() + self.sp
        self._place_childs_horizontally(y, self.sp, self.items)
        y += self.items[0]._height()
        y += self.sp

        self.h = y

        self.setFlag(QtGui.QGraphicsItem.ItemIsMovable, True)
        self.setFlag(QtGui.QGraphicsItem.ItemIsSelectable, True)

        self.update()
        self.setZValue(300)
示例#5
0
    def __init__(self,
                 scene,
                 x,
                 y,
                 program_helper,
                 done_cb=None,
                 item_switched_cb=None,
                 learning_request_cb=None):

        self.w = 100
        self.h = 100

        self.done_cb = done_cb
        self.item_switched_cb = item_switched_cb
        self.learning_request_cb = learning_request_cb

        self.readonly = False

        super(ProgramItem, self).__init__(scene, x, y)

        self.w = self.m2pix(0.2)
        self.h = self.m2pix(0.25)
        self.sp = self.m2pix(0.005)

        self.ph = program_helper

        self.block_id = None
        self.item_id = None
        self.block_learned = False
        self.program_learned = False

        # block "view"
        self.block_finished_btn = ButtonItem(self.scene(), 0, 0,
                                             translate("ProgramItem", "Done"),
                                             self, self.block_finished_btn_cb)
        self.block_edit_btn = ButtonItem(self.scene(), 0, 0,
                                         translate("ProgramItem", "Edit"),
                                         self, self.block_edit_btn_cb)
        self.block_on_failure_btn = ButtonItem(
            self.scene(), 0, 0, translate("ProgramItem", "On fail"), self,
            self.block_on_failure_btn)

        bdata = []

        self.blocks_map = {}  # map from indexes (key) to block_id (value)
        self.blocks_map_rev = {}

        block_id = self.ph.get_first_block_id()

        while block_id != 0:

            bmsg = self.ph.get_block_msg(block_id)

            bdata.append("Block ID: " + str(block_id) + "\nName: " + bmsg.name)
            idx = len(bdata) - 1
            self.blocks_map[idx] = block_id
            self.blocks_map_rev[block_id] = idx

            block_id = self.ph.get_block_on_success(block_id)

            # test for cycle
            if block_id in self.blocks_map_rev:
                break

        self.blocks_list = ListItem(self.scene(),
                                    0,
                                    0,
                                    0.2 - 2 * 0.005,
                                    bdata,
                                    self.block_selected_cb,
                                    parent=self)

        for k, v in self.blocks_map.iteritems():

            self._update_block(v)

        y = 50
        self.blocks_list.setPos(self.sp, y)
        y += self.blocks_list._height() + self.sp

        self._place_childs_horizontally(y, self.sp, [
            self.block_finished_btn, self.block_edit_btn,
            self.block_on_failure_btn
        ])

        y += self.block_finished_btn._height() + self.sp

        group_enable((self.block_edit_btn, self.block_on_failure_btn), False)

        self.h = y
        self.update()

        # items "view"
        self.item_edit_btn = ButtonItem(self.scene(), 0, 0,
                                        translate("ProgramItem", "Edit"), self,
                                        self.item_edit_btn_cb)
        self.item_run_btn = ButtonItem(self.scene(), 0, 0,
                                       translate("ProgramItem", "Run"), self,
                                       self.item_run_btn_cb)
        self.item_on_failure_btn = ButtonItem(
            self.scene(), 0, 0, translate("ProgramItem", "On fail"), self,
            self.item_on_failure_btn_cb)

        self.item_finished_btn = ButtonItem(
            self.scene(), 0, 0, translate("ProgramItem", "Back to blocks"),
            self, self.item_finished_btn_cb)

        self.items_list = None

        group_visible((self.item_finished_btn, self.item_run_btn,
                       self.item_on_failure_btn, self.item_edit_btn), False)

        # readonly (program running) "view"
        self.pr_pause_btn = ButtonItem(self.scene(), 0, 0,
                                       translate("ProgramItem", "Pause"), self,
                                       self.pr_pause_btn_cb)
        self.pr_repeat_btn = ButtonItem(self.scene(), 0, 0,
                                        translate("ProgramItem", "Repeat"),
                                        self, self.pr_repeat_btn_cb)
        self.pr_cancel_btn = ButtonItem(self.scene(), 0, 0,
                                        translate("ProgramItem", "Cancel"),
                                        self, self.pr_cancel_btn_cb)

        group_visible(
            (self.pr_pause_btn, self.pr_repeat_btn, self.pr_cancel_btn), False)

        self.fixed = False

        self.editing_item = False
        self.edit_request = False
        self.run_request = False

        self.setZValue(100)
示例#6
0
    def __init__(self,
                 scene,
                 x,
                 y,
                 program_headers,
                 learned_dict,
                 selected_program_id=None,
                 program_selected_cb=None):

        self.w = 100
        self.h = 100

        self.program_headers = program_headers
        self.learned_dict = learned_dict
        self.program_selected_cb = program_selected_cb

        super(ProgramListItem, self).__init__(scene, x, y)

        self.w = self.m2pix(0.2)
        self.h = self.m2pix(0.25)

        self.fixed = False
        self.setZValue(100)

        data = []
        self.map_from_idx_to_program_id = {}
        self.map_from_program_id_to_idx = {}

        for ph in self.program_headers:

            data.append("ID: " + str(ph.id) + "\nName: " + ph.name)
            idx = len(data) - 1
            self.map_from_idx_to_program_id[idx] = ph.id
            self.map_from_program_id_to_idx[ph.id] = idx

        self.list = ListItem(scene,
                             0,
                             0,
                             0.2 - 2 * 0.005,
                             data,
                             self.item_selected_cb,
                             parent=self)

        for idx in range(0, len(data)):

            if not self.learned_dict[self.map_from_idx_to_program_id[idx]]:
                self.list.items[idx].set_background_color(QtCore.Qt.red)

        self.run_btn = ButtonItem(scene, 0, 0, translate("ProgramItem", "Run"),
                                  self, self.run_btn_cb)
        self.edit_btn = ButtonItem(scene, 0, 0,
                                   translate("ProgramItem",
                                             "Edit"), self, self.edit_btn_cb)
        self.template_btn = ButtonItem(scene, 0, 0,
                                       translate("ProgramItem", "Template"),
                                       self, self.template_btn_cb)

        self.run_btn.set_enabled(False)
        self.edit_btn.set_enabled(False)
        self.template_btn.set_enabled(False)

        if selected_program_id is not None:

            self.list.set_current_idx(
                self.map_from_program_id_to_idx[selected_program_id])

        sp = self.m2pix(0.005)
        h = 50
        self.list.setPos(sp, h)
        h += self.list._height()
        h += 2 * sp

        self._place_childs_horizontally(
            h, sp, [self.run_btn, self.edit_btn, self.template_btn])

        h += self.run_btn._height()
        h += 3 * sp

        self.h = h
        self.update()
示例#7
0
    def __init__(self,
                 scene,
                 x,
                 y,
                 program_helper,
                 instruction,
                 ih,
                 done_cb=None,
                 item_switched_cb=None,
                 learning_request_cb=None,
                 pause_cb=None,
                 cancel_cb=None,
                 stopped=False,
                 visualize=False,
                 v_visualize_cb=None,
                 v_back_cb=None,
                 vis_pause_cb=None,
                 vis_stop_cb=None,
                 vis_replay_cb=None,
                 vis_back_to_blocks_cb=None):

        self.w = 100
        self.h = 100

        self.instruction = instruction
        self.ih = ih

        self.done_cb = done_cb
        self.item_switched_cb = item_switched_cb
        self.learning_request_cb = learning_request_cb
        self.pause_cb = pause_cb
        self.cancel_cb = cancel_cb

        self.readonly = False
        self.stopped = stopped

        # variables for HoloLens visualization
        self.visualize = visualize
        self.visualization_paused = False
        # callbacks for visualization buttons
        self.v_visualize_cb = v_visualize_cb
        self.v_back_cb = v_back_cb
        self.vis_pause_cb = vis_pause_cb
        self.vis_stop_cb = vis_stop_cb
        self.vis_replay_cb = vis_replay_cb
        self.vis_back_to_blocks_cb = vis_back_to_blocks_cb

        super(ProgramItem, self).__init__(scene, x, y)

        self.title = DescItem(self.scene(), 0, 0, self)

        # TODO it should take coords given to __init__
        self.title.setPos(QtCore.QPointF(self.m2pix(0.01), self.m2pix(0.01)))

        self.w = self.m2pix(0.2)
        self.h = self.m2pix(0.25)
        self.sp = self.m2pix(0.005)

        self.ph = program_helper

        self.block_id = None
        self.item_id = None

        self.block_learned = False
        self.program_learned = False

        # block "view"
        self.block_finished_btn = ButtonItem(self.scene(),
                                             0,
                                             0,
                                             "BTN",
                                             self,
                                             self.block_finished_btn_cb,
                                             image_path=icons_path +
                                             "back.svg")
        self.block_edit_btn = ButtonItem(self.scene(),
                                         0,
                                         0,
                                         "BTN",
                                         self,
                                         self.block_edit_btn_cb,
                                         image_path=icons_path + "edit.svg")

        self.block_on_success_btn = ButtonItem(self.scene(),
                                               0,
                                               0,
                                               "BTN",
                                               self,
                                               self.block_on_success_btn_cb,
                                               image_path=icons_path +
                                               "success.svg")
        self.block_on_failure_btn = ButtonItem(self.scene(),
                                               0,
                                               0,
                                               "BTN",
                                               self,
                                               self.block_on_failure_btn_cb,
                                               image_path=icons_path +
                                               "failure.svg")

        # block "view" when in visualization
        self.program_visualize_btn = ButtonItem(
            self.scene(), 0, 0, translate("ProgramItem", "Visualize Program"),
            self, self.program_visualize_btn_cb)
        self.block_visualize_btn = ButtonItem(
            self.scene(), 0, 0, translate("ProgramItem", "Visualize Block"),
            self, self.block_visualize_btn_cb)
        self.block_back_btn = ButtonItem(self.scene(), 0, 0,
                                         translate("ProgramItem", "Back"),
                                         self, self.block_back_btn_cb)

        bdata = []

        self.blocks_map = {}  # map from indexes (key) to block_id (value)
        self.blocks_map_rev = {}

        for i in range(len(self.ph.get_program().blocks)):

            bmsg = self.ph.get_program().blocks[i]

            bdata.append(
                translate("ProgramItem",
                          "Block %1\n%2\nSuccess: %3, failure: %4").arg(
                              bmsg.id).arg(bmsg.name).arg(bmsg.on_success).arg(
                                  bmsg.on_failure))
            idx = len(bdata) - 1
            self.blocks_map[idx] = bmsg.id
            self.blocks_map_rev[bmsg.id] = idx

        self.blocks_list = ListItem(self.scene(),
                                    0,
                                    0,
                                    0.2 - 2 * 0.005,
                                    bdata,
                                    self.block_selected_cb,
                                    parent=self)

        for k, v in self.blocks_map.iteritems():

            self._update_block(v)

        y = self.title.mapToParent(self.title.boundingRect().bottomLeft()).y()
        self.blocks_list.setPos(self.sp, y)
        y += self.blocks_list._height() + self.sp

        if visualize:
            self._place_childs_horizontally(y, self.sp, [
                self.program_visualize_btn, self.block_visualize_btn,
                self.block_back_btn
            ])

            y += self.block_visualize_btn._height() + self.sp

            self.block_back_btn.set_enabled(True)
            self.block_visualize_btn.set_enabled(False)
            self.program_visualize_btn.set_enabled(True)

            # hide edit block buttons
            group_visible(
                (self.block_finished_btn, self.block_edit_btn,
                 self.block_on_failure_btn, self.block_on_success_btn), False)

        else:
            self._place_childs_horizontally(y, self.sp, [
                self.block_edit_btn, self.block_on_success_btn,
                self.block_on_failure_btn, self.block_finished_btn
            ])

            y += self.block_finished_btn._height() + self.sp

            group_enable((self.block_edit_btn, self.block_on_failure_btn,
                          self.block_on_success_btn), False)
            # hide visualization block buttons
            group_visible((self.block_visualize_btn,
                           self.program_visualize_btn, self.block_back_btn),
                          False)

        self.h = y

        # items "view"
        self.item_edit_btn = ButtonItem(self.scene(),
                                        0,
                                        0,
                                        translate("ProgramItem", "Ed"),
                                        self,
                                        self.item_edit_btn_cb,
                                        image_path=icons_path + "edit.svg")
        self.item_run_btn = ButtonItem(self.scene(),
                                       0,
                                       0,
                                       "BTN",
                                       self,
                                       self.item_run_btn_cb,
                                       image_path=icons_path + "run.svg")
        self.item_on_success_btn = ButtonItem(self.scene(),
                                              0,
                                              0,
                                              "BTN",
                                              self,
                                              self.item_on_success_btn_cb,
                                              image_path=icons_path +
                                              "success.svg")
        self.item_on_failure_btn = ButtonItem(self.scene(),
                                              0,
                                              0,
                                              "BTN",
                                              self,
                                              self.item_on_failure_btn_cb,
                                              image_path=icons_path +
                                              "failure.svg")
        self.item_finished_btn = ButtonItem(self.scene(),
                                            0,
                                            0,
                                            "BTN",
                                            self,
                                            self.item_finished_btn_cb,
                                            image_path=icons_path + "back.svg")

        self.items_list = None

        group_visible((self.item_finished_btn, self.item_run_btn,
                       self.item_on_success_btn, self.item_on_failure_btn,
                       self.item_edit_btn), False)

        # readonly (program running) "view"
        self.pr_pause_btn = ButtonItem(self.scene(),
                                       0,
                                       0,
                                       "BTN",
                                       self,
                                       self.pr_pause_btn_cb,
                                       image_path=icons_path + "pause.svg")

        if self.stopped:
            self.pr_pause_btn.set_image(icons_path + "run.svg")

        self.pr_cancel_btn = ButtonItem(self.scene(),
                                        0,
                                        0,
                                        "BTN",
                                        self,
                                        self.pr_cancel_btn_cb,
                                        image_path=icons_path + "stop.svg")

        group_visible((self.pr_pause_btn, self.pr_cancel_btn), False)

        # buttons for HoloLens visualization
        self.vis_pause_btn = ButtonItem(self.scene(), 0, 0,
                                        translate("ProgramItem", "Resume"),
                                        self, self.vis_pause_btn_cb)
        # quick hack .. init button with 'Resume' caption and switch back to
        # 'Pause' to keep the button large enough for text switching
        if not self.visualization_paused:
            self.vis_pause_btn.set_caption(translate("ProgramItem", "Pause"))
        self.vis_stop_btn = ButtonItem(self.scene(), 0, 0,
                                       translate("ProgramItem", "Stop"), self,
                                       self.vis_stop_btn_cb)
        self.vis_replay_btn = ButtonItem(self.scene(), 0, 0,
                                         translate("ProgramItem", "Replay"),
                                         self, self.vis_replay_btn_cb)
        self.vis_back_btn = ButtonItem(
            self.scene(), 0, 0, translate("ProgramItem", "Back to blocks"),
            self, self.vis_back_btn_cb)
        group_visible((self.vis_pause_btn, self.vis_stop_btn,
                       self.vis_replay_btn, self.vis_back_btn), False)

        self.fixed = False

        self.editing_item = False
        self.edit_request = False
        self.run_request = False

        self.setFlag(QtGui.QGraphicsItem.ItemIsMovable, True)
        self.setFlag(QtGui.QGraphicsItem.ItemIsSelectable, True)

        self.setZValue(100)

        self._update_learned()
        self.update()

        if self.item_switched_cb:
            self.item_switched_cb(None, None, blocks=True)
示例#8
0
    def __init__(
            self,
            scene,
            x,
            y,
            program_headers,
            learned_dict,
            selected_program_id=None,
            program_selected_cb=None,
            program_selection_changed_cb=None):

        self.w = 100
        self.h = 100

        self.program_headers = program_headers
        self.learned_dict = learned_dict
        self.program_selected_cb = program_selected_cb
        self.program_selection_changed_cb = program_selection_changed_cb

        super(ProgramListItem, self).__init__(scene, x, y)

        self.w = self.m2pix(0.2)
        self.h = self.m2pix(0.25)

        self.fixed = False
        self.setZValue(100)

        title = DescItem(self.scene(), 0, 0, self)
        title.set_content(translate("ProgramListItem", "Program list"), 1.2)
        title.setPos(QtCore.QPointF(self.m2pix(0.01), self.m2pix(0.01)))  # TODO it should take coords given to __init__

        data = []
        self.map_from_idx_to_program_id = {}
        self.map_from_program_id_to_idx = {}

        self.program_headers.sort(key=lambda p: p.id)

        for ph in self.program_headers:

            data.append("Program " + str(ph.id) + "\n" + ph.name)
            idx = len(data) - 1
            self.map_from_idx_to_program_id[idx] = ph.id
            self.map_from_program_id_to_idx[ph.id] = idx

        self.list = ListItem(scene, 0, 0, 0.2 - 2 * 0.005, data, self.item_selected_cb, parent=self)

        for idx in range(0, len(data)):

            if not self.learned_dict[self.map_from_idx_to_program_id[idx]]:
                self.list.items[idx].set_background_color(QtCore.Qt.red)

        rospack = rospkg.RosPack()
        icons_path = rospack.get_path('art_projected_gui') + '/icons/'

        self.run_btn = ButtonItem(scene, 0, 0, "BTN", self, self.run_btn_cb, image_path=icons_path + "run.svg")
        self.edit_btn = ButtonItem(scene, 0, 0, "BTN", self, self.edit_btn_cb, image_path=icons_path + "edit.svg")
        self.template_btn = ButtonItem(scene, 0, 0, "BTN", self, self.template_btn_cb,
                                       image_path=icons_path + "template.svg")
        self.visualize_btn = ButtonItem(scene, 0, 0, "BTN", self, self.visualize_btn_cb,
                                        image_path=icons_path + "visualize.svg")

        self.run_btn.set_enabled(False)
        self.edit_btn.set_enabled(False)
        self.template_btn.set_enabled(False)
        self.visualize_btn.set_enabled(False)

        if selected_program_id is not None:

            self.list.set_current_idx(self.map_from_program_id_to_idx[selected_program_id])

        sp = self.m2pix(0.005)
        # h = title.mapToParent(title.boundingRect().bottomLeft()).y() + sp
        h = 0

        self.list.setPos(sp, h)
        h += self.list._height()
        h += 2 * sp

        btns = (self.run_btn, self.edit_btn, self.template_btn, self.visualize_btn)

        self._place_childs_horizontally(h, sp, btns)
        h += self.run_btn._height()

        h += 3 * sp

        self.h = h

        self.setFlag(QtGui.QGraphicsItem.ItemIsMovable, True)
        self.setFlag(QtGui.QGraphicsItem.ItemIsSelectable, True)

        self.update()
示例#9
0
    def __init__(self,
                 scene,
                 x,
                 y,
                 program_helper,
                 done_cb=None,
                 item_switched_cb=None,
                 learning_request_cb=None,
                 pause_cb=None,
                 cancel_cb=None,
                 stopped=False):

        self.w = 100
        self.h = 100

        self.done_cb = done_cb
        self.item_switched_cb = item_switched_cb
        self.learning_request_cb = learning_request_cb
        self.pause_cb = pause_cb
        self.cancel_cb = cancel_cb

        self.readonly = False
        self.stopped = stopped

        super(ProgramItem, self).__init__(scene, x, y)

        self.w = self.m2pix(0.2)
        self.h = self.m2pix(0.25)
        self.sp = self.m2pix(0.005)

        self.ph = program_helper

        self.block_id = None
        self.item_id = None

        self.block_learned = False
        self.program_learned = False

        # block "view"
        self.block_finished_btn = ButtonItem(self.scene(), 0, 0,
                                             translate("ProgramItem", "Done"),
                                             self, self.block_finished_btn_cb)
        self.block_edit_btn = ButtonItem(self.scene(), 0, 0,
                                         translate("ProgramItem", "Edit"),
                                         self, self.block_edit_btn_cb)
        self.block_on_failure_btn = ButtonItem(
            self.scene(), 0, 0, translate("ProgramItem", "On fail"), self,
            self.block_on_failure_btn)

        bdata = []

        self.blocks_map = {}  # map from indexes (key) to block_id (value)
        self.blocks_map_rev = {}

        for i in range(len(self.ph.get_program().blocks)):

            bmsg = self.ph.get_program().blocks[i]

            bdata.append(
                translate("ProgramItem",
                          "Block %1\n%2").arg(bmsg.id).arg(bmsg.name))
            idx = len(bdata) - 1
            self.blocks_map[idx] = bmsg.id
            self.blocks_map_rev[bmsg.id] = idx

        self.blocks_list = ListItem(self.scene(),
                                    0,
                                    0,
                                    0.2 - 2 * 0.005,
                                    bdata,
                                    self.block_selected_cb,
                                    parent=self)

        for k, v in self.blocks_map.iteritems():

            self._update_block(v)

        y = 50
        self.blocks_list.setPos(self.sp, y)
        y += self.blocks_list._height() + self.sp

        self._place_childs_horizontally(y, self.sp, [
            self.block_finished_btn, self.block_edit_btn,
            self.block_on_failure_btn
        ])

        y += self.block_finished_btn._height() + self.sp

        group_enable((self.block_edit_btn, self.block_on_failure_btn), False)

        self.h = y

        # items "view"
        self.item_edit_btn = ButtonItem(self.scene(), 0, 0,
                                        translate("ProgramItem", "Edit"), self,
                                        self.item_edit_btn_cb)
        self.item_run_btn = ButtonItem(self.scene(), 0, 0,
                                       translate("ProgramItem", "Run"), self,
                                       self.item_run_btn_cb)
        self.item_on_success_btn = ButtonItem(self.scene(), 0, 0,
                                              translate("ProgramItem",
                                                        "On S"), self,
                                              self.item_on_success_btn_cb)
        self.item_on_failure_btn = ButtonItem(self.scene(), 0, 0,
                                              translate("ProgramItem",
                                                        "On F"), self,
                                              self.item_on_failure_btn_cb)

        self.item_finished_btn = ButtonItem(
            self.scene(), 0, 0, translate("ProgramItem", "Back to blocks"),
            self, self.item_finished_btn_cb)

        self.items_list = None

        group_visible((self.item_finished_btn, self.item_run_btn,
                       self.item_on_success_btn, self.item_on_failure_btn,
                       self.item_edit_btn), False)

        # readonly (program running) "view"
        self.pr_pause_btn = ButtonItem(self.scene(), 0, 0,
                                       translate("ProgramItem", "Pause"), self,
                                       self.pr_pause_btn_cb)

        if self.stopped:
            self.pr_pause_btn.set_caption(translate("ProgramItem", "Resume"))

        self.pr_cancel_btn = ButtonItem(self.scene(), 0, 0,
                                        translate("ProgramItem", "Stop"), self,
                                        self.pr_cancel_btn_cb)

        group_visible((self.pr_pause_btn, self.pr_cancel_btn), False)

        self.fixed = False

        self.editing_item = False
        self.edit_request = False
        self.run_request = False

        self.setFlag(QtGui.QGraphicsItem.ItemIsMovable, True)
        self.setFlag(QtGui.QGraphicsItem.ItemIsSelectable, True)

        self.setZValue(100)

        self._update_learned()
        self.update()

        if self.item_switched_cb:
            self.item_switched_cb(None, None, blocks=True)