def remove(self, treeview_item: TreeViewItem = None):
'''
Removes the given treeview_item and all its children from the TreeViewControl.
If treeview_item == None, then the whole TreeViewControl will be cleared.
:param treeview_item: TreeViewItem to be deleted form tree.
'''
log_enter_func('TreeViewControl', 'remove',
{'treeview_item': treeview_item})
if treeview_item == None:
# Clear the whole tree
self.__treeview.delete(*self.__treeview_id_dict.keys())
self.__added_treeview_items.clear()
self.__treeview_id_dict.clear()
self.__parentless_items.clear()
else:
#Remove the given item and its children from the tree.
for child in self.__find_children(treeview_item.parent_id):
self.remove(child)
treeview_id = self.__get_treeview_id(treeview_item.id)
self.__treeview.delete(treeview_id)
self.__added_treeview_items.remove(treeview_item)
del self.__treeview_id_dict[treeview_id]
self.__parentless_items.remove(treeview_item)
log_leave_func('TreeViewControl', 'remove')
def __init__(self, master: tk.Frame):
'''
Constructor
'''
log_enter_func('OverviewControl', '__init__', {'master': master})
self.__overview = Treeview(master=master, selectmode='browse')
self.__overview.heading('#0', text='Overview', anchor=tk.W)
self.__overview.pack(fill=tk.Y, side=tk.LEFT)
self.__overview.bind('<<TreeviewSelect>>', self.__notifiy_observer)
self.__overview.insert('', 0, self.__root_id, text='Pages')
self.__overview.item(self.__root_id, open=True)
self.__overview.insert('', 1, 'css_rules', text='CSS Rules')
self.__overview.item('css_rules', open=True)
self.__overview.insert('', 2, 'javascripts', text='JavaScripts')
self.__overview.item('javascripts', open=True)
self.__overview.insert('', 3, 'text', text='Text')
self.__overview.item('text', open=True)
self.__overview.insert('', 4, 'variables', text='Variables')
self.__overview.item('variables', open=True)
log_leave_func('OverviewControl', '__init__')
def on_new(self, event:Event) -> None:
'''
'''
log_enter_func('MainWindowCNTLR', 'on_new', {'event':event})
log_set_var('MainWindowCNTLR', 'on_new', 'event.event_source', event.event_source)
if event.event_source == MainWindowMenuKeys.KEY_PROJECT:
if self.__model.is_project_open() \
and not self.__check_and_save_changes():
# user has cancelled the process
return
self.__model.create_new_project()
elif event.event_source == MainWindowMenuKeys.KEY_HTML_PAGE:
self.__model.create_page()
self.__load_data_in_view()
elif event.event_source == MainWindowMenuKeys.KEY_CSS_RULE:
self.__model.create_css_rule()
self.__load_data_in_view()
elif event.event_source == MainWindowMenuKeys.KEY_JAVASCRIPT:
self.__model.create_javascript()
self.__load_data_in_view()
elif event.event_source == MainWindowMenuKeys.KEY_TEXT:
self.__model.create_text()
self.__load_data_in_view()
elif event.event_source == MainWindowMenuKeys.KEY_VARIABLE:
self.__model.create_variable()
self.__load_data_in_view()
log_leave_func('MainWindowCNTLR', 'on_new')
def __validate_input(self):
'''
Set the treview_state to TreeViewState.OK.
Checks if the parent id of the __current_treeview_item is set and if so it searches
for the parent in the __added_treeview_items array. If it finds the item the treeview_state remains unchanged.
If the parent couldn't be found the treeview_state will be changed to TreeViewState.PARENT_NOT_EXISTS.
If the parent id of the __current_treeview_item is not set the __treeview_state is set to TreeViewState.NO_PARENT.
'''
log_enter_func('TreeViewControl', '__validate_input')
self.__treeview_state = TreeViewState.OK
if not self.__current_treeview_item.parent_id == None:
parent_item = self.__search_parent()
if parent_item == None:
self.__treeview_state = TreeViewState.PARENT_NOT_EXISTS
else:
self.__treeview_state = TreeViewState.NO_PARENT
log_set_var('TreeViewControl', '__validate_input', '__treeview_state',
self.__treeview_state)
log_leave_func('TreeViewControl', '__validate_input')
def __on_collection_select(self, event): # @UnusedVariable
'''
'''
log_enter_func('SelectText', '__on_collection_select',
{'event': event})
self.__selected_txt_item_var.set('')
selected_collection = self.__selected_txt_coll_var.get()
log_set_var('SelectText', '__on_collection_select',
'selected_collection', selected_collection)
self.__text_items_opm['menu'].delete(0, 'end')
for _tuple in self.__text_elements:
if _tuple[0] == selected_collection:
log_set_var('SelectText', '__on_collection_select',
'adding _tuple', _tuple)
self.__text_items_opm['menu'].add_command(
label=_tuple[1],
command=tk._setit(self.__selected_txt_item_var, _tuple[1]))
log_leave_func('SelectText', '__on_collection_select')
def __init__(self,
text_elements,
observer: ABSTextDialogObserver,
master=None):
'''
Constructor
'''
log_enter_func('SelectText', '__init__', {
'text_elements': text_elements,
'observer': observer,
'master': master
})
self.__text_elements = text_elements
self.__observer = observer
self.__selected_txt_coll_var = tk.StringVar()
self.__selected_txt_item_var = tk.StringVar()
self.__text_collections = []
for _tuple in self.__text_elements:
if not _tuple[0] in self.__text_collections:
self.__text_collections.append(_tuple[0])
log_set_var('SelectText', '__init__', '__text_collections',
self.__text_collections)
self.__text_items = ['']
self.__text_select_dialog(master)
log_leave_func('SelectText', '__init__')
def __on_ok(self):
log_enter_func('CreateCssRuleSet', '__on_ok')
selector_type = self.__selector_type_var.get()
log_set_var('CreateCssRuleSet', '__on_ok', 'selector_type',
selector_type)
is_compound = self.__is_compound(selector_type)
log_set_var('CreateCssRuleSet', '__on_ok', 'is_compound', is_compound)
if not self.__check_user_input(is_compound):
log_error('CreateCssRuleSet', '__on_ok', 'user input check failed')
log_leave_func('CreateCssRuleSet', '__on_ok')
return
selector_element = self.__get_selector_element(selector_type)
log_set_var('CreateCssRuleSet', '__on_ok', 'selector_element',
selector_element)
selector_specifier = self.__get_selector_specifier(
selector_type, is_compound)
log_set_var('CreateCssRuleSet', '__on_ok', 'selector_specifier',
selector_specifier)
self.__dialog.destroy()
self.__observer.on_create_css_rule_set_closed(
(self.__SELECTOR_TYPE_MAP[selector_type], selector_element,
selector_specifier, is_compound,
self.__SELECTOR_TYPE_SEP.get(selector_type)))
log_leave_func('CreateCssRuleSet', '__on_ok')
def __init__(self):
'''
Constructor
'''
log_enter_func('MainWindowCNTLR', '__init__')
self.__overview = OverviewControl(self.__gui.get_page_overview_frame())
self.__overview.add_obeserver(self)
self.__configuration = ConfigurationControl(self.__gui.get_page_config_frame())
self.__configuration.add_obeserver(self)
treeview_conf = TreeViewConfiguration()
treeview_conf.column_count = 2
treeview_conf.add_column_name('Property', 0)
treeview_conf.add_column_name('Value', 1)
log_set_var('MainWindowCNTLR', '__init__', 'treeview_conf', treeview_conf)
self.__properties = TreeViewControl(self.__gui.get_attributes_frame(), treeview_conf)
self.__properties.add_observer(self)
self.__model.add_observer(self)
log_leave_func('MainWindowCNTLR', '__init__')
def __check_user_input(self, is_compound):
log_enter_func('CreateCssRuleSet', '__check_user_input',
{'is_compound': is_compound})
user_input_ok = True
if self.__selector_var.get() == '':
log_error('CreateCssRuleSet', '__check_user_input',
'Selector not set!', None)
messagebox.showerror('Input Error', 'Selector not set!')
user_input_ok = False
if is_compound and self.__selector_sec_part_var.get() == '':
log_error('CreateCssRuleSet', '__check_user_input',
'Selector second part not set!', None)
user_input_ok = False
log_leave_func('CreateCssRuleSet', '__check_user_input', user_input_ok)
return user_input_ok
def __init__(self,
master: tk.Frame,
treeview_config: TreeViewConfiguration = None):
'''
:param tree_config: TreeViewConfiguration
'''
log_enter_func('TreeViewControl', '__init__', {
'master': master,
'tree_config': treeview_config
})
#Contains all TreeViewItems added to the TreeView
self.__added_treeview_items = []
#Is the item which is currently about to be added to the tree.
self.__current_treeview_item = None
#Contains the error message if the state is set to ERROR.
#This is optional! It is not said that there is an message if an error occurs.
self.__error_message = None
#State of the TreeViewControl
self.__treeview_state = TreeViewState.OK
#Contains all registered observers.
self.__observers = []
#This array contains all TreeViewItem for which the parent element was not added
#at the time as they were added.
self.__parentless_items = []
#UI Treeview element.
self.__treeview = None
#Contains the mapping of the treeview_id and the corresponding TreeViewItem.
self.__treeview_id_dict = {}
#build the treeview
self.__build_tree(master, treeview_config)
log_leave_func('TreeViewControl', '__init__')
def __update_title(self):
log_enter_func('MainWindowCNTLR', '__update_title')
self.__root.title(' - '.join([self.__base_title,
self.__model.get_project_name()]))
log_leave_func('MainWindowCNTLR', '__update_title')
def __remove(self, tag_id):
log_enter_func('OverviewControl', '__remove', {'tag_id': tag_id})
self.__overview.delete(tag_id)
log_leave_func('OverviewControl', '__remove')
def __css_dialog(self, master):
'''
'''
log_enter_func('CreateCssRuleSet', '__css_dialog', {'master': master})
self.__dialog = tk.Toplevel(master)
self.__dialog.title('Create New CSS Rule Set')
self.__top_frame = tk.Frame(self.__dialog)
self.__top_frame.pack(fill=tk.BOTH,
side=tk.TOP,
expand=True,
padx=10,
pady=10)
log_msg('CreateCssRuleSet', '__css_dialog',
'topLevel and main frame created')
tk.Label(self.__top_frame, text='Selector Type:',
anchor=tk.W).grid(row=0, column=0, padx=10, sticky=tk.W)
tk.OptionMenu(self.__top_frame,
self.__selector_type_var,
*CreateCssRuleSet.__selectors,
command=self.__on_selector_type_selected).grid(
row=0, column=1, columnspan=3, sticky=tk.EW, padx=10)
log_msg('CreateCssRuleSet', '__css_dialog',
'selector type selection created')
selector_frame = tk.Frame(self.__top_frame)
selector_frame.grid(row=1,
column=0,
columnspan=2,
padx=10,
sticky=tk.W)
tk.Label(selector_frame, text='Selector:',
anchor=tk.W).grid(row=0, column=0, padx=10, sticky=tk.W)
selector_entry = tk.Entry(selector_frame,
textvariable=self.__selector_var)
selector_entry.grid(row=0, column=1, columnspan=1, sticky=tk.W, padx=0)
self.__selector_part_2_lbl = tk.Label(selector_frame,
text='#',
anchor=tk.W)
self.__selector_part_2_entry = tk.Entry(
selector_frame, textvariable=self.__selector_sec_part_var)
log_msg('CreateCssRuleSet', '__css_dialog', 'selector input created')
buttons_frame = tk.Frame(self.__dialog)
buttons_frame.pack(fill=tk.X, side=tk.BOTTOM, padx=20)
tk.Button(buttons_frame, text='Ok',
command=self.__on_ok).pack(side=tk.LEFT, padx=1)
tk.Button(buttons_frame, text='Cancel',
command=self.__on_cancel).pack(side=tk.LEFT, padx=1)
log_leave_func('CreateCssRuleSet', '__css_dialog')
def __on_cancel(self):
log_enter_func('CreateTagDialog', '__on_cancel')
self.__dialog.destroy()
self.__observer.on_create_tag_closed()
log_leave_func('CreateTagDialog', '__on_cancel')
def remove_observer(self, observer: OverviewControlObserver):
log_enter_func('OverviewControl', 'remove_observer',
{'observer': observer})
self.__observers.remove(observer)
log_leave_func('OverviewControl', 'remove_observer')
def __on_cancel(self):
log_enter_func('CreateCssRuleSet', '__on_cancel')
self.__dialog.destroy()
self.__observer.on_create_css_rule_set_closed()
log_leave_func('CreateCssRuleSet', '__on_cancel')
def __remove(self, conf_id):
log_enter_func('ConfigurationControl', '__remove',
{'conf_id': conf_id})
self.__configuration.delete(conf_id)
log_leave_func('ConfigurationControl', '__remove')
def remove_observer(self, observer: ConfigurationControlObserver):
log_enter_func('ConfigurationControl', 'remove_observer',
{'observer': observer})
self.__observers.remove(observer)
log_leave_func('ConfigurationControl', 'remove_observer')
def add_obeserver(self, observer: ConfigurationControlObserver):
log_enter_func('ConfigurationControl', 'add_obeserver',
{'observer': observer})
self.__observers.append(observer)
log_leave_func('ConfigurationControl', 'add_obeserver')
def remove_page(self, page_id: str):
log_enter_func('OverviewControl', 'remove_page', {'page_id': page_id})
self.__remove(page_id)
self.__inserted.remove(page_id)
log_leave_func('OverviewControl', 'remove_page')
def __on_cancel(self):
log_enter_func('SelectText', '__on_cancel')
self.__dialog.destroy()
self.__observer.on_text_selected()
log_leave_func('SelectText', '__on_cancel')
def on_double_click(self, item:TreeViewItem)->None:
log_enter_func('MainWindowCNTLR', 'on_double_click', {'item':item})
if not item == None:
self.__model.set_property(item.id)
log_leave_func('MainWindowCNTLR', 'on_double_click')
def add_obeserver(self, observer: OverviewControlObserver):
log_enter_func('OverviewControl', 'add_obeserver',
{'observer': observer})
self.__observers.append(observer)
log_leave_func('OverviewControl', 'add_obeserver')
def __load_properties(self):
log_enter_func('MainWindowCNTLR', '__load_properties')
for treeview_item in self.__model.get_sub_data():
self.__properties.insert(treeview_item)
log_leave_func('MainWindowCNTLR', '__load_properties')
def clear_observers(self) -> None:
'''
Removes all registered observers.
'''
log_enter_func('TreeViewControl', 'clear_observers')
self.__observers.clear()
log_leave_func('TreeViewControl', 'clear_observers')
def select(self, page_id: str):
log_enter_func('OverviewControl', 'select', {'page_id': page_id})
if not page_id == None:
self.__overview.focus(page_id)
self.__overview.selection_set(page_id)
log_leave_func('OverviewControl', 'select')
def select(self, _id: str):
log_enter_func('ConfigurationControl', 'select', {'_id': _id})
if not _id == None:
self.__configuration.focus(_id)
self.__configuration.selection_set(_id)
log_leave_func('ConfigurationControl', 'select')
def unregister_observer(self):
'''
'''
log_enter_func('SelectText', 'unregister_observer')
del self.__observer
log_leave_func('SelectText', 'unregister_observer')
def __load_data_in_view(self):
log_enter_func('MainWindowCNTLR', '__load_data_in_view')
self.__update_title()
self.__load_page_config()
self.__load_page_overview()
self.__configuration.select(self.__model.selected_sub())
log_leave_func('MainWindowCNTLR', '__load_data_in_view')
def insert(self, treeview_item: TreeViewItem) -> None:
'''
Add the given treeview_item to the TreeViewcontrol.
If the parent_id of the treeview_item is set, the given treeview_item will inserted
under TreeViewItem with the corresponding ID.
If the parent_id of the treeview_item is set, but there is no item with that ID
in the TreeViewControl, the given treeview_item will be inserted under the "Parentless"
top level element.
As soon as the parent is added the parentless TreeViewItem will be moved from the
"Parentless" element to its actual parent.
:param treeview_item:TreeViewItem the item to be added to the TreeViewcontrol
'''
log_enter_func('TreeViewControl', 'insert',
{'treeview_item': treeview_item})
self.__current_treeview_item = treeview_item
new_treeview_id = self.__create_treeview_id()
self.__treeview_id_dict[new_treeview_id] = treeview_item
self.__added_treeview_items.append(treeview_item)
self.__validate_input()
parent_id = '' #This would insert the item as root element
if self.__treeview_state == TreeViewState.OK:
parent_id = self.__get_treeview_id(treeview_item.parent_id)
elif self.__treeview_state == TreeViewState.PARENT_NOT_EXISTS:
#Add current_treeview_item to parentless items
self.__parentless_items.append(treeview_item)
parent_id = TreeViewControl.PARENTLESS_ROOT_ID
#Check if parentless node exists
if not self.__treeview.exists(parent_id):
#If not add it.
self.__treeview.insert(
'',
'end',
parent_id,
text=TreeViewControl.PARENTLESS_ROOT_KEY)
values = ['']
if not treeview_item.value == None:
values = [treeview_item.value]
self.__treeview.insert(parent_id,
'end',
new_treeview_id,
text=treeview_item.key,
values=values)
self.__revise_parentlesses()
log_leave_func('TreeViewControl', 'insert')
