__doc__ = _("""Provides a tree view for Test Suites """)

datafile = property(lambda self: self.get_selected_datafile())

defaults = {"opened": True,

"docked": True,

"own colors": False

}

show_count = 0

def __init__(self, application):

Plugin.__init__(self, application, default_settings=self.defaults)

# print("DEBUG: treeplugin.py TreePlugin __init__")

self._app = application

self.settings = self._app.settings.config_obj['Plugins']['Tree']

self._parent = None

self._tree = self.tree

"""

self._mgr = aui.GetManager(self._tree)

self.pane_id = self._tree.GetId()

self._model = self.model

self._tree.Bind(wx.EVT_SHOW, self.on_show_tree)

self._tree.Bind(wx.EVT_MOVE, self.on_tab_changed)

# self._tree.Bind(aui.wxEVT_AUI_PANE_CLOSED, self.toggle_view)

# parent, action_registerer, , default_settings={'collapsed':True}

self.opened = self.settings['opened']

self._pane = self._mgr.GetPane(self._tree)

self.font = wx.Font(self._app.fontinfo) # self._tree.GetFont()

self._tree.SetFont(self.font)

self.show_count = 0

# print(f"DEBUG: TreePlugin init self.pane_id={self.pane_id} \n"

# f"self._pane = {self._pane}")

def register_frame(self, parent=None):

if parent:

self._parent = parent

if self._mgr.GetPane("tree_content") in self._mgr._panes:

register = self._mgr.InsertPane

else:

register = self._mgr.AddPane

register(self._tree, wx.lib.agw.aui.AuiPaneInfo().Name("tree_content").

Caption(_('Test Suites')).CloseButton(True).LeftDockable(True))

self._mgr.Update()

def enable(self):

# DEBUG: This does not work (in KDE/Plasma on Fedora 42), the panel has no tree, when we dock from floating

# DEBUG: On other O.S. it may work, so we leave the feature on.

self.register_action(ActionInfo(_('View'), _('View Test Suites Explorer'), self.toggle_view,

shortcut='F12',

doc=_('Show Test Suites tree panel'),

position=2))

self.subscribe(self.on_tree_selection, RideTreeSelection)

self.subscribe(self.reload_tree, RideSettingsChanged)

# self.save_setting('opened', True)

# DEBUG: Add toggle checkbox to menu View/Hide Tree

# On creation always show

self.on_show_tree(None)

"""

"""

def close_tree(self):

self.show_count = 0

self.opened = False

self._mgr = aui.GetManager(self._app.frame)

# print(f"DEBUG: TreePlugin ENTER close_tree self._mgr={self._mgr} _tree={self._tree} == frame {self.frame.tree}")

if not self._mgr:

return

# self._mgr = self.app.frame.aui_mgr

if not self._tree:

self._tree = self.frame.tree

# print(f"DEBUG: TreePlugin ENTER close_tree _tree={self._tree}")

# self._mgr.DetachPane(self.file_explorer) DestroyOnClose()

pane_info = self._mgr.GetPane("tree_content")

if pane_info.IsOk():

if pane_info.IsFloating():

pane_info.DestroyOnClose(False)

# self._mgr.DetachPane(self._tree)

pane_info.Float().Hide()

self.set_float_docked(False)

# print(f"DEBUG: TreePlugin in branch FLOAT close_tree pane_info={pane_info}")

else:

# self._mgr.GetPane.ClosePane(

pane_info.Dock().Hide()

self.set_float_docked(True)

# print(f"DEBUG: TreePlugin in branch DOCK close_tree pane_info={pane_info}")

# perspective = self._mgr.SavePaneInfo(pane_info)

# print(f"DEBUG: TreePlugin call close_tree perspective={perspective}")

# self.save_setting('perspective', perspective)

self.save_setting('opened', False)

self._mgr.Update()

def disable(self):

self.close_tree()

# self.save_setting('opened', False)

self.unregister_actions()

self.unsubscribe_all()

def is_focused(self):

return self._tree.HasFocus()

def populate(self, model):

if model: # DEBUG: Always populate ... and model != self._model:

self._model = model

# print(f"DEBUG: Populating model... {self._model}\n\n")

self._tree.populate(self._model)

def set_editor(self, editor):

self._tree.set_editor(editor)

def reload_tree(self, message):

if message.keys[0] != "General":

return

try:

if message.keys[1] == "reload":

# reload style

wx.CallLater(50000, self.on_show_tree, None)

# print("DEBUG: treeplugin.py TreePlugin reload_tree RELOADED TREE")

except IndexError:

pass

def toggle_view(self, event):

if event is None:

# print(f"DEBUG: TreePlugin ENTER toggle_view {event=} is NONE tree is {self.opened}")

return

# print(f"DEBUG: TreePlugin ENTER toggle_view {event=} in not None tree is {self.opened}")

self.save_setting('opened', not self.opened)

if not self.opened:

self.show_count = 0

self.opened = True

self.on_show_tree(None)

else:

self.close_tree()

def on_show_tree(self, event):

# print(f"DEBUG: TreePlugin on_show_tree ENTER {event=}"

# f" COUNTER={self.show_count} event. == tree? {self._tree}")

self.show_count += 1

if self.show_count >= 2:

# print(f"DEBUG: TreePlugin on_show_tree COUNTER={self.show_count} >=2 returning")

self.show_count = 0

return

__ = event

if not self._parent:

self._parent = self.frame

if not self._tree: # This is not needed because tree is always created

self._tree = Tree(self._parent, self._parent.actions, self._app.settings)

# print(f"DEBUG: TreePlugin on_show_tree # On Windows this code is executed when closing the app, we DON'T "

# f"return now")

# return # On Windows this code is executed when closing the app, we return now

# print(f"DEBUG: TreePlugin on_show_tree {self._tree}")

global_settings = self._app.settings.config_obj['General']

apply_global = global_settings['apply to panels']

use_own = self.settings['own colors']

if apply_global or not use_own:

html_background = self.settings.get('background help', (240, 242, 80))

html_foreground = self.settings.get('foreground text', (7, 0, 70))

else:

html_background = self.settings.get('background', (240, 242, 80))

html_foreground = self.settings.get('foreground', (7, 0, 70))

html_font_face = self.settings.get('font face', '')

html_font_size = self.settings.get('font size', 11)

self._tree.Show(True)

# print(f"DEBUG: treeplugin on_show_tree {html_font_face=} {html_font_size=}")

self._tree.SetMinSize(wx.Size(200, 225))

# self.aui_mgr.DetachPane(self._tree)

# self.aui_mgr.Update()

# DEBUG: Let's use own method

# self.aui_mgr.AddPane(self._tree,

# wx.lib.agw.aui.AuiPaneInfo().Name("tree_content").

# Caption("Test Suites").LeftDockable(True).

# CloseButton(True))

# self.register_frame(self._parent)

self._tree.SetBackgroundStyle(wx.BG_STYLE_SYSTEM)

self._tree.SetBackgroundColour(html_background)

self._tree.SetForegroundColour(html_foreground)

# self.font = self._tree.GetFont()

self._tree.SetFont(self.font)

if html_font_face is not None:

self.font.SetFaceName(html_font_face)

self.font.SetPointSize(html_font_size)

self._tree.SetFont(self.font)

self._tree.Refresh()

self._tree.Raise()

self.save_setting('opened', True)

self._mgr.Update()

self._tree.populate(self._model)

self._update_tree()

def set_float_docked(self, state: bool):

self.save_setting('docked', state) # Docked == True

def on_tree_selection(self, message):

if self.is_focused():

self._tree.tree_node_selected(message.item)

def on_tab_changed(self, event):

__ = event

self._update_tree()

def _update_tree(self, event=None):

__ = event

# print(f"DEBUG: treeplugin.py TreePlugin _update_tree called model={self._model}")

self._tree.populate(self._model)

self._tree.refresh_view()

def __init__(self, parent, action_registerer, settings=None):

from ..controller.ui.treecontroller import TreeController

self._RESOURCES_NODE_LABEL = _('External Resources')

# print(f"DEBUG: treeplugin.py Tree after importing TreeController __init__ "

# f"translated label={self._RESOURCES_NODE_LABEL}")

self.theme = settings.get_without_default('General')

self.background = self.theme['background']

self.foreground = self.theme['foreground']

self._checkboxes_for_tests = False

self._test_selection_controller = self._create_test_selection_controller()

self.controller = TreeController(self, action_registerer, settings=settings,

test_selection=self._test_selection_controller)

treemixin.DragAndDrop.__init__(self, parent, **_TREE_ARGS)

self.controller.register_tree_actions()

self._bind_tree_events()

self._images = TreeImageList()

self._animctrl = None

self._silent_mode = False

self.SetImageList(self._images)

self.label_editor = TreeLabelEditListener(self, action_registerer)

self.controller.bind_keys()

self._subscribe_to_messages()

self._popup_creator = PopupCreator()

self._dragging = False

self._clear_tree_data()

self._editor = None

self._execution_results = None

self._resources = set()

self._right_click = False

self.dirty = False

# DEBUG: This menu is not working because is being attached to main frame

# self._menu = wx.Menu()

# self._menu.Append(wx.ID_CLOSE, item="&Close", helpString="Closes panel")

# self._mb = wx.MenuBar()

# self._mb.Append(self._menu, "Menu")

# self.GetParent().SetMenuBar(self._mb)

# print(f"DEBUG: Tree tried to add menu to {self.GetParent().__repr__()} parent={parent}")

self.pane_id = self.GetId()

if not hasattr(self, 'OnCancelEdit'):

self.OnCancelEdit = self._on_cancel_edit

@staticmethod

def _create_test_selection_controller():

from ..controller.ui.treecontroller import TestSelectionController

tsc = TestSelectionController()

PUBLISHER.subscribe(tsc.clear_all, RideOpenSuite)

PUBLISHER.subscribe(tsc.clear_all, RideNewProject)

return tsc

def _on_cancel_edit(self, item):

le = customtreectrl.TreeEvent(

customtreectrl.wxEVT_TREE_END_LABEL_EDIT, self.GetId())

le._item = item

le.SetEventObject(self)

le._label = ""

le._editCancelled = True

self.GetEventHandler().ProcessEvent(le)

def _bind_tree_events(self):

self.Bind(wx.EVT_LEFT_DCLICK, self.on_double_click)

self.Bind(wx.EVT_TREE_SEL_CHANGED, self.on_sel_changed)

self.Bind(wx.EVT_TREE_ITEM_EXPANDING, self.on_tree_item_expanding)

self.Bind(wx.EVT_RIGHT_DOWN, self.on_right_click)

self.Bind(wx.EVT_TREE_SEL_CHANGING, self.on_selection)

# self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.OnRightClick)

self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.on_item_activated)

self.Bind(customtreectrl.EVT_TREE_ITEM_CHECKED, self.on_tree_item_checked)

self.Bind(wx.EVT_TREE_ITEM_COLLAPSING, self.on_tree_item_collapsing)

self.Bind(wx.EVT_CLOSE, self.on_close)

def on_selection(self, event):

if self._right_click:

event.Skip()

def on_double_click(self, event):

item, _ = self.HitTest(self.ScreenToClient(wx.GetMousePosition()))

if item:

handler = self.controller.get_handler(item)

handler.double_clicked()

event.Skip()

def set_editor(self, editor):

self._editor = editor

def StartDragging(self): # Overrides wx method

self._dragging = True

treemixin.DragAndDrop.StartDragging(self)

def OnEndDrag(self, event): # Overrides wx method

self._dragging = False

treemixin.DragAndDrop.OnEndDrag(self, event)

def register_context_menu_hook(self, callable_m):

self._popup_creator.add_hook(callable_m)

def unregister_context_menu_hook(self, callable_m):

self._popup_creator.remove_hook(callable_m)

def _subscribe_to_messages(self):

subscriptions = [

(self._item_renamed, RideItemNameChanged),

(self._item_changed, RideItem),

(self._resource_added, RideOpenResource),

(self._select_resource, RideSelectResource),

(self._suite_added, RideSuiteAdded),

(self._keyword_added, RideUserKeywordAdded),

(self._test_added, RideTestCaseAdded),

(self._variable_added, RideVariableAdded),

(self._leaf_item_removed, RideUserKeywordRemoved),

(self._leaf_item_removed, RideTestCaseRemoved),

(self._leaf_item_removed, RideVariableRemoved),

(self._datafile_removed, RideDataFileRemoved),

(self._datafile_set, RideDataFileSet),

(self._data_dirty, RideDataChangedToDirty),

(self._data_undirty, RideDataDirtyCleared),

(self._variable_moved_up, RideVariableMovedUp),

(self._variable_moved_down, RideVariableMovedDown),

(self._variable_updated, RideVariableUpdated),

(self._filename_changed, RideFileNameChanged),

(self._testing_started, RideTestExecutionStarted),

(self._test_result, RideTestRunning),

(self._test_result, RideTestPaused),

(self._test_result, RideTestPassed),

(self._test_result, RideTestFailed),

(self._test_result, RideTestSkipped),

(self._test_result, RideTestStopped),

(self._handle_import_setting_message, RideImportSetting),

(self._mark_excludes, RideExcludesChanged),

(self._mark_excludes, RideIncludesChanged),

]

for listener, topic in subscriptions:

PUBLISHER.subscribe(listener, topic)

def _mark_excludes(self, message):

tree = self.controller.find_node_by_controller(message.old_controller)

self._render_datafile(self.GetItemParent(tree), message.new_controller)

self._remove_datafile_node(tree)

def _set_item_excluded(self, node):

self.SetItemTextColour(node, wx.TheColourDatabase.Find(colourName="GREY"))

self.SetItemItalic(node, True)

self.SetItemText(node, _("%s (excluded)") % self.GetItemText(node))

def _handle_import_setting_message(self, message):

if message.is_resource():

self._set_resource_color(

message.import_controller.get_imported_controller())

self._set_resource_color(

message.import_controller.get_previous_imported_controller())

def _set_resource_color(self, resource_controller):

if not resource_controller:

return

node = self.controller.find_node_by_controller(resource_controller)

if node:

self.SetItemTextColour(

node, self._get_resource_text_color(resource_controller))

def _get_resource_text_color(self, resource_controller):

if resource_controller.is_used():

return self.GetDefaultAttributes().colFg

else:

return wx.LIGHT_GREY

def _testing_started(self, message):

self._for_all_drawn_tests(

self.root, lambda t: self.SetItemImage(t, ROBOT_IMAGE_INDEX))

self._execution_results = message.results

self._images.set_execution_results(message.results)

def _test_result(self, message):

from ..controller.macrocontrollers import TestCaseController

test: TestCaseController = message.item

if not test:

# test object will be None when running with DataDriver

# when runner is interrupted, is also None, so let's stop animation

if self._animctrl:

self._animctrl.Stop()

self._animctrl.Animation.Destroy()

self._animctrl.Destroy()

self._animctrl = None

return

if isinstance(message, RideTestPassed):

test.run_passed = True

elif isinstance(message, RideTestFailed):

test.run_passed = False

elif isinstance(message, RideTestSkipped):

test.run_passed = False

else:

test.run_passed = None

wx.CallAfter(self._set_icon_from_execution_results, message.item)

def _set_icon_from_execution_results(self, controller):

node = self.controller.find_node_by_controller(controller)

if not node:

return

img_index = self._get_icon_index_for(controller)

# Always set the static icon

self.SetItemImage(node, img_index)

if self._animctrl:

self._animctrl.Stop()

self._animctrl.Animation.Destroy()

self._animctrl.Destroy()

self._animctrl = None

self.DeleteItemWindow(node)

if img_index in (RUNNING_IMAGE_INDEX, PAUSED_IMAGE_INDEX):

from wx.adv import Animation, AnimationCtrl

import os

_BASE = os.path.join(os.path.dirname(__file__), '..', 'widgets')

if img_index == RUNNING_IMAGE_INDEX:

img = os.path.join(_BASE, 'robot-running.gif')

else:

img = os.path.join(_BASE, 'robot-pause.gif')

ani = Animation(img)

obj = self

rect = Point(node.GetX()+20, node.GetY()) # Overlaps robot icon

try:

self._animctrl = AnimationCtrl(obj, -1, ani, rect)

self._animctrl.SetBackgroundColour('white')

self.SetItemWindow(node, self._animctrl, False)

self._animctrl.Play()

except AttributeError: # In fast executions the element self._animctrl.Play() does not exists

pass

# Make visible the running or paused test

parent = node.GetParent()

self.EnsureVisible(parent) # DEBUG add animation to parent if suite setup/teardown started

self.ExpandAllChildren(parent)

self.EnsureVisible(node)

self.ExpandAllChildren(node)

self.Update()

def _get_icon_index_for(self, controller):

if not self._execution_results:

return ROBOT_IMAGE_INDEX

if self._execution_results.is_paused(controller):

return PAUSED_IMAGE_INDEX

if self._execution_results.is_running(controller):

return RUNNING_IMAGE_INDEX

if self._execution_results.has_passed(controller):

return PASSED_IMAGE_INDEX

if self._execution_results.has_failed(controller):

return FAILED_IMAGE_INDEX

if self._execution_results.has_skipped(controller):

return SKIPPED_IMAGE_INDEX

return ROBOT_IMAGE_INDEX

def populate(self, model):

self._clear_tree_data()

self._populate_model(model)

self.refresh_view()

self.SetFocus() # Needed for keyboard shortcuts

def _clear_tree_data(self):

self.DeleteAllItems()

self.root = self.AddRoot('')

self._resource_root = self._create_resource_root()

self.datafile_nodes = []

self._resources = set()

self.controller.clear_history()

def _create_resource_root(self):

return self._create_node(self.root, self._RESOURCES_NODE_LABEL,

self._images.directory)

def _populate_model(self, model):

handler = ResourceRootHandler(model, self, self._resource_root,

self.controller.settings)

# print(f"DEBUG: _populate_model model={model} self._resource_root={self._resource_root}"

# f" self._controller.settings={self._controller.settings}")

self.SetPyData(self._resource_root, handler)

if model.data:

self._render_datafile(self.root, model.data, 0)

for res in model.external_resources:

if not res.parent:

self._render_datafile(self._resource_root, res)

def _resource_added(self, message):

ctrl = message.datafile

if self.controller.find_node_by_controller(ctrl):

return

if ctrl.parent:

parent = self._get_dir_node(ctrl.parent)

else:

parent = self._resource_root

self._render_datafile(parent, ctrl)

def _get_dir_node(self, ctrl):

if ctrl is None:

return self.root

dir_node = self._get_datafile_node(ctrl.data)

if dir_node is None:

parent = self._get_dir_node(ctrl.parent)

self._render_datafile(parent, ctrl)

dir_node = self._get_datafile_node(ctrl.data)

return dir_node

def _select_resource(self, message):

self.select_controller_node(message.item)

def select_controller_node(self, controller):

self.SelectItem(self.controller.find_node_by_controller(controller))

def _suite_added(self, message):

self.add_datafile(message.parent, message.suite)

def refresh_view(self):

self.Show()

self.Refresh()

# print(f"DEBUG: Called Tree._refresh_view {self.GetParent().GetClassName()}")

if self._resource_root:

self.Expand(self._resource_root)

if self.datafile_nodes:

self._expand_and_render_children(self.datafile_nodes[0])

wx.CallAfter(self.SelectItem, self.datafile_nodes[0])

self.Update()

# print(f"DEBUG: Called Tree._refresh_view parent={self.GetParent().GetClassName()} self={self}")

def _render_datafile(self, parent_node, controller, index=None):

node = self._create_node_with_handler(parent_node, controller, index)

if not node:

return None

# avoid repeated resources

if hasattr(controller, 'source') and os.path.isfile(self._normalize(controller.source)):

if not self._normalize(controller.source) in self._resources:

self._resources.add(self._normalize(controller.source))

if controller.dirty:

self.controller.mark_node_dirty(node)

self.datafile_nodes.append(node)

self.SetItemHasChildren(node, True)

for child in controller.children:

if not self._normalize(child.source) in self._resources:

self._render_datafile(node, child)

return node

@staticmethod

def _normalize(path):

return os.path.normcase(os.path.normpath(os.path.abspath(path)))

def _create_node_with_handler(self, parent_node, controller, index=None):

from ..controller.filecontrollers import ResourceFileController

if (controller.display_name.startswith("#") or

controller.display_name.startswith("...")): # If it is a comment or continuation marker don't create

return None

handler_class = action_handler_class(controller)

with_checkbox = (handler_class == TestCaseHandler and self._checkboxes_for_tests)

node = self._create_node(parent_node, controller.display_name, self._images[controller],

index, with_checkbox=with_checkbox)

if isinstance(controller, ResourceFileController) and not controller.is_used():

self.SetItemTextColour(node, TREETEXTCOLOUR) # wxPython3 hack

action_handler = handler_class(controller, self, node, self.controller.settings)

self.SetPyData(node, action_handler)

# if we have a TestCase node we have to make sure that

# we retain the checked state

if (handler_class == TestCaseHandler and self._checkboxes_for_tests) \

and self._test_selection_controller.is_test_selected(controller):

self.CheckItem(node, True)

if controller.is_excluded():

self._set_item_excluded(node)

return node

def set_checkboxes_for_tests(self):

self._checkboxes_for_tests = True

def _expand_and_render_children(self, node):

assert node is not None

self._render_children(node)

self.Expand(node)

def _render_children(self, node):

handler = self.controller.get_handler(node)

if not handler or not handler.can_be_rendered:

return

self._create_child_nodes(

node, handler, lambda item: item.is_test_suite)

handler.set_rendered()

def _create_child_nodes(self, node, handler, predicate):

for childitem in self._children_of(handler):

index = self._get_insertion_index(node, predicate)

self._create_node_with_handler(node, childitem, index)

@staticmethod

def _children_of(handler):

return [v for v in handler.variables if v.has_data()] + list(handler.tests) + list(handler.keywords)

def _create_node(self, parent_node, label, img, index=None, with_checkbox=False):

node = self._wx_node(parent_node, index, label, with_checkbox)

self.SetItemImage(node, img.normal, wx.TreeItemIcon_Normal)

self.SetItemImage(node, img.expanded, wx.TreeItemIcon_Expanded)

return node

def _wx_node(self, parent_node, index, label, with_checkbox):

ct_type = 1 if with_checkbox else 0

if index is not None:

# blame wxPython for this ugliness

if isinstance(index, int):

return self.InsertItemByIndex(

parent_node, index, label, ct_type=ct_type)

else:

return self.InsertItem(

parent_node, index, label, ct_type=ct_type)

return self.AppendItem(parent_node, label, ct_type=ct_type)

def add_datafile(self, parent, suite):

snode = self._render_datafile(

self._get_datafile_node(parent.data), suite)

self.SelectItem(snode)

def add_test(self, parent_node, test):

self._add_dataitem(

parent_node, test, lambda item: item.is_user_keyword)

def add_keyword(self, parent_node, kw):

self._add_dataitem(parent_node, kw, lambda item: item.is_test_suite)

def _add_dataitem(self, parent_node, dataitem, predicate):

node = self._get_or_create_node(parent_node, dataitem, predicate)

self._select(node)

self.controller.mark_node_dirty(parent_node)

def _get_or_create_node(self, parent_node, dataitem, predicate):

if not self.IsExpanded(parent_node):

self._expand_and_render_children(parent_node)

return self.controller.find_node_with_label(

parent_node, dataitem.display_name)

index = self._get_insertion_index(parent_node, predicate)

return self._create_node_with_handler(parent_node, dataitem, index)

def _select(self, node):

if node:

wx.CallAfter(self.SelectItem, node)

def _get_insertion_index(self, parent_node, predicate):

if not predicate:

return None

item, cookie = self.GetFirstChild(parent_node)

while item:

if predicate(self.controller.get_handler(item)):

index = self.GetPrevSibling(item)

if not index:

index = 0

return index

item, cookie = self.GetNextChild(parent_node, cookie)

return None

def _keyword_added(self, message):

self.add_keyword(self._get_datafile_node(self.get_selected_datafile()),

message.item)

def _variable_added(self, message):

self._get_or_create_node(

self._get_datafile_node(self.get_selected_datafile()),

message.item,

lambda item: not item.is_variable or item.index > message.index)

def _leaf_item_removed(self, message):

node = self.controller.find_node_by_controller(message.item)

parent_node = self._get_datafile_node(message.datafile)

# DEBUG The below call causes not calling delete_node

# self._test_selection_controller.select(message.item, False)

self.controller.mark_node_dirty(parent_node)

self.delete_node(node)

def _test_added(self, message):

self.add_test(self._get_datafile_node(self.get_selected_datafile()),

message.item)

def _datafile_removed(self, message):

dfnode = self._get_datafile_node(message.datafile.data)

self.datafile_nodes.remove(dfnode)

self.DeleteChildren(dfnode)

self.Delete(dfnode)

def _datafile_set(self, message):

wx.CallAfter(self._refresh_datafile_when_file_set, message.item)

def _filename_changed(self, message):

from ..controller import ResourceFileController

df = message.datafile

node = self.controller.find_node_by_controller(df)

if not node:

raise AssertionError('No node found with controller "%s"' % df)

old_name = node.GetText()

# print(f"DEBUG: treeplugin.py Tree _filename_changed message={message} df={df}"

# f" node={node} {old_name=} df.display_name={df.display_name}")

wx.CallAfter(self.SetItemText, node, df.display_name)

if isinstance(df, ResourceFileController):

RideItemNameChanged(item=node, old_name=old_name, new_name=df.display_name).publish()

def add_keyword_controller(self, controller):

parent = self._get_datafile_node(self.get_selected_datafile())

self.add_keyword(parent, controller)

def delete_node(self, node):

if node is None:

return

parent = self.GetItemParent(node)

self.controller.mark_node_dirty(parent)

self.Delete(node)

wx.CallAfter(self.SelectItem, parent)

def _data_dirty(self, message):

# print("DEBUG: TreePlugin tree _data_dirty ENTER")

if not self.dirty:

self.dirty = True

self.controller.mark_controller_dirty(message.datafile)

def _data_undirty(self, message):

_ = message

# print("DEBUG: TreePlugin tree _data_undirty")

self.unset_dirty()

def unset_dirty(self):

for node in self.datafile_nodes:

text = self.GetItemText(node)

handler = self.controller.get_handler(node)

if text.startswith('*') and not handler.controller.dirty:

self.SetItemText(node, text[1:])

self.dirty = False

def select_node_by_data(self, controller):

"""Find and select the tree item associated with the given controller.

parent_node = self._get_datafile_node(controller.datafile)

# print(f"DEBUG: treeplugin.py Tree select_node_by_data parent_node={parent_node}")

if not parent_node:

return None

# if not self.IsExpanded(parent_node):

self.EnsureVisible(parent_node)

self._expand_and_render_children(parent_node)

node = self.controller.find_node_by_controller(controller)

if node and node != self.GetSelection():

self.SelectItem(node)

return node

def select_user_keyword_node(self, uk):

parent_node = self._get_datafile_node(uk.parent.parent)

if not parent_node:

return

self.EnsureVisible(parent_node)

if not self.IsExpanded(parent_node):

self._expand_and_render_children(parent_node)

node = self.controller.find_node_with_label(parent_node, utils.normalize(uk.name))

# print(f"DEBUG: treeplugin.py Tree select_user_keyword_node node= {node}")

if node != self.GetSelection():

self.SelectItem(node)

def _get_datafile_node(self, datafile):

# print(f"DEBUG: treeplugin.py Tree _get_datafile_node ENTER dataffile= {datafile}")

for node in self.datafile_nodes:

item = self.controller.get_handler(node).item

if item == datafile: # This only works before editing a resource item because the obj id changes

return node

if type(item) == type(datafile) and hasattr(item, 'name') and item.name == datafile.name:

return node

return None

def get_selected_datafile(self):

"""Returns currently selected data file.

datafile = self._get_selected_datafile_node()

if not datafile:

return None

return self.controller.get_handler(datafile).item

def get_selected_datafile_controller(self):

"""Returns controller associated with currently active data file.

dfnode = self._get_selected_datafile_node()

if dfnode:

return self.controller.get_handler(dfnode).controller

else:

return None

def _get_selected_datafile_node(self):

node = self.GetSelection()

if not node or node in (self._resource_root, self.root):

return None

while node not in self.datafile_nodes:

node = self.GetItemParent(node)

return node

def get_selected_item(self):

"""Returns model object associated with currently selected tree node.

selection = self.GetSelection()

if not selection:

return None

handler = self.controller.get_handler(selection)

return handler and handler.controller or None

def tree_node_selected(self, node):

# print(f"DEBUG: TreePlugin tree node selected {str(node)}")

pass

def move_up(self, node):

prev = self.GetPrevSibling(node)

if prev.IsOk():

self._switch_items(prev, node, node)

def move_down(self, node):

_next = self.GetNextSibling(node)

if _next.IsOk():

self._switch_items(node, _next, node)

def _switch_items(self, first, second, currently_selected):

"""Changes the order of given items, first is expected to be directly

selection = self.GetItemData(currently_selected).controller

controller = self.controller.get_handler(first).controller

self.Delete(first)

self._create_node_with_handler(self.GetItemParent(second), controller, second)

self.select_node_by_data(selection)

def _refresh_datafile_when_file_set(self, controller):

# remove invalid cases selection when data file is changed in text editor

self._test_selection_controller.remove_invalid_cases_selection(controller)

# Prevent tab selections based on tree item selected events

self._start_silent_mode()

current = self.get_selected_datafile_controller()

if not current: # If tree is not yet in use - do not expand anything.

self._end_silent_mode()

return

item = self.GetSelection()

current_txt = self.GetItemText(item) if item.IsOk() else ''

# after refresh current and current_txt might have been changed

node = self._refresh_datafile(controller)

if node is None:

# DEBUG: Find out why this sometimes happens

return

self._expand_and_render_children(node)

if current == controller:

select_item = self.controller.find_node_with_label(

node, current_txt)

if select_item is None:

select_item = node

wx.CallAfter(self.SelectItem, select_item)

wx.CallAfter(self._end_silent_mode)

else:

self._end_silent_mode()

def _uncheck_tests(self, controller):

self._test_selection_controller.unselect_all(controller.tests)

def _start_silent_mode(self):

self._silent_mode = True

def _end_silent_mode(self):

self._silent_mode = False

def refresh_datafile(self, controller, event):

to_be_selected = self._get_pending_selection(event)

new_node = self._refresh_datafile(controller)

self._handle_pending_selection(to_be_selected, new_node)

def _refresh_datafile(self, controller):

orig_node = self._get_data_controller_node(controller)

if orig_node is not None:

insertion_index = self._get_datafile_index(orig_node)

parent = self.GetItemParent(orig_node)

self._remove_datafile_node(orig_node)

return self._render_datafile(parent, controller, insertion_index)

def _get_pending_selection(self, event):

if hasattr(event, 'Item'):

item = event.GetItem()

event.Veto()

elif hasattr(event, 'Position'):

item, flags = self.HitTest(event.Position)

if not self._click_on_item(item, flags):

return

else:

return

return self.GetItemText(item)

def _get_data_controller_node(self, controller):

for node in self.datafile_nodes:

if self.GetItemData(node).controller == controller:

return node

return None

@staticmethod

def _click_on_item(item, flags):

return item is not None and item.IsOk() and flags & wx.TREE_HITTEST_ONITEM

def _get_datafile_index(self, node):

insertion_index = self.GetPrevSibling(node)

if not insertion_index:

insertion_index = 0

return insertion_index

def _remove_datafile_node(self, node):

for child in self.GetItemChildren(node):

if child in self.datafile_nodes:

self._remove_datafile_node(child)

self.datafile_nodes.remove(node)

self.Delete(node)

def _handle_pending_selection(self, to_be_selected, parent_node):

if to_be_selected: