Esempio n. 1
0
    def __init__(self, recipe, loader, app):

        self.state = self.STATE_READY

        self.app = app
        self.recipe = recipe
        self.loader = loader

        _id = self._get_id

        sm = get_scene_manager()
        self.scene_node = sm.createSceneNode()
        self.obtree = None
        self._actions = []

        self._user_navigated = False #: whether user moved around
            # in the viewport
        self._next_view_adjust = 1 #: adjust view (to fit screen)
            # after so many seconds

        # GUI widgets
        p = self.app.frame

        if not getattr(self, 'obtree_widget', None):
            self.obtree_widget = BuildTree(p, -1, (0, 0),
                                    wx.DefaultSize,
                                    wx.TR_DEFAULT_STYLE | wx.NO_BORDER,
                                    on_item_select=self.on_obtree_item_select)
            self.obtree_widget.Hide()

        if not getattr(self, 'xpath_widget', None):
            self.xpath_widget = XpathWidget(p)
            self.xpath_widget.Hide()

        if not getattr(self, 'conf_widget', None):
            self.gen_widget = GeneratorsWidget(p, self)
            self.mod_widget = ModificationsWidget(p, self)

            self.conf_widget = ConfWidget(p, self)
            self.conf_widget.Hide()

        # camera oriented members
        self.center_node = sm.createSceneNode()
        self.camera_node = self.center_node.createChildSceneNode()
        self.camera_node.lookAt((0, 0, 0), ogre.Node.TS_LOCAL)

        camera = sm.createCamera(_id('camera'))
        camera.nearClipDistance = .1
        camera.setAutoAspectRatio(True)
        self.camera_node.attachObject(camera)
        self.camera = camera

        # camera light
        light = sm.createLight('light_%x' % id(self))
        light.setType(ogre.Light.LT_POINT)
        light.setPosition((0, 0, 0))
        light.setSpecularColour((0.9, 0.9, 0.9))
        light.setDiffuseColour((0.7, 0.7, 0.7))
        self.light = light
        self.camera_node.attachObject(light)
        self.light.setVisible(False)

        # 3D navigation oriented members
        self.navigation_mode = self.DEFAULT_NAVIGATION_MODE
        self.move_scale = 0.0
        self.move_speed = 3.0
        self.num_moves = 0
        self.acceleration = 3
        self.last_time = time.time()

        self.x_start = 0
        self.y_start = 0
        self._click = False
        self._ray_scene_query = sm.createRayQuery(ogre.Ray())
        self._selection = set()
        self._sel_xpath = None
        self._sel_geom = None
        self._sel_xpaths = []
Esempio n. 2
0
class Document:
    FLY_MODE = 0
    EXAMINE_MODE = 1
    NAVIGATION_MODES = [FLY_MODE, EXAMINE_MODE]
    DEFAULT_NAVIGATION_MODE = EXAMINE_MODE

    STATE_READY = 0
    STATE_RUNNING = 1
    STATE_PAUSED = 2
    STATE_COMPLETED = 3

    @logmt
    def __init__(self, recipe, loader, app):

        self.state = self.STATE_READY

        self.app = app
        self.recipe = recipe
        self.loader = loader

        _id = self._get_id

        sm = get_scene_manager()
        self.scene_node = sm.createSceneNode()
        self.obtree = None
        self._actions = []

        self._user_navigated = False #: whether user moved around
            # in the viewport
        self._next_view_adjust = 1 #: adjust view (to fit screen)
            # after so many seconds

        # GUI widgets
        p = self.app.frame

        if not getattr(self, 'obtree_widget', None):
            self.obtree_widget = BuildTree(p, -1, (0, 0),
                                    wx.DefaultSize,
                                    wx.TR_DEFAULT_STYLE | wx.NO_BORDER,
                                    on_item_select=self.on_obtree_item_select)
            self.obtree_widget.Hide()

        if not getattr(self, 'xpath_widget', None):
            self.xpath_widget = XpathWidget(p)
            self.xpath_widget.Hide()

        if not getattr(self, 'conf_widget', None):
            self.gen_widget = GeneratorsWidget(p, self)
            self.mod_widget = ModificationsWidget(p, self)

            self.conf_widget = ConfWidget(p, self)
            self.conf_widget.Hide()

        # camera oriented members
        self.center_node = sm.createSceneNode()
        self.camera_node = self.center_node.createChildSceneNode()
        self.camera_node.lookAt((0, 0, 0), ogre.Node.TS_LOCAL)

        camera = sm.createCamera(_id('camera'))
        camera.nearClipDistance = .1
        camera.setAutoAspectRatio(True)
        self.camera_node.attachObject(camera)
        self.camera = camera

        # camera light
        light = sm.createLight('light_%x' % id(self))
        light.setType(ogre.Light.LT_POINT)
        light.setPosition((0, 0, 0))
        light.setSpecularColour((0.9, 0.9, 0.9))
        light.setDiffuseColour((0.7, 0.7, 0.7))
        self.light = light
        self.camera_node.attachObject(light)
        self.light.setVisible(False)

        # 3D navigation oriented members
        self.navigation_mode = self.DEFAULT_NAVIGATION_MODE
        self.move_scale = 0.0
        self.move_speed = 3.0
        self.num_moves = 0
        self.acceleration = 3
        self.last_time = time.time()

        self.x_start = 0
        self.y_start = 0
        self._click = False
        self._ray_scene_query = sm.createRayQuery(ogre.Ray())
        self._selection = set()
        self._sel_xpath = None
        self._sel_geom = None
        self._sel_xpaths = []

    @logmt
    def get_display_name(self):
        name, location, _id, version = self.recipe.generator
        _id = _id.split('.')
        _id = '.'.join(_id[-2:])
        return _id

    @logmt
    def get_properties(self):
        name, location, _id, version = self.recipe.generator

        properties = [
                        ('name', self.get_display_name()),
                        ('generator_id', _id),
                        ('location', location),
                        ('version', version)
                     ]

        return properties

    @logmt
    def on_root_gen_created(self):
        self.obtree_widget.set_build_tree(self.obtree)
        rg = self.obtree.root_gen
        self.conf_widget.update_panes(rg, 'gen', '//%s' % rg.generator.IDENT.id)
    
    @logmt
    def on_root_gen_destroyed(self):
        self.obtree_widget.clear_build_tree()

    def on_time_elapsed(self, time_elapsed):
        self._next_view_adjust -= 1

        if self._next_view_adjust <= 0 and not self._user_navigated:
            self._actions.append(lambda: self._set_view('perspective'))
            self._actions.append(lambda: self._fit_to_view())
            self._next_view_adjust = 10

    @logmt
    def _update_recipe(self, loader=None):
        loader = loader or self.loader

        old_loader = set_loader(self.loader)

        try:
            self.recipe.update()
        finally:
            set_loader(old_loader)

        self.loader = loader

    @logmt
    def run(self):
        if self.state != self.STATE_READY:
            raise PIDEException('not in ready state. please reset')

        self._update_recipe()

        gen_class = self.recipe.make_generator(self.recipe._root_generator)
        self.obtree = BuildTreeOverlay(gen_class, self)
        self.obtree.build()

        self.state = self.STATE_RUNNING

    @logmt
    def pause(self):
        if self.state != self.STATE_RUNNING:
            raise PIDEException('not running')

        self.obtree.pause()
        self.state = self.STATE_PAUSED

    @logmt
    def resume(self):
        if self.state != self.STATE_PAUSED:
            raise PIDEException('not paused')

        self.obtree.resume()
        self.state = self.STATE_RUNNING

    @logmt
    def stop(self):
        if self.state not in (self.STATE_PAUSED,
                              self.STATE_RUNNING):
            return

        self.obtree.stop()
        self.state = self.STATE_COMPLETED

    @logmt
    def rebuild(self, gen_infos, on_first_gen_created=None):

        if self.state == self.STATE_READY:
            raise PIDEException('not in required state. cannot reload')

        if self.state in (self.STATE_PAUSED,
                          self.STATE_RUNNING):
            self.stop()

        self._update_recipe()
        self.state = self.STATE_RUNNING

        self.obtree.rebuild(gen_infos, on_first_gen_created)

    @logmt
    def export_collada(self):
        if self.state == self.STATE_RUNNING:
            self.pause()

        # FIXME: complete this implementation

    @logmt
    def on_build_completed(self):
        self.state = self.STATE_COMPLETED
        self.app.on_document_done(self)

        obt = self.obtree_widget
        if obt:
            obt.Expand(obt.GetRootItem())

        if not self._user_navigated and self._actions is not None:
            self._actions.append(lambda: self._set_view('perspective'))
            self._actions.append(lambda: self._fit_to_view())

    @logmt
    def cleanup(self, preserve_gui_widgets=False):

        if self.state in (self.STATE_RUNNING,
                          self.STATE_PAUSED):
            self.stop()

        sm = get_scene_manager()

        if self.obtree:
            self.obtree.cleanup()
            self.obtree = None
            self.obtree_widget.clear_build_tree()

        parent_node = self.scene_node.getParent()
        if parent_node:
            parent_node.removeChild(self.scene_node)

        sm.destroySceneNode(self.scene_node)

        self.camera_node.detachObject(self.camera)
        sm.destroyCamera(self.camera)
        self.camera_node.detachObject(self.light)
        sm.destroyLight(self.light)

        self.center_node.removeChild(self.camera_node)
        sm.destroySceneNode(self.camera_node)
        sm.destroySceneNode(self.center_node)

        # cleanup GUI widgets!
        if preserve_gui_widgets:
            self.obtree_widget.DeleteAllItems()

        else:
            for widget_name in ('obtree_widget',
                                'xpath_widget', 'conf_widget'):
                widget = getattr(self, widget_name)
                widget.Destroy()
                setattr(self, widget_name, None)

        self._actions = []
        self.state = None

    @logmt
    def reset(self):
        self.cleanup(preserve_gui_widgets=True)
        self.__init__(self.recipe, self.loader, self.app)

    @logmt
    def save(self):
        if not self.recipe.package_dir or not self.recipe.fpath:
            return self.save_as()

        else:
            return self.recipe.save()

    @logmt
    def save_as(self):
        pdir = self.recipe.package_dir
        fpath = self.recipe.fpath

        dlg = SaveAsDialog(self.app.frame, -1)
        dlg.CenterOnParent()
        response = dlg.ShowModal()

        if response == wx.ID_CANCEL:
            return

        pdir = dlg.package_dir.GetValue()
        fpath = dlg.fpath.GetValue()

        self.recipe.save(package_dir=pdir, fpath=fpath)

        _pdir = pdir.rsplit(os.path.sep, 1)[-1]
        _fpath = fpath.rsplit('.')[0]
        self.app.frame.change_tabname(_pdir + '.' + _fpath)

        return pdir, fpath

    @logmt
    def reload(self):
        '''
        Reload code.
        '''
        self._update_recipe(Loader())

    def _get_id(self, name):
        return '%s_%x' % (name, id(self))

    def _camera_lookat(self, point=None):
        if not point:
            bbox = self.obtree.get_bounding_box()
            point = bbox.getCenter()

        if self.navigation_mode == self.EXAMINE_MODE:
            self.camera_node.lookAt(point, ogre.Node.TS_LOCAL)
        else:
            self.camera.lookAt(point)

    def _place_light(self):
        if self.navigation_mode != self.FLY_MODE:
            return

        self.light.setPosition(self.camera.getPosition())

    def _move_camera(self, vector):
        if self.navigation_mode == self.EXAMINE_MODE:
            self.camera_node.translate(vector)

        else:
            self.camera.moveRelative(vector)

        self._place_light()

    @logmt
    def set_navigation_mode(self, mode):
        mode = self.EXAMINE_MODE if mode == 'examine' else self.FLY_MODE
        self._actions.append(lambda: self._set_navigation_mode(mode))

    @logmt
    def toggle_navigation_mode(self):
        mode = self.FLY_MODE if self.navigation_mode == self.EXAMINE_MODE\
                                  else self.EXAMINE_MODE
        self._actions.append(lambda: self._set_navigation_mode(mode))

        return mode

    @logmt
    def _set_navigation_mode(self, mode):
        self._user_navigated = True

        self.center_node.resetOrientation()
        self.camera.setOrientation(ogre.Quaternion())
        self.camera.setPosition((0, 0, 0))
        self.camera_node.detachAllObjects()
        self.camera_node.setPosition((0, 0, 0))
        self.light.setPosition((0, 0, 0))

        if mode == self.EXAMINE_MODE:
            self.camera_node.attachObject(self.camera)
            self.camera_node.attachObject(self.light)

        self.navigation_mode = mode

    @logmt
    def set_view(self, view='perspective', delayed=True):
        self._user_navigated = True

        actions = []

        if view == 'fit':
            actions.append(lambda: self._fit_to_view())
        elif view == 'lookat':
            actions.append(lambda: self._camera_lookat())
        else:
            actions.append(lambda: self._set_view(view))
            actions.append(lambda: self._fit_to_view())

        if delayed:
            self._actions.extend(actions)
        else:
            for a in actions:
                a()

    @logmt
    def get_view(self):
        return self.navigation_mode

    @logmt
    def _set_view(self, view):

        if self.navigation_mode == self.EXAMINE_MODE:
            c = self.center_node
        else:
            c = self.camera

        if view == 'perspective':
            c.setOrientation(ogre.Quaternion(math.pi/4, (-1, 1, 0)))

        elif view == 'top':
            c.setOrientation(ogre.Quaternion(-math.pi/2, (1, 0, 0)))

        elif view == 'bottom':
            c.setOrientation(ogre.Quaternion(math.pi/2, (1, 0, 0)))

        elif view == 'right':
            c.setOrientation(ogre.Quaternion(math.pi/2, (0, 1, 0)))

        elif view == 'left':
            c.setOrientation(ogre.Quaternion(-math.pi/2, (0, 1, 0)))

        elif view == 'back':
            c.setOrientation(ogre.Quaternion(math.pi, (0, 1, 0)))

        else:
            # front is default
            c.setOrientation(ogre.Quaternion())

    @logmt
    def _fit_to_view(self, bbox=None):

        if bbox is None:
            if not self.obtree:
                return
            bbox = self.obtree.get_bounding_box()

        # http://www.ogre3d.org/forums/viewtopic.php?f=5&t=49611
        near_plane = self.camera.getNearClipDistance()
        theta = self.camera.getFOVy() / 2.

        aspect_ratio = self.camera.getAspectRatio()
        if aspect_ratio < 1.0:
            theta *= aspect_ratio

        sv = bbox.getSize()
        size = max(sv.x, sv.y, sv.z)
        theta = theta.valueRadians()
        distance = (size / math.sin(theta)) + near_plane
        distance /= 2.
        distance = distance + distance / 10.

        if self.navigation_mode == self.EXAMINE_MODE:
            self.camera_node.setPosition((0, 0, 0))
            self.center_node.setPosition(bbox.getCenter())
        else:
            self.camera.setPosition(bbox.getCenter())

        self._move_camera((0, 0, distance))
        self._place_light()

    def on_key_down(self, event):
        is_examine_mode = self.navigation_mode == self.EXAMINE_MODE

        k = event.m_keyCode
        t = ogre.Vector3().ZERO

        amount = self.move_scale
        amount = amount + amount * (self.num_moves / self.acceleration)

        if k in (wx.WXK_LEFT, ord('A')):
            if not is_examine_mode:
                t.x = -amount

        elif k in (wx.WXK_RIGHT, ord('D')):
            if not is_examine_mode:
                t.x = amount

        elif k in (wx.WXK_UP, ord('W')):
            t.z =  -amount

        elif k in (wx.WXK_DOWN, ord('S')):
            t.z =  amount

        else:
            return

        self._user_navigated = True

        if event.ShiftDown():
            self.num_moves += 1
        else:
            self.num_moves = 0

        self._move_camera(t)

    @logmt
    def _cast_ray(self, ray):
        '''
        http://www.ogre3d.org/addonforums/viewtopic.php?f=3&t=11621
        '''

        sm = get_scene_manager()

        # variable to hold resulting entity
        closest_entity = None

        # variable to hold point of hit
        closest_result = None

        # create a query object
        ray_query = sm.createRayQuery(ray)
        ray_query.setSortByDistance(True)

        # execute the query, returns a vector of hits
        ray_query.execute(ray_query)
        result = ray_query.getLastResults()

        if len(result) == 0:
            # raycast did not hit an objects bounding box
            return None;

        # at this point we have raycast to a series of different objects
        # bounding boxes. we need to test these different objects to see
        # which is the first polygon hit. there are some minor
        # optimizations (distance based) that mean we wont have to
        # check all of the objects most of the time, but the worst case
        # scenario is that we need to test every triangle of every object.
        closest_dist = -1.0

        for item in result:

            # stop checking if we have found a raycast hit that is closer
            # than all remaining entities
            if closest_dist >= 0.0 and closest_dist < item.distance:
                break

            # only check this result if its a hit against an entity
            if not item.movable:
                continue

            if item.movable.getMovableType() != "Entity":
                continue

            # get the entity to check
            entity = sm.getEntity(item.movable.getName())

            # get the buffers from the mesh
            buffers = self._get_mesh_info(entity.getMesh())
            vertex_buffer = buffers[0]
            index_buffer = buffers[1]

            # get the world position, orientation (as a Matrix) and scale
            position = entity.getParentNode()._getDerivedPosition()
            orientation = entity.getParentNode()._getDerivedOrientation()
            mat_orient = ogre.Matrix3()
            orientation.ToRotationMatrix(mat_orient)
            scale = entity.getParentNode()._getDerivedScale()

            # Now test for hitting individual triangles on the mesh
            new_closest = False

            # get the positions of the vertices from the vertex buffer
            # three vertices each form a triangle
            triangle = []
            i = 1

            for vertex_num in index_buffer:
                start = vertex_num * 8

                pt = ogre.Vector3(vertex_buffer[start],
                                  vertex_buffer[start + 1],
                                  vertex_buffer[start + 2])

                # factor in the world position, orientation and scale
                pt = (mat_orient * (pt * scale)) + position
                triangle.append(pt)

                if i % 3 == 0:
                    # check for a hit against this triangle
                    hit = ogre.Math.intersects(ray,
                            triangle[0], triangle[1], triangle[2],
                            True, False)

                    # if it was a hit check if its the closest
                    if hit.first:
                        if closest_dist < 0.0 or hit.second < closest_dist:
                            # this is the closest so far, save it off
                            closest_dist = hit.second
                            new_closest = True

                    # reset the triangle
                    triangle = []

                i = i + 1

            # if we found a new closest raycast for this object, update the
            # closest_result and closest_entity before moving on to the next
            # object.
            if new_closest:
                closest_entity = entity
                closest_result = ray.getPoint(closest_dist)

        #destroy the query
        sm.destroyQuery(ray_query)

        # return the result
        return [closest_entity, closest_result]

    def _get_mesh_info(self, mesh):
        '''
        http://www.ogre3d.org/addonforums/viewtopic.php?f=3&t=11621
        '''

        added_shared = False

        current_offset = 0
        shared_offset = 0
        next_offset = 0
        index_offset = 0

        vertex_count = 0
        index_count = 0

        # Calculate how many vertices and indices we're going to need
        num_sub_meshes = mesh.getNumSubMeshes()
        for i in range(0, num_sub_meshes):
            submesh = mesh.getSubMesh(i)

            # We only need to add the shared vertices once
            if submesh.useSharedVertices:
                if not added_shared:
                    vertex_count += mesh.sharedVertexData.vertexCount
                    added_shared = True
            else:
                vertex_count += submesh.vertexData.vertexCount

            # Add the indices
            index_count += submesh.indexData.indexCount

        added_shared = False;

        # Run through the submeshes again, adding the data into the arrays
        for i in range(0, num_sub_meshes):
            submesh = mesh.getSubMesh(i)

            vertexData = None
            if submesh.useSharedVertices:
                vertexData =  mesh.sharedVertexData
            else:
                vertexData = submesh.vertexData

            if not submesh.useSharedVertices or\
                (submesh.useSharedVertices and not added_shared):

                if submesh.useSharedVertices:
                    added_shared = True
                    shared_offset = current_offset

                # retrieve index buffer for this submesh
                indexData = submesh.indexData
                ibuf = indexData.indexBuffer
                pointer = ibuf.lock(ogre.HardwareBuffer.HBL_READ_ONLY)
                index_buffer = None

                if bool(ibuf.getType() == ogre.HardwareIndexBuffer.IT_32BIT):
                    index_buffer = ogre.getUint32(pointer, index_count)
                else:
                    index_buffer = ogre.getUint16(pointer, index_count)
                ibuf.unlock()


                # retrieve vertex buffer for this submesh
                posElem = vertexData.vertexDeclaration\
                                .findElementBySemantic(ogre.VES_POSITION)
                vbuf = vertexData.vertexBufferBinding\
                                .getBuffer(posElem.getSource())
                pointer = vbuf.lock(ogre.HardwareBuffer.HBL_READ_ONLY)

                # There are 8 float entries for each vertex in the buffer
                # 3 for position, 3 for normal, 2 for texture coordinate.
                # We only need the position.
                vertex_buffer = ogre.getFloat(pointer, vertex_count * 8)
                vbuf.unlock()

        return [vertex_buffer, index_buffer]

    def _add_to_selection(self, gen_info):
        self._selection.add(gen_info)
        gen_info.highlight()

    def _clear_selection(self):
        for gen_info in self._selection:
            gen_info.unhighlight()

        if self._sel_geom:
            self._sel_geom.unhighlight()
            self._sel_geom = None

        self._selection.clear()

    @logmt
    def _on_manual_selection(self):
        self._sel_xpath = None
        self._sel_xpaths = []

        self._sel_xpaths = self.get_xpath_suggestions()
        if self._sel_xpaths:
            self._sel_xpath = self._sel_xpaths[0]

        self._on_selection_changed('gen')

    @logmt
    def _on_selection_changed(self, sel_type):
        self.update_conf_widget(sel_type)
        self.xpath_widget.update(self._sel_xpaths, self)

    @logmt
    def update_conf_widget(self, sel_type):
        if sel_type == 'geom':
            self.conf_widget.update_panes(self._sel_geom, sel_type,
                                          self._sel_xpath[0])

        elif sel_type == 'class':
            xpath, desc, _class = self._sel_xpath
            self.conf_widget.update_panes(_class, 'class',
                                          self._sel_xpath[0])

        else:
            gen = list(self._selection)[0]
            self.conf_widget.update_panes(gen, sel_type,
                                          self._sel_xpath[0])

    @logmt
    def pick_generator(self, x, y, width, height):
        mouse_ray = self.camera.getCameraToViewportRay(x / float(width),
                                                       y / float(height))

        data = self._cast_ray(mouse_ray)
        if not data:
            return

        entity, point = data
        if not entity:
            return

        gen_info = self.obtree.pick_entity(entity)
        return gen_info

    @logmt
    def select_xpath(self, xpath, description=''):
        self._clear_selection()
        self._sel_xpath = None

        gen_infos = self.query(xpath)
        if not gen_infos:
            return

        for g in gen_infos:
            self._add_to_selection(g)

        g = gen_infos[0]
        self._sel_xpath = (xpath, description, g.generator.__class__)

        sel_type = 'gen' if len(self._selection) == 1 else 'class'

        self.update_conf_widget(sel_type)

    @logmt
    def on_mouse_click(self, event):
        wnd = event.GetEventObject()
        width, height = wnd.GetClientSizeTuple()
        x, y = event.GetPosition()
        gen_info = self.pick_generator(x, y, width, height)

        if not event.ControlDown() or self._sel_geom:
            self._clear_selection()

        if not gen_info:
            return

        self._add_to_selection(gen_info)
#        self._on_manual_selection()

        self.obtree_widget.select_generator(gen_info)

    def on_mouse_event(self, event):
        if self.navigation_mode == self.EXAMINE_MODE:
            c = self.center_node
        else:
            c = self.camera

        rotation = event.GetWheelRotation()
        rotation = rotation * 10 if event.ControlDown() else rotation
        rotation = rotation / 10.0 if event.ShiftDown() else rotation / 100.0
        self._move_camera((0, 0, rotation))

        if event.LeftDown():
            self.x_start, self.y_start = event.GetPosition()
            self._user_navigated = True
            self._click = True

        if event.LeftUp():
            if self._click:
                self._click = False
                self.on_mouse_click(event)

        if event.Dragging() and event.LeftIsDown():
            self._click = False
            x,y = event.GetPosition()
            dx = x - self.x_start
            dy = y - self.y_start
            self.x_start, self.y_start = x, y

            c.yaw(ogre.Degree( -dx / 3.0))
            c.pitch(ogre.Degree( -dy / 3.0))
            self._user_navigated = True

    def on_frame_started(self, event):
        cur_time = time.time()
        t = cur_time - self.last_time
        self.last_time = cur_time

        self.move_scale = self.move_speed * t

        # build tree construction activity
        if self.obtree:
            self.obtree.on_frame_started(event)

        # perform delayed actions
        for index, action in enumerate(self._actions):

            if action is None:
                continue

            try:
                action()
            finally:
                self._actions[index] = None

        while self._actions and self._actions[0] is None:
            self._actions.pop(0)

    def on_frame_ended(self, event):
        if self.obtree:
            self.obtree.on_frame_ended(event)

    def on_obtree_item_select(self, node, node_type):
        if node_type == 'gen':
            self._clear_selection()
            self._add_to_selection(node)
            self._on_manual_selection()

        elif node_type == 'geom':
            self._clear_selection()
            self._sel_geom = node
            node.highlight()
            self._on_selection_changed('geom')

    def _get_class(self, location, _id, version=None):
        old_loader = set_loader(self.loader)

        try:
            _class = get_class(location, _id, version)
        finally:
            set_loader(old_loader)

        return _class

    def get_generators_map(self):
        generators = {}

        for name, location, _id, version in self.recipe.generators:
            _class = self._get_class(location, _id, version)
            generators[_class] = name

        return generators

    @logmt
    def get_xpath_suggestions(self, gen_infos=None):
        gen_infos = gen_infos or self._selection
        names = self.get_generators_map()
        xpaths = self.obtree.suggest_xpaths(gen_infos, names)
        return xpaths

    @logmt
    def query(self, xpaths):
        match_fn = self.recipe.make_matcher(xpaths)
        return self.obtree.query(match_fn)