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()
