""" Hierarchy of Sizers supported by wxGlade @copyright: 2002-2007 Alberto Griggio @copyright: 2014-2016 Carsten Grohmann @copyright: 2016-2024 Dietmar Schwertberger @license: MIT (see LICENSE.txt) - THIS PROGRAM COMES WITH NO WARRANTY """ import wx from wx.lib.buttons import GenButton import new_properties as np import clipboard import common, compat, config, misc import edit_base HAVE_WRAP_SIZER = hasattr(wx, "WrapSizer") # only for 3.0 def _frozen(method): "freeze toplevel parent during update" def _frozen(sizer, *args, **kwargs): if config.use_freeze_thaw and sizer.window.widget: toplevel = sizer.window.widget.GetTopLevelParent() if config.debugging: print("Freezing", toplevel) toplevel.Freeze() else: toplevel = None try: return method(sizer, *args, **kwargs) finally: if toplevel: toplevel.Refresh() if config.debugging: print("Thawing", toplevel) toplevel.Thaw() return _frozen class SizerSlot(edit_base.Slot): "A window to represent a slot in a sizer" WX_CLASS ="sizerslot" def __init__(self, parent, index, label=None): edit_base.Slot.__init__(self, parent, index, label) def set_overlap(self, overlapped=True, add_to_sizer=True): # interface from GridBagSizer; so self.parent is a sizer if overlapped==self.overlapped: return self.overlapped = overlapped if not config.use_gui: return sizer = self.parent if overlapped: if self.widget: self.parent.destroying_child_widget(self, self.index) self.destroy_widget(0) else: if sizer.widget and not self.widget: self.create_widget() if add_to_sizer: sizer.widget.Add(self.widget, self.index, self.span, wx.EXPAND, self.border) self.properties["info"].set( self._get_tooltip() ) common.app_tree.refresh(self) # XXX indicate overlapped slots def check_drop_compatibility(self): if self.overlapped: return (False,"Slot/cell overlapped by another cell") return (True,None) # clipboard handling ############################################################################################### def check_compatibility(self, widget, typename=None): "check whether widget can be pasted here" if self.overlapped: return (False,"Slot/cell overlapped by another cell") if typename is not None: if typename=="window": return (False, "No toplevel object can be pasted here.") if typename in ('menubar', 'toolbar', 'statusbar'): return (False, "No %s object can be pasted here."%typename) if typename=="slot": return (False, "No slot can be pasted here.") return (True,None) if widget.IS_TOPLEVEL: return (False, "No toplevel object can be pasted here.") if widget.WX_CLASS in ('wxMenuBar', 'wxToolBar', 'wxStatusBar'): return (False, "No %s object can be pasted here."%widget.WX_CLASS) if widget.IS_SLOT: return (False, "No slot can be pasted here.") return (True,None) def write(self, output, tabs): output.extend( common.format_xml_tag( u'object', '', tabs, **{'class': 'sizerslot'}) ) def _get_tooltip(self): if self.overlapped: return "This slot is overlapped by another cell.\n(see Properties->Layout->Span of the other cell)" return "Add a widget or another sizer here." class SizerHandleButton(GenButton): 'Provides a "handle" to activate a Sizer and to access its popup menu' def __init__(self, parent, id, sizer): GenButton.__init__(self, parent.widget, id, '', size=(5, 5)) self.sizer = sizer self.SetUseFocusIndicator(False) self.Bind(wx.EVT_RIGHT_DOWN, self.sizer.popup_menu ) #self.Bind(wx.EVT_KEY_DOWN, misc.on_key_down_event) colour = compat.wx_SystemSettings_GetColour(wx.SYS_COLOUR_BTNFACE) self.SetBackgroundColour(colour) class BaseSizerBuilder(object): "Language independent base class for all sizer builders / code generators" tmpl = [] # Statements to generate the sizer from, the stmt has to end with a newline character language = None # Language to generate the code for tmpl_SetSizer = '' # Template to call SetSizer() tmpl_Fit = '' # Template to call Fit() tmpl_Realize = '' # Template to call Realize() for StdDialogButtonSizer tmpl_SetSizeHints = '' # Template to set the size hints tmpl_AddGrowableRow = '' # Template for wxFlexGridSizer to set growable rows tmpl_AddGrowableCol = '' # Template for wxFlexGridSizer to set growable columns def __init__(self): "Initialise sizer builder" self.tmpl_dict = {} # properties to replace in tmpl self.codegen = common.code_writers[self.language] #language specific code generator (codegen.BaseLangCodeWriter) def _get_wparent(self, topl, obj): "Return the parent widget or a reference to it as string" raise NotImplementedError def _prepare_tmpl_content(self, obj): """Prepare template variables""" self.tmpl_dict.clear() self.tmpl_dict['klass'] = self.codegen.cn(obj.WX_CLASS) self.tmpl_dict['wxIDANY'] = self.codegen.cn('wxID_ANY') self.tmpl_dict['parent_widget'] = self._get_wparent(obj) self.tmpl_dict['sizer_name'] = self.codegen._format_classattr(obj) def _get_code(self, obj): "Generates the language specific code for sizer specified in klass" if not self.tmpl: return [], [] # init, final init = [] layout = [] # generate init lines from tmpl filled with tmpl_dict init.append(self.tmpl % self.tmpl_dict) # generate layout lines if not obj.parent.IS_SIZER: layout.append(self.tmpl_SetSizer % self.tmpl_dict) if not obj.parent.check_prop("size") and obj.parent.IS_TOPLEVEL: layout.append(self.tmpl_Fit % self.tmpl_dict) if "sizehints" in obj.window.properties and obj.window.sizehints: layout.append(self.tmpl_SetSizeHints % self.tmpl_dict) return init, layout # init, post def get_code(self, obj): "Generates the language specific code for sizer specified in klass" self._prepare_tmpl_content(obj) if obj.WX_CLASS == 'wxBoxSizer': return self.get_code_wxBoxSizer(obj) if obj.WX_CLASS == 'wxWrapSizer': return self.get_code_wxBoxSizer(obj) # the same here if obj.WX_CLASS == 'wxStaticBoxSizer': return self.get_code_wxStaticBoxSizer(obj) if obj.WX_CLASS == 'wxStdDialogButtonSizer': return self.get_code_wxStdDialogButtonSizer(obj) if obj.WX_CLASS == 'wxGridSizer': return self.get_code_wxGridSizer(obj) if obj.WX_CLASS == 'wxFlexGridSizer': return self.get_code_wxFlexGridSizer(obj) if obj.WX_CLASS == 'wxGridBagSizer': return self.get_code_wxFlexGridSizer(obj) return self._get_code(obj) def get_code_wxStaticBoxSizer(self, obj): "Set sizer specific properties and generate the code" self.tmpl_dict['orient'] = self.codegen.cn( obj.properties["orient"].get_string_value() ) self.tmpl_dict['label'] = self.codegen.quote_str( obj.label ) return self._get_code(obj) def get_code_wxBoxSizer(self, obj): "Set sizer specific properties and generate the code" self.tmpl_dict['orient'] = self.codegen.cn( obj.properties["orient"].get_string_value() ) return self._get_code(obj) def get_code_wxStdDialogButtonSizer(self, obj): "Set sizer specific properties and generate the code" ret = self._get_code(obj) # append Realize to layout code ret[-1].append(self.tmpl_Realize % self.tmpl_dict) return ret def get_code_wxGridSizer(self, obj): "Set sizer specific properties and generate the code" if obj.WX_CLASS != 'wxGridBagSizer': self.tmpl_dict['rows'] = obj.rows self.tmpl_dict['cols'] = obj.cols self.tmpl_dict['vgap'] = obj.vgap self.tmpl_dict['hgap'] = obj.hgap return self._get_code(obj) def get_code_wxFlexGridSizer(self, obj): "Set sizer specific properties and generate the code" ret = list( self.get_code_wxGridSizer(obj) ) if obj.WX_CLASS=="wxGridBagSizer": max_row, max_col = obj._get_max_row_col() else: max_row = max_col = None growable = [] if 'growable_rows' in obj.properties: for row in obj.growable_rows: if max_row is None or row<=max_row: self.tmpl_dict['row'] = row growable.append(self.tmpl_AddGrowableRow % self.tmpl_dict) if 'growable_cols' in obj.properties: for col in obj.growable_cols: if max_col is None or col<=max_col: self.tmpl_dict['col'] = col growable.append(self.tmpl_AddGrowableCol % self.tmpl_dict) ret[-1] = growable + ret[-1] return ret def get_code_per_child(self, obj, child): """Returns code that will be inserted after the child code; e.g. for adding element to a sizer. It's placed before the final code returned from get_code().""" if child.WX_CLASS in ("spacer","sizerslot"): # spacer and slot are adding itself to the sizer return [] # the name attribute of a spacer is already formatted ", ". # This string can simply inserted in Add() call. obj_name = self.codegen._format_classattr(child) # check if sizer has to store as a class attribute sizer_name = self.codegen._format_classattr(obj) flag = child.properties["flag"].get_string_value() # as string, joined with "|" flag = self.codegen.cn_f(flag) or '0' if obj.WX_CLASS=="wxStdDialogButtonSizer" and child.WX_CLASS=='wxButton': # XXX optionally use SetAffirmativeButton, SetCancelButton, SetNegativeButton id_value = child.check_prop("id") and child.properties["id"].value.strip() or "" # e.g. 'wxID_CANCEL' if ( (child.check_prop_truth("stockitem") and child.stockitem in obj.BUTTON_STOCKITEMS) or (id_value and id_value.startswith("wxID_") and id_value[5:] in obj.BUTTON_STOCKITEMS) ): tmpl = self.codegen.tmpl_sizeritem_button return [tmpl % ( sizer_name, obj_name )] if obj.WX_CLASS!="wxGridBagSizer": stmt = self.codegen.tmpl_sizeritem % ( sizer_name, obj_name, child.proportion, flag, child.border ) else: index = obj._get_row_col(child.index) stmt = self.codegen.tmpl_gridbagsizeritem % ( sizer_name, obj_name, index, child.span, flag, child.border ) return [stmt] class SlotGenerator(object): # generic code generator; as a slot does not have flags etc. we don't need BaseWidgetBuilder etc. def __init__(self, language): self.language = language self.codegen = common.code_writers[self.language] #language specific code generator (codegen.BaseLangCodeWriter) def get_code(self, obj): # add spacer for empty sizer slot parent = obj.parent if not parent.IS_SIZER or parent._IS_GRIDBAG: return [], [] sizer_name = self.codegen._format_classattr(parent) size = self.codegen.tmpl_spacersize%(0, 0) stmt = self.codegen.tmpl_sizeritem % ( sizer_name, size, 0, '0', 0 ) return [stmt], [] def get_event_handlers(self, obj): return [] class OrientProperty(np.Property): "orientation property for BoxSizers; hidden property to be set by the ClassOrientProperty" ORIENTATION_to_STRING = {wx.HORIZONTAL: 'wxHORIZONTAL', wx.VERTICAL: 'wxVERTICAL'} STRING_to_ORIENTATION = {'wxHORIZONTAL': wx.HORIZONTAL, 'wxVERTICAL': wx.VERTICAL} def __init__(self, value, default_value=None, name=None): assert value!=0 np.Property.__init__(self, value, default_value, name) def _set_converter(self, value): if not value: return None if isinstance(value, int): return value return self.STRING_to_ORIENTATION.get(value, value) def _write_converter(self, value): if not value: return None return self.ORIENTATION_to_STRING[value] def get_string_value(self): return self.ORIENTATION_to_STRING[self.value] class ClassOrientProperty(np.RadioProperty): # radio box: class name and orientation; will not be written to XML file, but will influence class and orient CHOICES = [ ('wxBoxSizer (wxVERTICAL)', 'without box and label'), ('wxBoxSizer (wxHORIZONTAL)', 'without box and label'), ('wxStaticBoxSizer (wxVERTICAL)', 'with box and label'), ('wxStaticBoxSizer (wxHORIZONTAL)', 'with box and label') ] if HAVE_WRAP_SIZER: CHOICES += [ ('wxWrapSizer (wxVERTICAL)', 'without box and label; wraps around'), ('wxWrapSizer (wxHORIZONTAL)', 'without box and label; wraps around') ] CHOICES += [('wxStdDialogButtonSizer', 'for dialog buttons (will be rearranged acc. to platform style guide)'), ('wxGridSizer', None), ('wxFlexGridSizer', "with columns/rows of different widths"), ('wxGridBagSizer', "with cell spanning (i.e. item may populate multiple grid cells)")] TOOLTIPS = [c[1] for c in CHOICES] CHOICES = [c[0] for c in CHOICES] def __init__(self, value=None): np.RadioProperty.__init__(self, value, self.CHOICES, tooltips=self.TOOLTIPS) def write(self, output, tabs=0): pass class SizerBase(edit_base.EditBase): "Base class for every non-virtual Sizer handled by wxGlade" IS_SIZER = True IS_TOPLEVEL = IS_WINDOW = IS_SLOT = False _IS_GRIDBAG = False CHILDREN = None # any number PROPERTIES = ["Common", "name", "attribute", "class_orient", "Layout"] EXTRA_PROPERTIES = [] MANAGED_PROPERTIES = edit_base.MANAGED_PROPERTIES TOPLEVEL_PROPERTIES = ["fit"] _PROPERTY_LABELS = {"fit":"Fit parent", "attribute":'Store as attribute', "option": "Proportion", "class_orient":"Sizer Type"} _PROPERTY_HELP = {"fit":'Sizes the window so that it fits around its subwindows', "attribute":'Store instance as attribute of window class; e.g. self.sizer_1 = wx.BoxSizer(...)\n' 'Without this, you can not access the sizer from your program'} def __init__(self, name, parent, index, orient): edit_base.EditBase.__init__(self, name, parent, index) # if True, self is not inside another sizer, but it is the responsible of the layout of self.window toplevel = not parent.IS_SIZER self.toplevel = toplevel # initialise instance properties self.orient = OrientProperty(orient) # will be set from the class_orient property self.class_orient = ClassOrientProperty(self.get_class_orient()) # will set the orient properties self.attribute = np.CheckBoxProperty(False, default_value=False) self.fit = np.ActionButtonProperty(self.fit_parent) if not self.toplevel: self.PROPERTIES = self.PROPERTIES + self.MANAGED_PROPERTIES + self.EXTRA_PROPERTIES # if within another sizer: the arguments to sizer.Add(self, proportion, flag, border) # same as for edit_windows.ManagedBase self.span = np.LayoutSpanProperty((1,1) ) # row,colspan for items in GridBagSizers self.proportion = np.LayoutProportionProperty(1) self.border = np.SpinProperty(0, immediate=True) self.flag = np.ManagedFlags(wx.EXPAND) self._has_layout = True else: self._has_layout = False self.PROPERTIES = self.PROPERTIES + self.TOPLEVEL_PROPERTIES + self.EXTRA_PROPERTIES self._btn = None # "handle" to activate a Sizer and to access its popup menu (SizerHandleButton) window = edit_base.EditBase.parent_window def frozen(self): return self.window.frozen() def create_widget(self): self._btn = SizerHandleButton(self.window, wx.ID_ANY, self ) # XXX handle the popupmenu creation in SizerHandleButton # ScreenToClient used by WidgetTree for the popup menu self._btn.Bind(wx.EVT_BUTTON, self.on_selection, id=self._btn.GetId()) if not compat.IS_GTK: self._btn.Bind(wx.EVT_MOUSE_EVENTS, self.on_mouse_events, id=self._btn.GetId()) def finish_widget_creation(self, level): self.widget.GetBestSize = self.widget.GetMinSize self.widget.ScreenToClient = self._btn.ScreenToClient if self.toplevel: self.window.set_sizer(self) if not config.preferences.show_sizer_handle: self.widget.Show(self._btn, False) def on_mouse_events(self, event): if event.Dragging(): # start drag & drop window = misc.get_toplevel_parent(self._btn) if self._btn: self._btn.OnLeftUp(event) clipboard.begin_drag(window, self) return event.Skip() def on_selection(self, event): # button clicked -> set ourself as current widget misc.set_focused_widget(self) def get_class_orient(self): # as string return self.WX_CLASS def _properties_changed(self, modified, actions): # "class" and "orient" will only display; "class_orient" if modified and "flag" in modified and self.parent.IS_SIZER: self.properties["flag"]._check_value() if not modified or "class" in modified: self.properties["class_orient"].set(self.get_class_orient()) if not modified or "orient" in modified: self.properties["class_orient"].set(self.get_class_orient()) if "class_orient" in modified: # user has selected -> change value = self.class_orient if misc.focused_widget is self: misc.set_focused_widget(None) wx.CallAfter(change_sizer, self, value) if (not modified or "flag" in modified or "option" in modified or "border" in modified or "span" in modified): if not self.toplevel and self.sizer is not None: if "border" in modified and self.border and not "flag" in modified: # enable border flags if not yet done p = self.properties["flag"] if not p.value_set.intersection(p.FLAG_DESCRIPTION["Border"]): p.add("wxALL") if self.widget: self.sizer.item_properties_modified(self, modified) actions.add("layout") edit_base.EditBase._properties_changed(self, modified, actions) def properties_changed(self, modified): actions = edit_base.EditBase.properties_changed(self, modified) if config.debugging: assert not {"recreate", "recreate2", "refresh", "sizeevent"}.intersection(actions) if self.widget: if "layout" in actions: self.parent_window.layout() return actions def check_drop_compatibility(self): return (False, "Items can only be added to empty slots; add/insert a slot first, if required.") def check_compatibility(self, widget, typename=None): if typename is not None: if typename in ("widget","sizer"): return ("AddSlot",None) return (False,"Only widgets and sizers can be pasted here") if widget.IS_TOPLEVEL: return (False,"No toplevel objects can be pasted here") return ("AddSlot",None) # a slot is to be added before inserting/pasting # popup menu ####################################################################################################### def popup_menu(self, event, pos=None): "pops up a menu to add or remove slots from self, or to remove self from the application." event_widget = event.GetEventObject() menu = self._create_popup_menu(widget=event_widget) if pos is None: # convert relative event position to relative widget position event_pos = event.GetPosition() screen_pos = event_widget.ClientToScreen(event_pos) pos = event_widget.ScreenToClient(screen_pos) event_widget.PopupMenu(menu, pos) menu.Destroy() def _can_add_insert_slots(self, report=False): return True def _create_popup_menu(self, widget): # provide popup menu for removal menu = misc.wxGladePopupMenu(self.name) widgetclass = self.__class__.__name__.lstrip("Edit") i = misc.append_menu_item(menu, -1, _('Remove %s\tDel')%widgetclass, wx.ART_DELETE) misc.bind_menu_item_after(widget, i, self.remove) if not self.toplevel and self.sizer and self.sizer._can_add_insert_slots(): i = misc.append_menu_item( menu, -1, _('Insert slot before\tCtrl+I') ) misc.bind_menu_item_after(widget, i, self.sizer.insert_slot, self.index) menu.AppendSeparator() # other menu items: add/insert slot, copy, cut if self._can_add_insert_slots(): i = misc.append_menu_item( menu, -1, _('Add slot\tCtrl+A') ) misc.bind_menu_item_after(widget, i, self.add_slot) if "cols" in self.PROPERTIES: # a grid sizer i = misc.append_menu_item( menu, -1, _('Add row') ) misc.bind_menu_item_after(widget, i, self.insert_row, -1) i = misc.append_menu_item( menu, -1, _('Add column') ) misc.bind_menu_item_after(widget, i, self.insert_col, -1) menu.AppendSeparator() i = misc.append_menu_item( menu, -1, _('Copy\tCtrl+C'), wx.ART_COPY ) misc.bind_menu_item_after(widget, i, clipboard.copy, self) i = misc.append_menu_item( menu, -1, _('Cut\tCtrl+X'), wx.ART_CUT ) misc.bind_menu_item_after(widget, i, clipboard.cut, self) # preview (create or close?) menu.AppendSeparator() p = misc.get_toplevel_widget(self) if p is not None and p.preview_is_visible(): item = _('Close preview (%s)\tF5') % p.name else: item = _('Preview (%s)\tF5') % p.name i = misc.append_menu_item( menu, -1, item ) misc.bind_menu_item_after(widget, i, self.preview_parent) return menu def _add_parent_popup_menu_items(self, menu, item, widget): # called from managed widget items' _create_popup_menu method # rows/cols if inside a grid sizer if "rows" in self.PROPERTIES: row, col = self._get_row_col(item.index) i = misc.append_menu_item(menu, -1, _('Insert Row before') ) misc.bind_menu_item_after(widget, i, self.insert_row, row) i = misc.append_menu_item(menu, -1, _('Insert Column before') ) misc.bind_menu_item_after(widget, i, self.insert_col, col) if row==self.rows-1: # last row i = misc.append_menu_item(menu, -1, _('Add Row') ) misc.bind_menu_item_after(widget, i, self.insert_row, -1) if col==self.cols-1: # last col i = misc.append_menu_item(menu, -1, _('Add Column') ) misc.bind_menu_item_after(widget, i, self.insert_col, -1) if "growable_rows" in self.PROPERTIES: i = misc.append_menu_item(menu, -1, _('Make Row growable'), kind=wx.ITEM_CHECK ) i.Check(row in self.growable_rows) misc.bind_menu_item_after(widget, i, self.make_growable, "row", row) i = misc.append_menu_item(menu, -1, _('Make Column growable'), kind=wx.ITEM_CHECK ) i.Check(col in self.growable_cols) misc.bind_menu_item_after(widget, i, self.make_growable, "col", col) if "rows" in self.PROPERTIES: menu.AppendSeparator() if self._can_add_insert_slots(): # slots i = misc.append_menu_item(menu, -1, _('Insert Slot before\tCtrl+I') ) misc.bind_menu_item_after(widget, i, self.insert_slot, item.index) i = misc.append_menu_item(menu, -1, _('Insert Slots before...\tCtrl+Shift+I') ) misc.bind_menu_item_after(widget, i, self.insert_slot, item.index, True) if item.index==len(self.children)-1: # last slot -> allow to add i = misc.append_menu_item(menu, -1, _('Add Slot\tCtrl+A') ) misc.bind_menu_item_after(widget, i, self.add_slot) i = misc.append_menu_item(menu, -1, _('Add Slots...\tCtrl+Shift+A') ) misc.bind_menu_item_after(widget, i, self.add_slot, True) menu.AppendSeparator() #################################################################################################################### def _remove(self): "removes the sizer from his parent, if it has one" return self.parent._free_slot( self.parent.children.index(self) ) def remove(self, user=True): # entry point from GUI if user: common.history.widget_removing(self) common.root.saved = False # update the status of the app focus = self._remove() # slot or window misc.rebuild_tree(focus) if user: common.history.widget_removed(focus) return focus # for undo def preview_parent(self): # context menu callback p = misc.get_toplevel_widget(self) p.preview() def fit_parent(self, *args): "Tell the sizer to resize the window to match the sizer's minimal size" if self.widget and self.window.widget: if self.window.IS_TOPLEVEL: self.widget.Fit(self.window.widget.GetTopLevelParent()) else: self.widget.Fit(self.window.widget) # self.widget.SetSizeHints(self.window.widget) self.window.widget.Layout() def add_item(self, item, index=None): "Adds an item to self." # called from ManagedBase.__init__ when adding an item to the end from XML parser # or interactively when adding an item to an empty sizer slot # XXX unify with edit_base.EditBase.add_item if index is None: index = len(self.children) if index==len(self.children): self.children.append(None) else: old_child = self.children[index] if old_child: self.children[index].recursive_remove(0, keep_slot=True) if "rows" in self.PROPERTIES and not self._IS_GRIDBAG: self._adjust_rows_cols() # for GridSizer self.children[index] = item def child_widget_created(self, child, level): "called from finish_widget_creation() to add widget to sizer widget" index = child.index if self._IS_GRIDBAG: # GridBagSizer: add at (row, col) position self.widget.Add( child.widget, index, child.span, child.flag, child.border, destroy=True ) else: # no GridBagSizer: add or insert at index position if index+self.widget._BTN_OFFSET>=len(self.widget.GetChildren()): self.widget.Add( child.widget, child.proportion, child.flag, child.border ) else: self.widget.Insert(index+self.widget._BTN_OFFSET, child.widget, child.proportion, child.flag, child.border) if child.check_prop("size"): # size has been set in set_size, so we can just use GetSize here self.set_item_best_size(child, size=child.widget.GetSize()) if self.widget: self.window.widget.Layout() def _layout(self): # for delayed callback; see next method if self.widget: self.widget.Layout() def on_child_pasted(self): # otherwise EXPAND may not be obeyed wx.CallLater(1, self._layout) def destroying_child_widget(self, child, index): # previously in _free_slot # required here; otherwise removal of a StaticBox of a StaticBoxSizer will cause a crash # child has been removed from self.children already, # except when a widget is re-created or a slot is just set to overlapped self.widget.Detach(child.widget) def destroyed_child_widget(self): self.widget.Layout() def get_child_index(self, index): # return the index of the widget; in GridBagSizers, overlapped slots are skipped return index def set_item_best_size(self, widget, size=(-1,-1)): if not self.widget or not widget.widget: return elem = self.widget.GetItem(widget.widget) if not elem: return if elem.IsWindow(): item = elem.GetWindow() w, h = size if w==-1 or h==-1: best_size = item.GetBestSize() if w == -1: w = best_size[0] if h == -1: h = best_size[1] self.widget.SetItemMinSize(item, w, h) @_frozen def item_properties_modified(self, widget, modified=None): "update layout properties" if not self.widget or not widget.widget: return item = self.widget.GetItem(widget.widget) # a SizerItem or GBSizerItem instance if not item: return size_was_reduced = False # will the new scaled/expanded size be smaller than the previous? if modified is None or ("proportion" in modified or "option" in modified) and not self._IS_GRIDBAG: if widget.proportion call with window w, h = size if w == -1: w = best_size[0] if h == -1: h = best_size[1] elif widget.__class__.__name__=="EditSpacer": w = widget.width h = widget.height else: if size_was_reduced and widget.__class__.__name__ in ("EditPanel","CustomWidget"): # if proportion is reduced and no size defined, set to a minimum size of 20,20 # as GetBestSize returns the current size # maybe refactoring is required; search for RRR w,h = 20,20 else: w,h = best_size self.widget.SetItemMinSize(widget.widget, w, h) def remove_item(self, child, level, keep_slot=False): "Removes elem from self" # called from context menu of SizerSlot; detaches element and does re-layout edit_base.EditBase.remove_item(self, child, level, keep_slot) if level>0: return if "rows" in self.PROPERTIES and not self._IS_GRIDBAG: self._adjust_rows_cols() # for GridSizer def destroy_widget(self, level): if not self.widget: return if compat.IS_PHOENIX: self.widget.Clear(delete_windows=True) # not available with wxPython 3.0 else: self.widget.DeleteWindows() self.widget.Clear() if not self.parent.IS_SIZER: self.window.widget.SetSizer(None) # the call of self.widget.Destroy() would crash on mac os #edit_base.EditBase.destroy_widget(self, level) self.widget = None if wx.Platform == '__WXMSW__': def finish_set(self): # previously called after self.set_option(...) for c in self.children: if c.widget: try: c.widget.Refresh() except AttributeError: pass # sizers have no Refresh else: def finish_set(self): pass def update_view(self, selected): if self._btn is None: return if selected: colour = wx.RED else: colour = compat.wx_SystemSettings_GetColour(wx.SYS_COLOUR_BTNFACE) if not self._btn or self._btn.IsBeingDeleted(): return self._btn.SetBackgroundColour(colour) self._btn.Refresh(True) # add/insert/free slots; interface mainly from context menus ####################################################### def _add_slot(self, loading=False): "adds an empty slot to the sizer, i.e. a fake window that will accept the dropping of widgets" # called from "add slot" context menu handler of sizer # called from XML parser for adding empty 'sizerslot': sizer._add_slot(loading=True) slot = SizerSlot(self, len(self.children)) if "rows" in self.PROPERTIES: self._adjust_rows_cols(loading) # for GridSizer if self.widget: slot.create() return slot def _insert_slot(self, index=None): "Inserts an empty slot into the sizer at pos (1 based); optionally force layout update" # called from context menu handler; multiple times if applicable; layout will be called there # also called from SizerBase._remove after a sizer has removed itself and inserts an empty slot instead if index>=len(self.children) or not self.children[index] is None: self.children.insert( index, None) # placeholder to be overwritten slot = SizerSlot(self, index) if "rows" in self.PROPERTIES: self._adjust_rows_cols() # for GridSizer if self.widget: slot.create() return slot # insert/add slot callbacks for context menus ###################################################################### def _ask_count(self, insert=True): # helper for next method (insertion/adding of multiple slots) choices = [str(n) for n in range(1,11)] if insert: dlg = wx.SingleChoiceDialog(None, "Select number of slots to be inserted", "Insert Slots", choices) else: dlg = wx.SingleChoiceDialog(None, "Select number of slots to be added", "Add Slots", choices) ret = 0 if dlg.ShowModal()==wx.ID_CANCEL else int(dlg.GetStringSelection()) dlg.Destroy() return ret def insert_slot(self, index, multiple=False): # insert before current if not self._can_add_insert_slots(report=True): return count = self._ask_count() if multiple else 1 if not count: return with self.window.frozen(): for n in range(count): slot = self._insert_slot(index) if self.widget: self.layout() common.history.sizer_slots_added(self, index, count) misc.rebuild_tree(slot, recursive=False) def add_slot(self, multiple=False): # add to the end if not self._can_add_insert_slots(report=True): return count = self._ask_count(insert=False) if multiple else 1 if not count: return with self.window.frozen(): for n in range(count): slot = self._add_slot() if self.widget: self.layout() common.history.sizer_slots_added(self, -1, count) misc.rebuild_tree(slot, recursive=False) # rebuild also slots @_frozen def _free_slot(self, index): "Replaces the element at index with an empty slot" # called from ManagedBase context menu when removing an item slot = SizerSlot(self, index) if self.widget: slot.create() # create the actual SizerSlot as wx.Window with hatched background if self._IS_GRIDBAG: self._check_slots(add_only=True) self.layout() return slot #################################################################################################################### def is_visible(self): return self.window.is_visible() def post_load(self): """Called after loading of an app from a XML file, before showing the hierarchy of widget for the first time. This is used only for container widgets, to adjust their size appropriately.""" if "rows" in self.PROPERTIES: self._adjust_rows_cols() # for GridSizer if not self.toplevel: return size_p = self.window.properties['size'] if not size_p.is_active(): self.fit_parent() w, h = self.widget.GetSize() postfix = '' if config.preferences.use_dialog_units: w, h = compat.ConvertPixelsToDialog( self.window.widget, self.widget.GetSize() ) postfix = 'd' size_p.set('%s, %s%s' % (w, h, postfix)) def child_widgets_created(self, level): # called after (all) child widgets have been created or a single one has been added if "rows" in self.PROPERTIES: self._adjust_rows_cols() # for GridSizer if not self.toplevel: return size_p = self.window.properties['size'] if not size_p.is_active(): self.fit_parent() w, h = self.widget.GetSize() postfix = '' if config.preferences.use_dialog_units: w, h = compat.ConvertPixelsToDialog( self.window.widget, self.widget.GetSize() ) postfix = 'd' size_p.set('%s, %s%s' % (w, h, postfix)) def _get_tree_image(self): "Get an image name for tree display" name = self.__class__.__name__ if name in ("EditStaticBoxSizer", "EditBoxSizer"): # with or without label, horizontal/vertical if self.orient & wx.VERTICAL: name = "EditVerticalSizer" elif self.orient & wx.HORIZONTAL: name = "EditHorizontalSizer" else: name = "EditSpacer" elif name=="EditWrapSizer": if self.orient & wx.VERTICAL: name = "EditVerticalWrapSizer" else: name = "EditHorizontalWrapSizer" return name class wxGladeBoxSizer(wx.BoxSizer): _BTN_OFFSET = 1 def SetItemMinSize(self, item, w, h): if w==-1 or h==-1: try: w2, h2 = item.GetBestSize() if w == -1: w = w2 if h == -1: h = h2 except AttributeError: pass wx.BoxSizer.SetItemMinSize(self, item, w, h) class BoxSizerBase(SizerBase): "orientation handling for BoxSizer and StaticBoxSizer" def __init__(self, name, parent, index, orient=wx.VERTICAL, elements=0): # elements: number of slots SizerBase.__init__(self, name, parent, index, orient) self.children = [] for i in range(elements): self._add_slot() def get_class_orient(self): return '%s (%s)'%( self.WX_CLASS, self.properties["orient"].get_string_value() ) def _check_flags(self, flags, added=None): excludes = set() replace = {} msg = None if "wxALIGN_RIGHT" in flags and ("wxALIGN_CENTER" in flags or "wxALIGN_CENTER_HORIZONTAL" in flags): msg = "Multiple conflicting horizontal alignment flags" if "wxALIGN_CENTER" in flags: replace["wxALIGN_CENTER"] = None if "wxALIGN_CENTER_HORIZONTAL" in flags: replace["wxALIGN_CENTER_HORIZONTAL"] = None if "wxALIGN_BOTTOM" in flags and ("wxALIGN_CENTER" in flags or "wxALIGN_CENTER_VERTICAL" in flags): msg = "Multiple conflicting vertical alignment flags" if "wxALIGN_CENTER" in flags: replace["wxALIGN_CENTER"] = None if "wxALIGN_CENTER_VERTICAL" in flags: replace["wxALIGN_CENTER_VERTICAL"] = None if self.orient==wx.VERTICAL: excludes = {"wxALIGN_BOTTOM", "wxALIGN_CENTER_VERTICAL", "wxALIGN_CENTER"} if "wxALIGN_BOTTOM" in flags or "wxALIGN_CENTER_VERTICAL" in flags or "wxALIGN_CENTER" in flags: msg = "Vertical alignment flags are ignored in vertical sizers" if "wxALIGN_BOTTOM" in flags: replace["wxALIGN_BOTTOM"] = None if "wxALIGN_CENTER_VERTICAL" in flags: replace["wxALIGN_CENTER_VERTICAL"] = None if "wxALIGN_CENTER" in flags: replace["wxALIGN_CENTER"] = "wxALIGN_CENTER_HORIZONTAL" # Note that using alignment with wxEXPAND can make sense if wxSHAPED is also used, # as the item doesn't necessarily fully expand in the other direction in this case. if "wxEXPAND" in flags and not "wxSHAPED" in flags: if "wxALIGN_RIGHT" in flags or "wxALIGN_CENTER_HORIZONTAL" in flags or "wxALIGN_CENTER" in flags: msg = "Horizontal alignment flags are ignored with wxEXPAND" if "wxALIGN_RIGHT" in flags: replace["wxALIGN_RIGHT"] = None if "wxALIGN_CENTER_HORIZONTAL" in flags: replace["wxALIGN_CENTER_HORIZONTAL"] = None if "wxALIGN_CENTER" in flags: replace["wxALIGN_CENTER"] = "wxALIGN_CENTER_VERTICAL" excludes.update({"wxALIGN_RIGHT", "wxALIGN_CENTER_HORIZONTAL", "wxALIGN_CENTER"}) else: # horizontal excludes = {"wxALIGN_RIGHT", "wxALIGN_CENTER_HORIZONTAL", "wxALIGN_CENTER"} if "wxALIGN_RIGHT" in flags or "wxALIGN_CENTER_HORIZONTAL" in flags or "wxALIGN_CENTER" in flags: msg = "Horizontal alignment flags are ignored in horizontal sizers" if "wxALIGN_RIGHT" in flags: replace["wxALIGN_RIGHT"] = None if "wxALIGN_CENTER_HORIZONTAL" in flags: replace["wxALIGN_CENTER_HORIZONTAL"] = None if "wxALIGN_CENTER" in flags: replace["wxALIGN_CENTER"] = "wxALIGN_CENTER_VERTICAL" if "wxEXPAND" in flags and not "wxSHAPED" in flags: if "wxALIGN_BOTTOM" in flags or "wxALIGN_CENTER_VERTICAL" in flags or "wxALIGN_CENTER" in flags: msg = "Vertical alignment flags are ignored with wxEXPAND" if "wxALIGN_BOTTOM" in flags: replace["wxALIGN_BOTTOM"] = None if "wxALIGN_CENTER_VERTICAL" in flags: replace["wxALIGN_CENTER_VERTICAL"] = None if "wxALIGN_CENTER" in flags: replace["wxALIGN_CENTER"] = "wxALIGN_CENTER_HORIZONTAL" excludes.update( {"wxALIGN_BOTTOM", "wxALIGN_CENTER_VERTICAL", "wxALIGN_CENTER"} ) return excludes, replace, msg def _properties_changed(self, modified, actions): if modified and "orient" in modified: actions.add("image") SizerBase._properties_changed(self, modified, actions) class EditBoxSizer(BoxSizerBase): "Class to handle wxBoxSizer objects" WX_CLASS = "wxBoxSizer" def create_widget(self): BoxSizerBase.create_widget(self) self.widget = wxGladeBoxSizer(self.orient) self.widget.Add(self._btn, 0, wx.EXPAND) if HAVE_WRAP_SIZER: class wxGladeWrapSizer(wx.WrapSizer): _BTN_OFFSET = 1 def SetItemMinSize(self, item, w, h): if w==-1 or h==-1: try: w2, h2 = item.GetBestSize() if w == -1: w = w2 if h == -1: h = h2 except AttributeError: pass wx.BoxSizer.SetItemMinSize(self, item, w, h) class EditWrapSizer(BoxSizerBase): "Class to handle wxWrapSizer objects" WX_CLASS = "wxWrapSizer" def create_widget(self, dont_add=False): BoxSizerBase.create_widget(self) self.widget = wxGladeWrapSizer(self.orient) self.widget.Add(self._btn, 0, wx.EXPAND) class EditStdDialogButtonSizer(EditBoxSizer): "Class to handle wxStdDialogButtonSizer objects" WX_CLASS = "wxStdDialogButtonSizer" # the stockitems that are handled specially by StdDialogButtonSizer BUTTON_STOCKITEMS = ["OK", "YES", "SAVE", "APPLY", "CLOSE","NO", "CANCEL", "HELP", "CONTEXT_HELP"] def __init__(self, name, parent, index, elements=0): # elements: number of slots BoxSizerBase.__init__(self, name, parent, index, wx.HORIZONTAL, elements) def get_class_orient(self): return self.WX_CLASS class wxGladeStaticBoxSizer(wx.StaticBoxSizer): _BTN_OFFSET = 1 def reparenting(self, new_parent): sb = self.GetStaticBox() sb.Reparent(new_parent) def SetItemMinSize(self, item, w, h): if w==-1 or h==-1: try: w2, h2 = item.GetBestSize() if w == -1: w = w2 if h == -1: h = h2 except AttributeError: pass wx.StaticBoxSizer.SetItemMinSize(self, item, w, h) class EditStaticBoxSizer(BoxSizerBase): "Class to handle wxStaticBoxSizer objects" WX_CLASS = "wxStaticBoxSizer" PROPERTIES = ["Common", "name", "orient", "class_orient", # class and orient are hidden "label", "attribute", "Layout"] # not a property, just start the next page in the editor EXTRA_PROPERTIES = [] def __init__(self, name, parent, index, orient=wx.VERTICAL, label='', elements=3): BoxSizerBase.__init__(self, name, parent, index, orient, elements) self.label = np.TextProperty(label) def create_widget(self): BoxSizerBase.create_widget(self) self.widget = wxGladeStaticBoxSizer( wx.StaticBox(self.window.widget, -1, self.label), self.orient ) self.widget.Add(self._btn, 0, wx.EXPAND) def _properties_changed(self, modified, actions): if not modified or "label" in modified and self.widget: self.widget.GetStaticBox().SetLabel(self.label or "") BoxSizerBase._properties_changed(self, modified, actions) def destroy_widget(self, level): if self.widget: self.widget.GetStaticBox().Destroy() SizerBase.destroy_widget(self, level) class CustomGridSizer(wx.BoxSizer): """Custom wxSizer class used to implement a GridSizer with an additional handle button. e.g. in EditGridSizer instance: self.widget = CustomGridSizer(self,rows,cols,vgap,hgap""" _BTN_OFFSET = 0 def __init__(self, parent, rows, cols, vgap, hgap): wx.BoxSizer.__init__(self, wx.VERTICAL) self.parent = parent # EditGridSizer or derived class self._create(rows, cols, vgap, hgap) wx.BoxSizer.Add(self, self.parent._btn, 0, wx.EXPAND) wx.BoxSizer.Add(self, self._grid, 1, wx.EXPAND) if wx.VERSION[:2] < (3,0): self._growable_rows = set() self._growable_cols = set() def _create(self, rows, cols, vgap, hgap): self._grid = wx.GridSizer(rows, cols, vgap, hgap) def __getattr__(self, name): return getattr(self._grid, name) def reparenting(self, new_parent): if self.parent._btn: self.parent._btn.Reparent(new_parent) def GetBestSize(self): return self._grid.GetMinSize() def Add(self, *args, **kwds): self._grid.Add(*args, **kwds) def Insert(self, index, *args, **kwds): self._grid.Insert(index, *args, **kwds) def Remove(self, *args, **kwds): try: index = int(args[0]) self._grid.Remove(index) except TypeError: self._grid.Remove(*args, **kwds) def RemovePos(self, index): self._grid.Remove(index) def Detach(self, pos_or_obj): try: index = int(pos_or_obj) self._grid.Detach(index) except TypeError: self._grid.Detach(pos_or_obj) def SetItemMinSize(self, item, w, h): try: w2, h2 = item.GetBestSize() if w == -1: w = w2 if h == -1: h = h2 except AttributeError: pass self._grid.SetItemMinSize(item, w, h) def GetChildren(self): return self._grid.GetChildren() def GetItem(self, widget): if hasattr(self._grid, "FindItem"): return self._grid.FindItem(widget) # GridBagSizer return self._grid.GetItem(widget) def Layout(self): self._grid.Layout() wx.BoxSizer.Layout(self) if wx.VERSION[:2] < (3,0): # compatibility for wxPython 2.8, as IsRowGrowable was only introduced with wx 2.9.1 def IsRowGrowable(self, row): return row in self._growable_rows def IsColGrowable(self, col): return col in self._growable_cols def AddGrowableRow(self, row): self._grid.AddGrowableRow(row) self._growable_rows.add(row) def RemoveGrowableRow(self, row): self._grid.RemoveGrowableRow(row) self._growable_rows.remove(row) def AddGrowableCol(self, col): self._grid.AddGrowableCol(col) self._growable_cols.add(col) def RemoveGrowableCol(self, col): self._grid.RemoveGrowableCol(col) self._growable_cols.remove(col) class CustomFlexGridSizer(CustomGridSizer): def _create(self, rows, cols, vgap, hgap): self._grid = wx.FlexGridSizer(rows, cols, vgap, hgap) class CustomGridBagSizer(CustomFlexGridSizer): def _create(self, rows, cols, vgap, hgap): self._grid = wx.GridBagSizer(vgap, hgap) def Add(self, widget, pos, span, flag, border, destroy=False): "Add to sizer, re-use existing SizerItem if there is one; pos is (row,col)" if isinstance(pos, int): pos = self.parent._get_row_col(pos) old_sizer_item = self._grid.FindItemAtPosition(pos) if old_sizer_item: if destroy: old_window = old_sizer_item.GetWindow() if old_window: compat.DestroyLater(old_window) old_sizer_item.SetSpan((1,1)) old_sizer_item.SetFlag(wx.EXPAND) old_sizer_item.SetBorder(border) if isinstance(widget, wx.Sizer): old_sizer_item.AssignSizer(widget) else: old_sizer_item.AssignWindow(widget) else: self._grid.Add( widget, pos, span, flag, border ) def Detach(self, obj): self._grid.Detach(obj) class GridSizerBase(SizerBase): "Base class for Grid sizers" _PROPERTY_HELP = {"rows":"Number of sizer rows; can be set to 0 for 'as many as required'.\n" "This will re-arrange the children and empty slots, but not add/remove slots.\n" "To insert/add rows, better use the context menu items", "cols":"Number of sizer columns; can be set to 0 for 'as many as required'.\n" "This will re-arrange the children and empty slots, but not add/remove slots.\n" "To insert/add columns, better use the context menu items", "vgap":'Vertical extra space between all children', "hgap":'Horizontal extra space between all children'} EXTRA_PROPERTIES = ["Grid", "rows", "cols", "vgap", "hgap"] def __init__(self, name, parent, index, rows=3, cols=3, vgap=0, hgap=0): SizerBase.__init__(self, name, parent, index, None) if self.WX_CLASS == "wxGridBagSizer": val_range=(1,1000) else: # Grid and FlexGrid sizers allow columns/rows to be 0, i.e. as many as required val_range=(0,1000) self.rows = np.SpinProperty(rows, val_range=val_range, immediate=True) self.cols = np.SpinProperty(cols, val_range=val_range, immediate=True) self.vgap = np.SpinProperty(vgap, immediate=True) self.hgap = np.SpinProperty(hgap, immediate=True) def fit_parent(self, *args): "Tell the sizer to resize the window to match the sizer's minimal size" if self.widget and self.window.widget: self.widget.Fit(self.window.widget) self.widget.SetSizeHints(self.window.widget) def _can_add_insert_slots(self, report=False): if self.rows and self.cols and len(self.children)==self.rows*self.cols: # if both are defined, a re-sizing would need to be done if report: misc.error_message("Can't add or insert slots as sizer's Rows and Cols are fixed (see Properties -> Grid).") return False return True # helpers ########################################################################################################## def _get_actual_rows_cols(self): rows = self.rows cols = self.cols # for GridSizer and FlexGridSizer cols may be 0, i.e. auto calculated if cols==0: cols = (len(self.children)-1)//rows + 1 elif rows==0: rows = (len(self.children)-1)//cols + 1 return rows, cols def _get_row_col(self, index, cols=None): if cols is None: rows, cols = self._get_actual_rows_cols() return index // cols, index % cols def _get_pos(self, row, col): rows, cols = self._get_actual_rows_cols() return row*cols + col def _adjust_rows_cols(self, loading=False): # called when items are added or removed: adjust number of rows cols_p = self.properties["cols"] rows_p = self.properties["rows"] if rows_p.value==0 or cols_p.value==0: return rows_new = (len(self.children)-1) // cols_p.get() + 1 if rows_new==rows_p.value or (loading and rows_new=row_or_col_count: return None # number out of range except: return None return value def _convert_to_text(self, value): # from internal 0-based string value to text control 1-based: "0,1" -> "1,2" ret = [str(n+1) for n in self.value] return ",".join(ret) def get_string_value(self): # for XML file writing return ",".join( [str(n) for n in self.value] ) def remove_item(self, item): # called when a column is deleted if not self.value: return new = [] for n in self.value: if n!=item: if n=len(self.children): #max_col = c max_col = self.cols-1 break child = self.children[p] if not isinstance(child, SizerSlot): break if inserting and child.overlapped: break if p>=len(self.children) or not isinstance(child, SizerSlot): break if inserting and child.overlapped: break # only empty cells found max_col = c # check max rowspan max_row = row for r in range(row+1, self.rows): for c in range(col, col+colspan): # check cell content p = self._get_pos(r,c) if p>=len(self.children): #max_row = r max_row = self.rows-1 break child = self.children[p] if not isinstance(child, SizerSlot): break if inserting and child.overlapped: break if p>=len(self.children) or not isinstance(child, SizerSlot): break if inserting and child.overlapped: break # only empty cells found max_row = r return max_row-row+1, max_col-col+1 def _get_occupied_slots(self): "get pos for all slots that are SizerSlots only, but are occupied by other items spanning over rows/cols" index = 0 occupied = [] rows, cols = self._get_actual_rows_cols() for row in range(rows): for col in range(cols): if index==len(self.children): break child = self.children[index] if not isinstance(child, SizerSlot) and not child is None: # an element, check whether it spans over any slots span = child.span if span != (1,1): for r in range(row, row+span[0]): for c in range(col, col+span[1]): if r==row and c ==col: continue # the original cell if c>=self.cols: continue occupied.append( self._get_pos(r,c) ) index += 1 if index==len(self.children): break return occupied def _get_max_row_col(self): "get last row and col indices that are populated or spanned; for use by rows/cols properties" max_row = max_col = 0 for index, child in enumerate(self.children): row, col = self._get_row_col(index) if not isinstance(child, SizerSlot) and not child is None: span = child.span max_row = max( max_row, row + span[0] - 1 ) max_col = max( max_col, col + span[1] - 1 ) return max_row, max_col def _check_slots(self, remove_only=False, add_only=False, add_to_sizer=True): "add/remove the widgets for empty slots" occupied = set( self._get_occupied_slots() ) for index,child in enumerate(self.children): if isinstance(child, SizerSlot): if index in occupied: if not add_only: child.set_overlap(True, add_to_sizer=add_to_sizer) else: if not remove_only: child.set_overlap(False, add_to_sizer=add_to_sizer) def _can_add_insert_slots(self, report=False): if report: misc.error_message("Can't insert or add slots as sizer's Rows and Cols are fixed (see Properties -> Grid).") return False def get_child_index(self, index): # return the index of the widget; overlapped slots are skipped ret = 0 for p, child in enumerate(self.children): if child is None or (isinstance(child, SizerSlot) and child.overlapped): continue if p==index: return ret ret += 1 # context menu actions ############################################################################################# @_frozen # if _frozen is used, this should be called via wx.CallAfter def _recreate(self, rows, cols, previous_rows, previous_cols): "rows, cols: list of indices to keep or None for new rows/cols" if rows is None: rows = [r if r