class AlexLabelTest(AbstractComponentTest): def __init__(self): super().__init__() self.name = "Alex label test" def test_component(self, master, message_label): self.message_label = message_label self.master = master self.label1 = AlexLabel(master) self.label1.set('Label text:') self.label1.grid(row=0, column=0) self.entry1 = AlexEntry(master) self.entry1.set("Enter label text") self.entry1.grid(row=0, column=1) AlexButton(master, text='Set label text', command=self._set_label_text).grid(row=1, column=0) AlexButton(master, text='Set entry from label', command=self._set_entry_from_label).grid(row=1, column=1) def _set_label_text(self): self.label1.set(self.entry1.get()) self.entry1.set('') def _set_entry_from_label(self): self.entry1.set(self.label1.get())
class GenericInputEditDialog(AbstractInputDialog): def __init__(self, window_manager, presenter): super().__init__(window_manager, presenter) def create_dialog(self): super().create_dialog() self.set_default_buttons() self.label = AlexLabel(self.interior) self.label.pack() self.entry = AlexEntry(self.interior) self.entry.pack() def config_dialog(self, label=_('Please edit string:'), initvalue=''): self.label.set(label) self.entry.set(initvalue) def _get_entry(self): return self.entry.get() def _set_entry(self, value): self.entry.set(value) input = property(_get_entry, _set_entry)
class ReferenceView(Frame): # @UndefinedVariable def __init__(self, parent, presenter, label): super().__init__(parent, borderwidth=1, relief=RIDGE) self.parent = parent self.presenter = presenter self.presenter.view = self self.labelframe = Frame(self) self.labelframe.pack(pady=5) self.listbox = AlexComboBox(self) self.listbox.pack(fill=X, padx=5) self._add_label(label) self.pack(side=LEFT, padx=5, pady=5) self.buttonframe = Frame(self) self.buttonframe.pack() self.buttons = [] def _add_label(self, label): self.label = AlexLabel(self.labelframe) self.label.pack() self.label.set(label) def _set_items(self, items): self.deactivate() self.listbox.set_items(items) self.activate() def _get_selected_item(self): return self.listbox.get() def _get_items(self): return self.listbox.get_items() def add_button(self, action): self.buttons.append( AlexButton(self.buttonframe, text=action.label, command=action.callback)) self.buttons[-1].pack(side=LEFT, padx=5, pady=5) def deactivate(self): for button in self.buttons: button.configure(state=DISABLED) def activate(self): for button in self.buttons: button.configure(state=NORMAL) def show_message(self, message_text): messagebox.showinfo(_("Hint"), message_text) items = property(_get_items, _set_items) selected_item = property(_get_selected_item)
class GenericTreeSelectionDialog(AbstractInputDialog): def __init__(self, window_manager, presenter): super().__init__(window_manager, presenter) self.tree_widget = None self.filter_is_set = False def create_dialog(self): super().create_dialog() self.label = AlexLabel(self.interior) self.label.pack(side=TOP, padx=5, pady=5) filter_frame = Frame(self.interior) AlexLabel(filter_frame, text=_('Search tree:')).pack(side=LEFT, pady=5) self.filter_entry = AlexEntry(filter_frame) self.filter_entry.bind("<KeyRelease>", lambda event: self._apply_filter(event)) self.filter_entry.pack(side=LEFT, fill=X, expand=YES) filter_frame.pack(side=TOP, expand=YES, fill=X) self.set_default_buttons() def config_dialog(self, label=_('Select a tree node')): self.label.set(label) def _apply_filter(self, event): filter_string = self.filter_entry.get() if len(filter_string) > 2: visible_nodes = self.tree_widget.apply_filter(filter_string) if visible_nodes < 20: self.tree_widget.expand_all() self.filter_is_set = True else: if self.filter_is_set: self.tree_widget.clear_filter() self.filter_is_set = False def set_tree(self, tree): if self.tree_widget is not None: self.tree_widget.destroy() self.tree_widget = AlexTree(self.interior, tree) self.tree_widget.pack() def activate(self, callback, label): if self.window is not None: self.label.set(label) super().activate(callback, label=label) input = property(lambda self: self.tree_widget.get()) tree = property(None, set_tree)
def create_dialog(self): super().create_dialog() label = AlexLabel(self.interior) label.set("%s:" % _('Please select year')) label.pack() self.year_combo_box = AlexComboBox(self.interior) self.year_combo_box.pack(padx=5, pady=5) self.set_default_buttons()
class GenericBooleanSelectionDialog(AbstractInputDialog): @inject def __init__(self, window_manager: guiinjectorkeys.WINDOW_MANAGER_KEY, presenter: guiinjectorkeys.GENERIC_INPUT_DIALOG_PRESENTER): super().__init__(window_manager, presenter) def create_dialog(self): super().create_dialog() self.add_button(_('Yes'), self.presenter.yes_action) self.add_button(_('No'), self.presenter.no_action) self.label = AlexLabel(self.interior) self.label.pack(padx=20, pady=20) def config_dialog(self, question=('Select yes or no')): self.label.set(question)
def __init__(self, test_classes): self.message_broker = MessageBroker() self.window_manager = WindowManager(self.message_broker) self.create_test_instances(test_classes) self.root = self.window_manager.create_new_window() geometry = '800x450' self.root.geometry(geometry) self.test_frame = None top_frame = Frame(self.root) top_frame.pack(side=TOP, fill=BOTH, expand=TRUE) message_frame = Frame(self.root) message_frame.pack(side=TOP) button_frame = Frame(self.root) button_frame.pack(side=TOP) self.message_label = AlexLabel(message_frame) self.message_label.pack(side=LEFT) self.menu_frame = Frame(top_frame) self.menu_frame.pack(side=LEFT, anchor=NW, padx=5) label = AlexLabel(self.menu_frame) label.set("Select a test") label.pack() self.tests = AlexListBox( self.menu_frame, # @UndefinedVariable height=len(self.test_instances), selectioncommand=self.run_selected_test, ) self.tests.set_items(self.test_instances) self.tests.pack(anchor=NW) self.widget_frame = Frame(top_frame, borderwidth=1, relief=SOLID) self.widget_frame.pack(side=LEFT, fill=BOTH, expand=TRUE) quit_button = Button(button_frame, command=self.root.quit, text="Quit") quit_button.pack(side=LEFT)
class EventConfirmationDialog(AbstractInputDialog): @inject def __init__(self, window_manager: guiinjectorkeys.WINDOW_MANAGER_KEY, presenter: guiinjectorkeys.EVENT_CONFIRMATION_PRESENTER_KEY): super().__init__(window_manager, presenter) def create_dialog(self): super().create_dialog() self.add_button(_('Create new event'), self.presenter.cancel_action) self.label = AlexLabel(self.interior, wraplength=550, font=("Helvetica", 14, "bold")) self.label.pack() self.event_frame = None def config_dialog(self, event_list=[], date=None): self.label.set( _("Events exist on %s. Please select the event you want or create a new one" ) % date) if self.event_frame is not None: self.event_frame.destroy() self.event_frame = Frame(self.interior) self.event_frame.pack() row_counter = 0 for event in event_list: description = AlexLabel(self.event_frame, wraplength=500, justify=LEFT, text=event.description) description.grid(row=row_counter, column=0, sticky=W) def closure(event): return lambda: self._set_return_value(event) button = AlexButton(self.event_frame, text=_("Goto event"), command=closure(event)) button.grid(row=row_counter, column=1) row_counter += 1
def test_component(self, master, message_label): self.message_label = message_label self.master = master label1 = AlexLabel(master) label1.set('Entry 1:') label1.grid(row=0, column=0) self.entry1 = AlexEntry(master) self.entry1.set("Entry 1 text") self.entry1.grid(row=0, column=1) label2 = AlexLabel(master) label2.set('Entry 2:') label2.grid(row=1, column=0) self.entry2 = AlexEntry(master) self.entry2.set("Entry 2 text") self.entry2.grid(row=1, column=1) AlexButton(master, text='Switch input', command=self._switch_input).grid(row=2, column=1)
def create_dialog(self): self.window = self.window_manager.create_new_window() self.window.withdraw() super().__init__(self.window) self.pack() label = AlexLabel(self) label.set(_("Please select user:")) label.pack(padx=5, pady=5) self.combobox = AlexComboBox(self) self.combobox.pack(padx=5, pady=5) buttonframe = Frame(self) buttonframe.pack(padx=5, pady=5) AlexButton(buttonframe, text=_('OK'), command=self.presenter.ok_action).pack(side=LEFT) AlexButton(buttonframe, text=_('Cancel'), command=self.presenter.cancel_action).pack(side=LEFT)
class DocumentWindow(BaseWindow): ''' The window for manipulating documents. ''' @inject @singleton def __init__(self, window_manager: guiinjectorkeys.WINDOW_MANAGER_KEY, message_broker: guiinjectorkeys.MESSAGE_BROKER_KEY, presenter: guiinjectorkeys.DOCUMENT_WINDOW_PRESENTER_KEY, dialogs: guiinjectorkeys.DOCUMENT_WINDOW_DIALOGS_KEY, document_menu_additions: guiinjectorkeys. DOCUMENT_MENU_ADDITIONS_KEY): self.notebook = None self._description_widget = None self._condition_widget = None self._keywords_widget = None super().__init__(window_manager, message_broker, presenter, dialogs, document_menu_additions) self.window.title(_("Alexandria documents")) def _create_new(self): self.presenter.create_new() def _change_widget_state(self, state): self._description_widget.configure(state=state) self._condition_widget.configure(state=state) self._keywords_widget.configure(state=state) def _clear_widgets(self): self._document_label.set(_("No document available")) self._description_widget.set('') self._condition_widget.set('') self._keywords_widget.set('') def _disable_widgets(self): self._change_widget_state(DISABLED) def _enable_widgets(self): self._change_widget_state(NORMAL) def _populate_entity_frame(self): # pylint: disable=no-member self._document_label = AlexLabel(self.entity_frame, text=_("No document available")) self._document_label.pack(padx=7, pady=7) self.notebook = Notebook(self.entity_frame, width=600) self.notebook.pack(fill=X) description = Frame(self.notebook) self.notebook.add(description, text=_('Description')) self._description_widget = AlexText(description, font="Helvetica 12 bold", wrap=WORD, height=6) self._description_widget.pack(fill=X) condition = Frame(self.notebook) self.notebook.add(condition, text=_('Condition')) self._condition_widget = AlexText(condition, font="Helvetica 12 bold", wrap=WORD, height=6) self._condition_widget.pack(fill=X) keywords = Frame(self.notebook) self.notebook.add(keywords, text=_('Keywords')) self._keywords_widget = AlexText(keywords, font="Helvetica 12 bold", wrap=WORD, height=6) self._keywords_widget.pack(fill=X) def _view_to_entity(self): if self._entity == None: return None if self._description_widget.get() != self._entity.description: self._entity_has_changed = True self._entity.description = self._description_widget.get() if self._condition_widget.get() != self._entity.condition: self._entity_has_changed = True self._entity.condition = self._condition_widget.get() if self._keywords_widget.get() != self._entity.keywords: self._entity_has_changed = True self._entity.keywords = self._keywords_widget.get() return self._entity def _entity_to_view(self, entity): if self._entity != entity: self._entity_has_changed = False if self._entity == None: self._enable_widgets() self._entity = entity if entity == None: self._clear_widgets() self._disable_widgets() return if self._entity.id == None: self._document_label.set(_("New document")) else: self._document_label.set( _("Document no.{0:d} ({1!s})").format( self._entity.id, self._entity.document_type.description)) self._description_widget.set(self._entity.description) self._condition_widget.set(self._entity.condition) self._keywords_widget.set(self._entity.keywords)
class AbstractInputDialog: ''' A basic dialog skeleton for input dialogs. For simple message dialogs use the native dialogs of tkinter. This provides a rather simple framework for fast creating dialogs that return user input to the calling component. The framework works like this: - Make a subclass of this class - Overwrite the create_dialog method. You need to call the method in this superclass to provide you with the basic frames in the dialog window. Add your input stuff to the interior frame and your buttons to the button_frame (there are methods to help you for this) - Make a subclass of the AbstractInputDialogPresenter - Create action methods in the presenter that are bound to the buttons in the dialog window - The actions that are considered to close the dialog must set the return_value property of the view. This will close the dialog window and return the return_value to the caller of activate - Inject the dialog presenter into the dialog - Inject the dialog into your component that wants to use it - Call the activate method in the dialog in your component. You need to set a callback for your value. This callback will be executed with a value when the presenter closes the dialog window ''' def __init__(self, window_manager, presenter): self.window_manager = window_manager self.presenter = presenter self.window = None self.callback = None def create_dialog(self): ''' Extend this method in your child class. It already provides three frames: interior, buttons_frame and errormessage. The errormessage frame already has a label that may be read and set by the errormessage property. To set default buttons in the button_frame, use the set default buttons. Other buttons may be set through the add_button method. ''' self.window = self.window_manager.create_new_window() self.window.protocol("WM_DELETE_WINDOW", lambda: self._set_return_value(None)) self.window.transient() self.window.attributes('-topmost', True) self.window.withdraw() self.interior = Frame(self.window) self.interior.pack() self.buttons_frame = Frame(self.window) self.buttons_frame.pack() self.message_frame = Frame(self.window) self.message_frame.pack() self._errormessage = AlexLabel(self.message_frame) self._errormessage.pack(side=TOP) def add_button(self, label, callback): ''' Fast setup method for buttons. Just provide a label and a callback and a button will be appended to the button_frame ''' button = AlexButton(self.buttons_frame, command=callback) button.set(label) button.pack(side=LEFT, padx=5, pady=5) return button def set_default_buttons(self): ''' This method may be used in child classes to set the default buttons OK and Cancel ''' self.add_button(_('OK'), self.presenter.ok_action) self.add_button(_('Cancel'), self.presenter.cancel_action) def _get_errormessage(self): message = self._errormessage.get() if message == '': return None else: return message def _set_errormessage(self, message): if message == None: self._errormessage.set('') else: self._errormessage.set(message) def activate(self, callback, **kw): ''' ''' if self.window is None: self.create_dialog() self.config_dialog(**kw) if self.window is None: callback(None) return self.callback = callback self.presenter.view = self self.window.deiconify() self.window.grab_set() def config_dialog(self, **kw): pass def _set_return_value(self, value): self.window.grab_release() self.window.withdraw() self.callback(value) return_value = property(None, _set_return_value) errormessage = property(_get_errormessage, _set_errormessage)