def change_absolute_track_position_on_splitter(self, track_uid, new_pos): UIM = UIManager() track = UIM.get(track_uid) # tlc = track._get_label_controller() tcc = track._get_canvas_controller() # self._tracks_panel.top_splitter.ChangeWindowPosition(tlc.view, new_pos) self._tracks_panel.bottom_splitter.ChangeWindowPosition( tcc.view, new_pos)
def PostInit(self): UIM = UIManager() controller = UIM.get(self._controller_uid) controller.subscribe(self.set_xlim, 'change.left_scale') controller.subscribe(self.set_xlim, 'change.right_scale') controller.subscribe(self.set_thickness, 'change.thickness') controller.subscribe(self.set_color, 'change.color') controller.subscribe(self.set_zorder, 'change.zorder') controller.subscribe(self.on_change_xscale, 'change.x_scale') controller.subscribe(self.on_change_interpolate, 'change.interpolate')
def _set_float_mode(self, new_value, old_value): UIM = UIManager() controller = UIM.get(self._controller_uid) parent_uid = UIM._getparentuid(controller.uid) if new_value: controller.unsubscribe(self._set_title, 'change.title') controller.unsubscribe(self._set_pos, 'change.pos') fc = UIM.create('frame_controller', parent_uid, title=controller.title ) UIM.reparent(self._controller_uid, fc.uid) fc.view.Show() else: mwc_uid = UIM._getparentuid(parent_uid) mwc = UIM.get(mwc_uid) UIM.reparent(self._controller_uid, mwc.uid) UIM.remove(parent_uid) controller.subscribe(self._set_title, 'change.title') controller.subscribe(self._set_pos, 'change.pos')
def on_change_width(self, new_value, old_value): UIM = UIManager() parent_uid = UIM._getparentuid(self.uid) parent_ctrl = UIM.get(parent_uid) parent_ctrl.view._do_change_width(self.get_position(False), self.width ) if not self.selected: return parent_ctrl._change_width_for_selected_tracks(self.uid)
def set_picked(self, new_value, old_value): # print('set_picked:', new_value) if len(self._mplot_objects.values()) == 0: self.draw() if new_value: self._mplot_objects['line'].set_color(self._picked_color) else: UIM = UIManager() controller = UIM.get(self._controller_uid) self._mplot_objects['line'].set_color(controller.color) self.draw_canvas()
def PostInit(self): self._depth_canvas = None UIM = UIManager() controller = UIM.get(self._controller_uid) self.adjust_scale_xlim(controller.xscale) super().PostInit() self.set_ygrid_major_lines(controller.ygrid_major_lines) self.set_ygrid_minor_lines(controller.ygrid_minor_lines) if controller.xscale == 'log': self.set_locator('log', 'x', 'major', numdecs=controller.decades) wx.CallAfter(self.set_plotgrid, controller.plotgrid)
def adjust_scale_xlim(self, scale): UIM = UIManager() controller = UIM.get(self._controller_uid) if scale == 'linear': controller.xlim = LINEAR_XLIM elif scale == 'log': min_ = controller.leftscale max_ = controller.leftscale*10.0**controller.decades + \ XMAX_PLUS controller.xlim = (min_, max_)
def change_track_position(self, track_uid, old_pos, new_pos): """ Change track position. :class:`~GRIPy-3.ui.mvc_classes.TrackController` Parameters ---------- track_uid : :class:`~GRIPy-3.ui.mvc_classes.TrackController` uid. The track identificator. labelpad : scalar, optional, default: None Spacing in points between the label and the x-axis. """ UIM = UIManager() track_pos = UIM.get(track_uid) pos = old_pos # if new_pos == self.view.get_adjusted_absolute_track_position( track_pos.uid): return if new_pos < old_pos: while pos > new_pos: tracks_next_pos = UIM.exec_query('track_controller', self.uid, 'pos=' + str(pos - 1)) if track_pos in tracks_next_pos: tracks_next_pos.remove(track_pos) if len(tracks_next_pos) == 0: return track_next_pos = tracks_next_pos[0] if not track_pos.overview and not track_next_pos.overview: if new_pos != self.view.get_track_position( track_pos.uid, False): self.view.change_absolute_track_position_on_splitter( track_pos.uid, new_pos) track_next_pos.pos += 1 pos -= 1 else: while pos < new_pos: tracks_next_pos = UIM.exec_query('track_controller', self.uid, 'pos=' + str(pos + 1)) if track_pos in tracks_next_pos: tracks_next_pos.remove(track_pos) if len(tracks_next_pos) == 0: return track_next_pos = tracks_next_pos[0] if not track_pos.overview and not track_next_pos.overview: if new_pos != self.view.get_track_position( track_pos.uid, False): self.view.change_absolute_track_position_on_splitter( track_pos.uid, new_pos) track_next_pos.pos -= 1 pos += 1
def reparent(self, old_parent_uid, new_parent_uid): UIM = UIManager() old_parent_controller = UIM.get(old_parent_uid) new_parent_controller = UIM.get(new_parent_uid) if old_parent_controller.tid == 'main_window_controller': try: ret_val = old_parent_controller.remove_notebook_page(self) self.Reparent(new_parent_controller.view) except Exception as e: print('ERROR:', e) else: # Then old_parent_controller is a Frame self.Reparent(new_parent_controller.view) controller = UIM.get(self._controller_uid) ret_val = new_parent_controller.insert_notebook_page( controller.pos, self, controller.title, True ) return ret_val
def __init__(self, controller_uid): UIViewObject.__init__(self, controller_uid) _UIM = UIManager() controller = _UIM.get(self._controller_uid) if controller.id == wx.ID_ANY: controller.id = _UIM.new_wx_id() try: wx.MenuItem.__init__(self, None, controller.id, controller.label, controller.help, controller.kind) except Exception as e: print(e) raise
def get_track_on_position(self, pos, relative_position=True): if pos == -1: return self.get_overview_track() b_splitter = self._tracks_panel.bottom_splitter if relative_position: pos = b_splitter.get_windows_indexes_shown()[pos] bottom_window = b_splitter.GetWindow(pos) UIM = UIManager() for tcc in UIM.list('track_canvas_controller'): if tcc.view == bottom_window: track_ctrl_uid = UIM._getparentuid(tcc.uid) return UIM.get(track_ctrl_uid) raise Exception('Informed position [{}] is invalid.'.format(pos))
def _increment_tracks_positions(self, pos, exclude_track_uid=None): """ From position on, increment Tracks positions by 1. When a new :class:`~GRIPy-3.ui.mvc_classes.TrackController` object is created, others Tracks with position equal or greater must have their positions incremented by 1. It is done in a silent way (not generating :class:`~GRIPy-3.ui.mvc_classes.TrackModel` events), because the overview Track keep its original position. Parameters ---------- pos: int First position to be incremented. exclude_track_uid: :class:`~GRIPy-3.ui.mvc_classes.TrackController` uid, optional. If given, exclude the Track to have position incremented. """ UIM = UIManager() controller = UIM.get(self._controller_uid) if pos >= len(controller): return tracks_affected = UIM.exec_query('track_controller', self._controller_uid, 'pos>=' + str(pos)) # There is only one Track and it should be the "exclude_track" if len(tracks_affected) == 1: return # else: if exclude_track_uid: exclude_track = UIM.get(exclude_track_uid) tracks_affected.remove(exclude_track) for track in tracks_affected: # Silent way - not generating model events. track.set_value_from_event('pos', track.pos + 1)
def set_scale_lines(self, value): if value <= 0: raise ValueError('Wrong value for scale_lines. ' + \ 'Valid values are > 0.') UIM = UIManager() controller = UIM.get(self._controller_uid) if controller.xscale == 'linear' and controller.plotgrid: x0, x1 = LINEAR_XLIM x1 -= XMAX_PLUS x_major_grid_lines = (x1 - x0) / value # TODO: Verificar Locators self.set_locator('multiple', 'x', 'major', x_major_grid_lines) controller.xgrid_major = True
def PostInit(self): UIM = UIManager() controller = UIM.get(self._controller_uid) controller.subscribe(self._draw, 'change.step') controller.subscribe(self._draw, 'change.pos_x') controller.subscribe(self._draw, 'change.ha') controller.subscribe(self._draw, 'change.va') controller.subscribe(self._draw, 'change.fontsize') controller.subscribe(self._draw, 'change.color') controller.subscribe(self._draw, 'change.bbox') controller.subscribe(self._draw, 'change.bbox_style') controller.subscribe(self._draw, 'change.bbox_color') controller.subscribe(self._draw, 'change.bbox_alpha') controller.subscribe(self._draw, 'change.zorder')
def check_change(self, name, old_value, new_value): if not callable(self._trigger_func): return kwargs = {} if self._trigger_kwargs_keys: UIM = UIManager() dialog = UIM.get(self._controller_uid) for enc_ctrl_name in self._trigger_kwargs_keys: enc_control = dialog.view.get_object(enc_ctrl_name) try: kwargs[enc_control.name] = enc_control.get_value() except: raise self._trigger_func(name, old_value, new_value, **kwargs)
def PostInit(self): # log.debug('{}.PostInit started'.format(self.name)) UIM = UIManager() controller = UIM.get(self._controller_uid) parent_controller_uid = UIM._getparentuid(self._controller_uid) parent_controller = UIM.get(parent_controller_uid) # if isinstance(parent_controller, MenuController): if controller.pos == -1: # Appending - Not needed to declare pos controller.pos = parent_controller.view.GetMenuItemCount() if controller.pos > parent_controller.view.GetMenuItemCount(): # If pos was setted out of range for inserting in parent Menu msg = 'Invalid position for Menu with label={}. Position will be setting to {}'.format( controller.label, parent_controller.view.GetMenuItemCount()) log.warning(msg) controller.pos = parent_controller.view.GetMenuCount() parent_controller.view.Insert(controller.pos, controller.id, controller.label, self, controller.help) elif isinstance(parent_controller, MenuBarController): if controller.pos == -1: # Appending - Not needed to declare pos controller.pos = parent_controller.view.GetMenuCount() if controller.pos > parent_controller.view.GetMenuCount(): # If pos was setted out of range for inserting in parent Menu msg = 'Invalid position for Menu with label={}. Position will be setting to {}'.format( controller.label, parent_controller.view.GetMenuCount()) log.warning(msg) controller.pos = parent_controller.view.GetMenuCount() ret_val = parent_controller.view.Insert(controller.pos, self, controller.label) if not ret_val: raise Exception() else: raise Exception()
def _OnSetZAxis(self, event): UIM = UIManager() controller = UIM.get(self._controller_uid) ymin, ymax = controller.wellplot_ylim z_start_str = self._tool_bar.z_start.GetValue() z_end_str = self._tool_bar.z_end.GetValue() ok = True if not round(float(z_start_str), 2) >= round(ymin, 2): self._tool_bar.z_start.SetValue(z_start_str) ok = False if not round(float(z_end_str), 2) <= round(ymax, 2): self._tool_bar.z_start.SetValue(z_end_str) ok = False if ok: controller.shown_ylim = (float(z_start_str), float(z_end_str))
def _get_wx_parent(self, *args): flag = args[0] # print ('\nTrackView._get_wx_parent', flag) """ """ UIM = UIManager() controller = UIM.get(self._controller_uid) parent_controller_uid = UIM._getparentuid(self._controller_uid) parent_controller = UIM.get(parent_controller_uid) try: if flag.startswith('track_canvas'): # For tids track_canvas_controller, # canvas_track_model and canvas_track. if controller.overview: return parent_controller._get_wx_parent('overview') else: return parent_controller._get_wx_parent('track') elif flag.startswith('track_label'): # For tids canvas_label_controller, # canvas_label_model and canvas_label. return parent_controller._get_wx_parent('label') return parent_controller._get_wx_parent(flag) except: raise
def PostInit(self): log.debug('{}.AfterInit started'.format(self.name)) UIM = UIManager() main_window = wx.App.Get().GetTopWindow() # DetachPane if granpa object has a AuiManager... parent_uid = UIM._getparentuid(self.uid) grampa_uid = UIM._getparentuid(parent_uid) parent = UIM.get(parent_uid) grampa = UIM.get(grampa_uid) if isinstance(grampa, MainWindowController): mgr = wx.aui.AuiManager.GetManager(main_window) if mgr is not None: mgr.DetachPane(parent.view) if self.pos == -1: # Appending - Not needed to declare pos self.pos = parent.view.GetToolsCount() if self.pos > parent.view.GetToolsCount(): # If pos was setted out of range for inserting in parent Menu msg = 'Invalid tool position for ToolBarTool with text={}. Position will be setting to {}'.format( self.label, parent.view.GetToolsCount()) logging.warning(msg) self.pos = parent.view.GetToolsCount() bitmap = GripyBitmap(self.bitmap) # TODO: Rever isso try: tool = parent.view.InsertTool(self.pos, self.id, self.label, bitmap, wx.NullBitmap, self.kind, self.help, self.long_help, None) except Exception as e: msg = 'Error in creating ToolBarTool: ' + e logging.exception(msg) print('\n\n', msg) raise if self.callback and tool: main_window.Bind(wx.EVT_TOOL, self.callback, tool) parent.view.Realize() # AtachPane again if granpa object had it detached... if isinstance(grampa, MainWindowController): mgr.AddPane(parent.view, parent.view.paneinfo) mgr.Update() logging.debug('{}.AfterInit ended'.format(self.name))
def _get_sequence_number(self): """ Retorna o numero de ordem considerando a existencia de multiplos objetos do mesmo tipo. """ UIM = UIManager() controller = UIM.get(self._controller_uid) idx = 0 wpcs = UIM.list(self._controller_uid[0]) for wpc in wpcs: if wpc == controller: break if wpc.obj_uid == controller.obj_uid: idx += 1 idx += 1 return idx
def update_title(self, new_value, old_value): UIM = UIManager() controller = UIM.get(self._controller_uid) try: if controller.overview: return if not controller.label: splitter_pos = controller.get_position(relative_position=True) text = str(splitter_pos + 1) else: text = controller.label tlc = self._get_label_controller() tlc.title = text except Exception as e: print('ERROR @ Track.update_title:', e) raise
def __init__(self, controller_uid): UIViewObject.__init__(self, controller_uid) UIM = UIManager() parent_uid = UIM._getparentuid(self._controller_uid) parent_controller = UIM.get(parent_uid) wx_parent = parent_controller._get_wx_parent(self.tid) wx.Panel.__init__(self, wx_parent) # self.track_view_object = wx_parent self._visual_objects = [] self.SetBackgroundColour('white') self.SetSizer(wx.BoxSizer(wx.VERTICAL)) # self.Bind(wx.EVT_LEFT_DOWN, self._on_button_press) self.Bind(wx.EVT_MIDDLE_DOWN, self._on_button_press) self.Bind(wx.EVT_RIGHT_DOWN, self._on_button_press)
def end_dragging(self, canvas): if self._drag_mode != SASH_DRAG_DRAGGING: return self._drag_mode = SASH_DRAG_NONE self._old_y = None if self.track.HasCapture(): self.track.ReleaseMouse() # print 'mouse solto' y1 = self.d1_canvas.GetPosition()[1] y2 = self.d2_canvas.GetPosition()[1] #print 'y12:', y1, y2 if y1 <= y2: d1 = self.track.get_depth_from_ypixel(y1) d2 = self.track.get_depth_from_ypixel(y2 + self.canvas_width) # print 'considerando y12:', y1, y2 + self.canvas_width else: d1 = self.track.get_depth_from_ypixel(y2) d2 = self.track.get_depth_from_ypixel(y1 + self.canvas_width) # print 'considerando y12:', y2, y1 + self.canvas_width #print 'd12:', d1, d2 # UIM = UIManager() parent_controller_uid = UIM._getparentuid(self._controller_uid) parent_controller = UIM.get(parent_controller_uid) # #parent_controller.wellplot_ylim = (d1, d2) # parent_controller.set_value_from_event('shown_ylim', (d1, d2)) parent_controller._reload_ylim() # # #self._reload_depths_from_canvas_positions() #if self._callback: # self._callback(self.get_depth()) #print 'Send ' + str(self.get_depth()) + ' to callback...' canvas.SetBackgroundColour(self.canvas_color) canvas.Refresh() # #d1, d2 = self.get_depth() self.track.SetToolTip(wx.ToolTip('{0:.2f} - {1:.2f}'.format(d1, d2)))
def get_canvas(self): try: first_mpl_object = list(self._mplot_objects.values())[0] canvas = first_mpl_object.figure.canvas return canvas except: # TODO: Rever linhas abaixo # Getting from TrackController try: UIM = UIManager() toc_uid = UIM._getparentuid(self._controller_uid) track_controller_uid = UIM._getparentuid(toc_uid) track_controller = UIM.get(track_controller_uid) tcc = track_controller._get_canvas_controller() return tcc.view except: raise
def show_track(self, track_uid, show): UIM = UIManager() track = UIM.get(track_uid) if track.view.label: self._tracks_panel.top_splitter.ShowWindow(track.view.label, show) if not track.overview: self._tracks_panel.bottom_splitter.ShowWindow( track.view.track, show) else: raise Exception('show_track overview track???') tracks_affected = UIM.exec_query('track_controller', self._controller_uid, 'pos>=' + str(track.pos)) for track_affected in tracks_affected: if track_affected.uid != track.uid: #print 'track_affected.uid:', track_affected.uid track_affected.reload_track_title()
def set_plotgrid(self, value): UIM = UIManager() controller = UIM.get(self._controller_uid) self._postpone_draw = True if value: self.set_minorgrid(controller.minorgrid) self.set_scale_lines(controller.scale_lines) self.set_depth_lines(controller.depth_lines) else: controller.xgrid_major = False controller.xgrid_minor = False controller.ygrid_major = False controller.ygrid_minor = False controller.ytick_major_left = False controller.ytick_minor_left = False controller.ytick_major_right = False controller.ytick_minor_right = False self._postpone_draw = False
def get_track_position(self, track_uid, relative_position=True): UIM = UIManager() if UIM._getparentuid(track_uid) != self._controller_uid: raise Exception() track = UIM.get(track_uid) if track.overview: return -1 tcc = track._get_canvas_controller() #if relative_position: # return self._tracks_panel.bottom_splitter.GetVisibleIndexOf(bottom) #return self._tracks_panel.bottom_splitter.IndexOf(bottom) if relative_position: ret = self._tracks_panel.bottom_splitter.GetVisibleIndexOf( tcc.view) else: ret = self._tracks_panel.bottom_splitter.IndexOf(tcc.view) #print 'get_track_position({}, {}): {}'.format(track_uid, relative_position, ret) return ret
def remove_properties(self, obj_uid): # print('\n\n\nRemoving ALL properties for:', obj_uid) UIM = UIManager() parent_controller_uid = UIM._getparentuid(self.uid) parent_controller = UIM.get(parent_controller_uid) # TODO: Retirar isso daqui... if parent_controller.view.splitter.IsSplit(): parent_controller.view.splitter.Unsplit(self.view) # # if self._properties: obj = self._get_object(obj_uid) # print('self.view.GetPropertyValues():', self.view.GetPropertyValues()) for key, value in self._properties.items(): obj.unsubscribe(self.refresh_property, 'change.' + key) # self._properties.clear() self.view.Clear()
def __init__(self, controller_uid): try: UIViewObject.__init__(self, controller_uid) UIM = UIManager() parent_controller_uid = UIM._getparentuid(self._controller_uid) parent_controller = UIM.get(parent_controller_uid) wx_parent = parent_controller._get_wx_parent(self.tid) pg.PropertyGrid.__init__( self, wx_parent, style=pg.PG_SPLITTER_AUTO_CENTER # |\ # pg.PG_HIDE_MARGIN ) self.SetMarginColour('white') self.SetCaptionBackgroundColour(BLUE_COLORS_SCALE[2]) self.SetCaptionTextColour('white') except Exception as e: print('ERRO PropertyGridView.__init__:', e)
def fill_between(self, new_value, old_value): if new_value is None and old_value is None: return # if old_value is not None: self._remove_fillings() # fill_type = new_value UIM = UIManager() controller = UIM.get(self._controller_uid) # for idx_line in range(0, len(self._mplot_objects['wiggle']), 3): line = self._mplot_objects['wiggle'][idx_line] left_fill = self._mplot_objects['wiggle'][idx_line + 1] right_fill = self._mplot_objects['wiggle'][idx_line + 2] axis_center = self._lines_center[idx_line // 3] left_fill = None if fill_type == 'left' or fill_type == 'both': left_fill = self._my_fill( line.axes, line.get_ydata(), line.get_xdata(), axis_center, where=line.get_xdata() <= axis_center, facecolor=controller.fill_color_left, interpolate=True) right_fill = None if fill_type == 'right' or fill_type == 'both': xdata = line.get_xdata() right_fill = self._my_fill( line.axes, line.get_ydata(), xdata, axis_center, where=xdata >= axis_center, facecolor=controller.fill_color_right, interpolate=True) self._mplot_objects['wiggle'][idx_line + 1] = left_fill self._mplot_objects['wiggle'][idx_line + 2] = right_fill # self.draw_canvas()