from wxPython import wx import string from Numeric import * from numpy.core.umath import * import time from plot_utility import * from plot_objects import * from scipy.misc.common import lena def loop(): global bub bub.SetSize((400,400)) for i in range(20): #if bub.GetSizeTuple()[0] ==400: bub.SetSize((200,200)) #else: bub.SetSize((400,400)) #bub.client.layout_all() bub.client.draw_graph_area() # Issues: # -- Fix textobject.size() for non-90 degree rotations # -- Auto attributes haven't been fully thought through # -- Axis titles probably should be axis properties # This might save some current layout problems. # -- Little attention has been paid to round off errors. # Occassionly you'll see the consequences in a miss # placed grid line or slightly off markers, but overall # it's not so bad. # -- Could use a more sophisticated property setting scheme, # perhaps like graphite???? Anyway you can do bad things # such as assign a string instead of a text_object to # titles, etc. This is bad. Optional typing in future # Python would remove the need for fancy property type # checking system (I think). Hope it comes to pass... # -- This should be split up into several modules. Probably # a package. # -- Printing on windows does not print out line styles. # Everything is printed as solid lines. argh! # Update: This seems like an issue with calling dc.SetUserScale # If this isn't called, the problem is fixed - but the graph is # tiny!!! Should I work out the appropriate scaling in draw() # or should the SetUserScale() method maintain line types? # -- Print Preview scaling is not correct. Not sure why not, # but it looks lit the dc size is different the printer dc size. # How to fix? # -- Rotated text does not print with correct font type. Is this # a wxPython(windows) problem or mine? # -- Plot windows do not become top window when using gui_thread. # To Add: # -- Legend # -- MouseDown support for changing fonts from plot_utility import * #make this a box_object? aspect_ratios = ['normal', 'equal'] class plot_canvas(wx.wxWindow,property_object): _attributes = { 'background_color': ['light grey',colors,"Window background color" \ " Currently broken"], 'aspect_ratio': ['normal',aspect_ratios,"Set the axis aspect ratio"], 'hold': ['off',['on','off'],"Used externally for adding lines to plot"], } __type_hack__ = "plot_canvas" #background color is not working... def __init__(self, parent, id = -1, pos=wx.wxPyDefaultPosition, size=wx.wxPyDefaultSize, **attr): wx.wxWindow.__init__(self, parent, id, pos,size) wx.EVT_PAINT(self,self.on_paint) property_object.__init__(self, attr) background = wx.wxNamedColour(self.background_color) self.SetBackgroundColour(background) ##self.title = text_object('') ##self.x_title = text_object('') ##self.y_title = text_object('') self.title = text_window(self,'') self.x_title = text_window(self,'') self.y_title = text_window(self,'') self.all_titles = [self.title,self.x_title,self.y_title] #handy to have ##self.x_axis = axis_object(graph_location='above',rotate=0) ##self.y_axis = axis_object(graph_location='right',rotate=90) self.x_axis = axis_window(self,graph_location='above',rotate=0) self.y_axis = axis_window(self,graph_location='right',rotate=90) self.image_list = graphic_list() self.line_list = auto_line_list() # make this the data object. self.legend = legend_object() self.text_list = None # list of text objects to place on screen self.overlays = None # list of objects to draw on top of graph # (boxes, circles, etc.) ##self.y2_axis = axis_object(graph_location='left',rotate=90) self.client_size = (0,0) # zoom selection helpers self._mouse_selection = 0 self._mouse_selection_start = wx.wxPoint(0,0) self._mouse_selection_stop = wx.wxPoint(0,0) # mouse events wx.EVT_RIGHT_DOWN(self,self.on_right_down) wx.EVT_LEFT_DOWN(self, self.on_mouse_event) wx.EVT_LEFT_UP(self, self.on_mouse_event) wx.EVT_MOTION(self, self.on_mouse_event) wx.EVT_MOTION(self, self.on_mouse_event) wx.EVT_SIZE(self, self.update) # event handler def on_mouse_event(self, event): if event.LeftDown(): # start zoom selection self._mouse_selection_start = event.GetPosition() self._mouse_selection_stop = event.GetPosition() self._mouse_selection = 1 elif event.LeftUp() and self._mouse_selection: # zoom in self.zoom(event.GetPosition()) self._mouse_selection = 0 elif event.LeftIsDown() and self._mouse_selection: # update zoom selection self.rubberband(event.GetPosition()) else: pass def auto_zoom(self): # zoom to full scale # cannot call autoscale(), since validate_active() apparently # leads to a race condition:( self.x_axis.bounds = ['auto','auto'] self.y_axis.bounds = ['auto','auto'] self.x_axis.tick_interval = 'auto' self.y_axis.tick_interval = 'auto' self.update() def on_auto_zoom(self,event): self.auto_zoom() def on_paint(self, event): self.draw(wx.wxPaintDC(self)) def on_right_down(self,event): menu_found = 0 pos = event.GetX(),event.GetY() dc = wx.wxClientDC(self) for title in self.all_titles: title.set_dc(dc) # this dc stuff is a pain... if title.contains(pos): title.format_popup(pos) break menu_found = 1 title.clear_dc() if not menu_found: if self.x_axis.contains(pos,dc): self.x_axis.format_popup(pos) elif self.y_axis.contains(pos,dc): self.y_axis.format_popup(pos) else: self.format_popup(pos) def format_popup(self,pos): menu = wx.wxMenu() menu.Append(500, 'Auto Zoom', 'Auto Zoom') wx.EVT_MENU(self, 500, self.on_auto_zoom) menu.UpdateUI() self.PopupMenuXY(menu,pos[0],pos[1]) # workers def rubberband(self, new): """Delete previous selection band and paint new one.""" if self._mouse_selection: dc = wx.wxClientDC(self) dc.SetLogicalFunction(wx.wxXOR) dc.SetPen(wx.wxGREY_PEN) dc.SetBrush(wx.wxTRANSPARENT_BRUSH) diff = self._mouse_selection_stop - self._mouse_selection_start dc.DrawRectangle(self._mouse_selection_start.x, self._mouse_selection_start.y, diff.x, diff.y) self._mouse_selection_stop = new diff = self._mouse_selection_stop - self._mouse_selection_start dc.DrawRectangle(self._mouse_selection_start.x, self._mouse_selection_start.y, diff.x, diff.y) def save(self,path,image_type): w,h = self.GetSizeTuple() bitmap = wx.wxEmptyBitmap(w,h) dc = wx.wxMemoryDC() dc.SelectObject(bitmap) #self.update() # The background isn't drawn right without this cluge. #fill_color = get_color(self.background_color) fill_color = get_color('white') dc.SetPen(wx.wxPen(fill_color)) dc.SetBrush(wx.wxBrush(fill_color)) #how to handle transparency??? dc.DrawRectangle(0,0,w,h) dc.SetPen(wx.wxNullPen) dc.SetBrush(wx.wxNullBrush) # end cluge self.draw(dc) image = wx.wxImageFromBitmap(bitmap) wx.wxInitAllImageHandlers() image.SaveFile(path,image_type_map[image_type]) def layout_all(self,dc=None): #settingbackgroundcolors #background = wx.wxNamedColour(self.background_color) #if self.GetBackgroundColour() != background: # self.SetBackgroundColour(background) #self.Clear() # print 'refreshing' if not dc: dc = wx.wxClientDC(self) self.client_size = array(self.GetClientSizeTuple()) # set the device context for all titles so they can # calculate their size for text_obj in self.all_titles: text_obj.set_dc(dc) graph_area = box_object((0,0),self.client_size) graph_area.inflate(.95) # shrink box slightly # shrink graph area to make room for titles graph_area = self.layout_border_text(graph_area) # layout axis and graph data graph_area = self.layout_graph(graph_area,dc) # center titles around graph area. self.finalize_border_text(graph_area,dc) self.graph_box = graph_area # clear the dc for all titles # ? neccessary ? for text_obj in self.all_titles: text_obj.clear_dc() self.layout_data() #self.legend.layout(self.line_list,graph_area,dc) def layout_border_text(self,graph_area): # Shrink graph area to make room for titles. # Also, specify where the text is to live # in realation to the graph. This only # specifies one axis. The other can only # be specified after the final graph area # is calculated. margin = 4 graph_area.trim_top(self.title.height()+margin) graph_area.trim_bottom(self.x_title.height()+margin) self.y_title.rotate = 90 # make sure it is rotated graph_area.trim_left(self.y_title.width()+margin) #this is just to make so extra room for axis labels #on the x axis... graph_area.trim_right(12) return graph_area def layout_data(self): # get scale and offset axis_range = array((self.x_axis.range(),self.y_axis.range()),Float) # negative y to account for positve down in window coordinates scale = self.graph_box.size() / axis_range * array((1.,-1.)) offset = self.graph_to_window(array((0.,0.))) self.image_list.scale_and_shift(scale,offset) self.line_list.scale_and_shift(scale,offset) #self.legend #self.text_list #self.overlays def layout_graph(self,graph_area,dc): self.axes = [] #data_x_bounds,data_y_bounds = [0,6.28], [-1.1,1000] #jeez this is unwieldy code... smalls = []; bigs =[] if len(self.line_list): p1,p2 = self.line_list.bounding_box() smalls.append(p1);bigs.append(p2) if len(self.image_list): p1,p2 = self.image_list.bounding_box() smalls.append(p1);bigs.append(p2) if len(smalls): min_point = minimum.reduce(smalls) max_point = maximum.reduce(bigs) else: min_point = array((-1.,-1.),) max_point = array((1.,1.)) data_x_bounds = array((min_point[0],max_point[0])) data_y_bounds = array((min_point[1],max_point[1])) self.x_axis.calculate_ticks(data_x_bounds) height = self.x_axis.max_label_height(dc) graph_area.trim_bottom(height) self.y_axis.calculate_ticks(data_y_bounds) width = self.y_axis.max_label_width(dc) graph_area.trim_left(width) if self.aspect_ratio == 'equal': x_scale = float(graph_area.width()) / self.x_axis.range() y_scale = float(graph_area.height()) / self.y_axis.range() #print 'scales:', x_scale,y_scale,self.x_axis.range(),self.y_axis.range() if x_scale > y_scale: new_width = y_scale * self.x_axis.range() remove = .5 * (graph_area.width() - new_width) graph_area.trim_left(remove) graph_area.trim_right(remove) else: new_height = x_scale * self.y_axis.range() remove = .5 * (graph_area.height() - new_height) graph_area.trim_top(remove) graph_area.trim_bottom(remove) #self.y2_axis = axis_object(graph_location='left',rotate=90) #self.y2_axis.label_location = 'plus' #self.y2_axis.calculate_ticks(y2bounds) #width = self.y2_axis.max_label_width(dc) #graph_area.trim_right(width) self.x_axis.layout(graph_area,dc) self.x_axis.move((graph_area.left(),graph_area.bottom())) self.axes.append(self.x_axis) self.y_axis.layout(graph_area,dc) self.y_axis.move((graph_area.left(),graph_area.bottom())) self.axes.append(self.y_axis) #self.y2_axis.grid_color = 'wheat' #self.y2_axis.layout(graph_area,dc) #self.y2_axis.move((graph_area.right(),graph_area.bottom())) #self.axes.append(self.y2_axis) self.border = border_object() self.border.layout(graph_area,self.x_axis,self.y_axis) return graph_area def finalize_border_text(self,graph_area,dc): # Center the titles around the graph. # -- Really need to make axis object box_objects. # Use this to help determine more appropriate # title location. Current works fine # if axis labels are beside graph. Title # will be to far away if they are in center of graph margin = 4 if self.title: self.title.center_on_x_of(graph_area) self.title.above(graph_area,margin) if self.x_title: offset = self.x_axis.max_label_height(dc) self.x_title.center_on_x_of(graph_area) self.x_title.below(graph_area,margin + offset) if self.y_title: offset = self.y_axis.max_label_width(dc) self.y_title.center_on_y_of(graph_area) self.y_title.left_of(graph_area,margin+offset) #if self.y2_title:self.y2_title.center_on_y_of(graph_area) def graph_to_window(self,pts): axis_range = array((self.x_axis.range(),self.y_axis.range())) # negative y to account for positve down in window coordinates scale = self.graph_box.size() / axis_range * array((1.,-1.)) graph_min = array((self.x_axis.ticks[0],self.y_axis.ticks[0])) zero_offset = (array((0.,0))- graph_min) * scale graph_offset = array((self.graph_box.left(),self.graph_box.bottom())) return pts * scale + zero_offset + graph_offset def reset_size(self, dc = None): new_size = self.GetClientSizeTuple() if new_size != self.client_size: self.layout_all(dc) self.client_size = new_size def draw_graph_area(self,dc=None): if not dc: dc = wx.wxClientDC(self) self.layout_data() # just to check how real time plot would go... gb = self.graph_box #clear the plot area # SHOULD SET PEN HERE TO FILL BACKGROUND WITH CORRECT COLOR fill_color = get_color('white') dc.SetPen(wx.wxPen(fill_color)) dc.SetBrush(wx.wxBrush(fill_color)) # NEEDED FOR REAL-TIME PLOTTING dc.DrawRectangle(gb.left(),gb.top(), gb.width()+1,gb.height()+1) #needed to make sure images stay within bounds ##dc.SetClippingRegion(gb.left()-1,gb.top()-1, ## gb.width()+2,gb.height()+2) # mod by GAP 26092003 dc.SetClippingRegion(int(gb.left()-1),int(gb.top()-1), int(gb.width()+2),int(gb.height()+2)) # draw images self.image_list.draw(dc) dc.DestroyClippingRegion() # draw axes lines and tick marks t1 = time.clock() for axis in self.axes: axis.draw_lines(dc) #for axis in self.axes: # axis.draw_grid_lines(dc) #for axis in self.axes: # axis.draw_ticks(dc) t2 = time.clock() #print 'lines:', t2 - t1 #draw border t1 = time.clock(); self.border.draw(dc); t2 = time.clock() #print 'border:', t2 - t1 # slightly larger clipping area so that marks # aren't clipped on edges # should really clip markers and lines separately # draw lines self.line_list.clip_box(self.graph_box) self.line_list.draw(dc) # draw text # draw legend # self.legend.draw(dc) # draw overlay objects def draw(self,dc=None): #if not len(self.line_list) or len(self.image_list): # return # resize if necessary #print 'draw' #print 'dc:',dc t1 = time.clock();self.reset_size(dc);t2 = time.clock() #print 'resize:',t2 - t1 if not dc: dc = wx.wxClientDC(self) # draw titles and axes labels t1 = time.clock() for text in self.all_titles: text.draw(dc) for axis in self.axes: axis.draw_labels(dc) t2 = time.clock() #print 'text:',t2 - t1 self.draw_graph_area(dc) def update(self,event=None): self.client_size = (0,0) # forces the layout self.Refresh() def zoom(self, stop): """Delete selection band and zoom selection to full scale.""" # delete rubberband dc = wx.wxClientDC(self) dc.SetLogicalFunction(wx.wxXOR) dc.SetPen(wx.wxGREY_PEN) dc.SetBrush(wx.wxTRANSPARENT_BRUSH) diff = self._mouse_selection_stop - self._mouse_selection_start dc.DrawRectangle(self._mouse_selection_start.x, self._mouse_selection_start.y, diff.x, diff.y) self._mouse_selection_stop = stop # get zoom-area coordinates p1 = self._mouse_selection_start p2 = self._mouse_selection_stop gb = self.graph_box if abs(p1.x-p2.x) < 3 and abs(p1.y-p2.y) < 3: # zoom aborted (we assume) return left = float(min(p1.x, p2.x) - gb.left()) / gb.width() right = float(max(p1.x, p2.x) - gb.left()) / gb.width() top = float(min(p1.y, p2.y) - gb.top()) / gb.height() bottom = float(max(p1.y, p2.y) - gb.top()) / gb.height() # convert to real bounds width = self.x_axis.ticks[-1] - self.x_axis.ticks[0] height = self.y_axis.ticks[-1] - self.y_axis.ticks[0] left = left * width + self.x_axis.ticks[0] right = right * width + self.x_axis.ticks[0] top = self.y_axis.ticks[-1] - top * height bottom = self.y_axis.ticks[-1] - bottom * height x_int = auto_interval([left, right]) y_int = auto_interval([bottom,top]) self.x_axis.bounds = auto_bounds([left, right],x_int) self.y_axis.bounds = auto_bounds([bottom, top],y_int) self.update() #------------------ tick utilities ----------------------- # flexible log function #------------------ end tick utilities ----------------------- class graph_printout(wx.wxPrintout): """Print wrapper.""" # Do not change method names in this class, # we have to override wxPrintout methods here! def __init__(self, graph): wx.wxPrintout.__init__(self) self.graph = graph def HasPage(self, page): if page == 1: return wx.true else: return wx.false def GetPageInfo(self): return (1, 1, 1, 1) def OnPrintPage(self, page): dc = self.GetDC() # .5 inch margins are automatic # on my HP. Probably not standard. # Need smarter margin control. w_inch,h_inch = self.GetPPIPrinter() x_margin = .0* w_inch y_margin = .0* h_inch #------------------------------------------- # One possible method of setting scaling factors... #print w_inch,h_inch #print dc.GetSizeTuple() graph_box = box_object((0,0),self.graph.GetSizeTuple()) # Get the size of the DC in pixels page_size = dc.GetSizeTuple() #print 'dc size:',page_size #page_size = self.GetPageSizePixels() #print 'page size:',page_size print_box = box_object((0,0),page_size) print_box.trim_left(x_margin) print_box.trim_right(x_margin) print_box.trim_top(y_margin) print_box.trim_bottom(y_margin) # Calculate a suitable scaling factor scales = array(print_box.size(), Float)/graph_box.size() # Use x or y scaling factor, whichever fits on the DC scale = min(scales) # resize the graph and center on the page graph_box.inflate(scale) graph_box.center_on(print_box) # set the device scale and origin dc.SetUserScale(scale, scale) dc.SetDeviceOrigin(graph_box.left(),graph_box.top()) #------------------------------------------- #print 'print dc size:', dc.GetSizeTuple() self.graph.draw(dc) return wx.true class plot_window(plot_canvas): """Plot canvas window. This is a complete q+d hack, but it does (somewhat) work. """ def __init__(self, parent, id = -1, pos=wx.wxPyDefaultPosition, size=wx.wxPyDefaultSize,**attr): plot_canvas.__init__(self, parent, id, pos, size) self.parent = parent self.proxy_object_alive = wx.true scipy.plt.figure(self) self.layout_all() scipy.plt.xaxis('fit') # initial print setup self.print_data = wx.wxPrintData() self.print_data.SetPaperId(wx.wxPAPER_LETTER) self.print_data.SetOrientation(wx.wxLANDSCAPE) def add(self, x, y, **keywds): """Add data to plot.""" groups = scipy.plt.plot_groups([x, y, 'b-']) lines = [] for group in groups: lines.extend(scipy.plt.lines_from_group(group)) # check for hold here for name in plot_objects.poly_marker._attributes.keys(): value = keywds.get(name) if value is not None: for k in range(len(lines)): exec('lines[k].markers.%s = value' % name) for i in lines: self.line_list.append(i) self.update(); def clear(self): """Clear canvas, remove all plots.""" self.line_list = auto_line_list() scipy.plt.autoscale() def set_title(self, title): """Set plot title.""" self.title = text_window(self, title) self.all_titles[0] = self.title self.update() def set_xaxis_title(self, xtitle): """Set x-axis title""" self.x_title = text_window(self, xtitle) self.all_titles[1] = self.x_title self.update() def set_yaxis_title(self, ytitle): """Set y-axis title""" self.y_title = text_window(self, ytitle) self.all_titles[2] = self.y_title self.update() def printout(self, paper=None): """Print current plot.""" if paper != None: self.print_data.SetPaperId(paper) pdd = wx.wxPrintDialogData() pdd.SetPrintData(self.print_data) printer = wx.wxPrinter(pdd) out = graph_printout(self) print_ok = printer.Print(self.parent, out) if print_ok: self.print_data = printer.GetPrintDialogData().GetPrintData() out.Destroy() def print_preview(self): """Print-preview current plot.""" printout = graph_printout(self) printout2 = graph_printout(self) self.preview = wx.wxPrintPreview(printout, printout2, self.print_data) if not self.preview.Ok(): wx.wxMessageDialog(self, "Print Preview failed.\n" \ "Check that default printer is configured\n", \ "Print error", wx.wxOK|wx.wxCENTRE).ShowModal() else: frame = wx.wxPreviewFrame(self.preview, self.parent, "Preview") frame.Initialize() frame.SetPosition(self.GetPosition()) frame.SetSize(self.GetSize()) frame.Show(wx.true) class plot_frame(wx.wxFrame): """wxFrame for interactive use of plot_canvas.""" TITLE_FONT = 210 AXIS_FONT = 211 LABEL_FONT = 212 TITLE_TEXT,X_TEXT,Y_TEXT = 220,221,222 default_size = (500,400) # the default on Linux is always tiny??? def __init__(self, parent=wx.NULL, id = -1, title = '', pos=wx.wxPyDefaultPosition, size=default_size,visible=1): wx.wxFrame.__init__(self, parent, id, title,pos,size) # Now Create the menu bar and items self.mainmenu = wx.wxMenuBar() menu = wx.wxMenu() menu.Append(200, '&Save As...', 'Save plot to image file') wx.EVT_MENU(self, 200, self.file_save_as) menu.Append(203, '&Print...', 'Print the current plot') wx.EVT_MENU(self, 203, self.file_print) menu.Append(204, 'Print Pre&view', 'Preview the current plot') wx.EVT_MENU(self, 204, self.file_preview) menu.Append(205, 'Close', 'Close plot') wx.EVT_MENU(self, 205, self.file_close) self.mainmenu.Append(menu, '&File') menu = wx.wxMenu() menu.Append(self.TITLE_TEXT, '&Graph Title', 'Title for plot') wx.EVT_MENU(self,self.TITLE_TEXT,self.title) menu.Append(self.X_TEXT, '&X Title', 'Title for X axis') wx.EVT_MENU(self,self.X_TEXT,self.title) menu.Append(self.Y_TEXT, '&Y Title', 'Title for Y axis') wx.EVT_MENU(self,self.Y_TEXT,self.title) self.mainmenu.Append(menu, '&Titles') #menu = wx.wxMenu() #menu.Append(300, '&Profile', 'Check the hot spots in the program') #wx.EVT_MENU(self,300,self.OnProfile) #self.mainmenu.Append(menu, '&Utility') self.SetMenuBar(self.mainmenu) # A status bar to tell people what's happening self.CreateStatusBar(1) self.print_data = wx.wxPrintData() self.print_data.SetPaperId(wx.wxPAPER_LETTER) self.client = plot_canvas(self) if visible: self.Show(1) self.Raise() self.SetFocus() def plot_draw(self, event): #self.client.graphics = _InitObjects() self.client.title.text = 'Bubba' self.client.x_title.text = 'x title' self.client.y_title.text = 'y title' #self.client.y2_title.text = 'y2 title' for i in _InitObjects(): self.client.line_list.append(i) #self.client.image_list.append(lena_obj()) self.client.draw(); def profile(self, event): import profile #self.client.graphics = _InitObjects() self.client.title.text = 'Bubba' self.client.x_title.text = 'x title' self.client.y_title.text = 'y title' #self.client.y2_title.text = 'y2 title' #for i in _InitObjects(): # self.client.line_list.append(i) #self.client.image_list.append(lena_obj()) global bub bub = self profile.run('from plt import loop;loop()','profile') def file_print(self, event): self.print_data.SetPaperId(wx.wxPAPER_LETTER) pdd = wx.wxPrintDialogData() pdd.SetPrintData(self.print_data) printer = wx.wxPrinter(pdd) printout = graph_printout(self.client) print_ok = printer.Print(self, printout) #Is Abort() not wrapped? #if not printer.Abort() and not print_ok: # wx.wxMessageBox("There was a problem printing.\n" \ # "Perhaps your current printer is not set correctly?", # "Printing", wx.wxOK) #else: # self.print_data = printer.GetPrintDialogData().GetPrintData() if print_ok: self.print_data = printer.GetPrintDialogData().GetPrintData() printout.Destroy() def file_preview(self, event): printout = graph_printout(self.client) printout2 = graph_printout(self.client) self.preview = wx.wxPrintPreview(printout, printout2, self.print_data) if not self.preview.Ok(): #self.log.WriteText("Print Preview failed." \ # "Check that default printer is configured\n") print "Print Preview failed." \ "Check that default printer is configured\n" return frame = wx.wxPreviewFrame(self.preview, self, "Preview") frame.Initialize() frame.SetPosition(self.GetPosition()) frame.SetSize(self.GetSize()) frame.Show(wx.true) def file_save_as(self, event): import os wildcard = "PNG files (*.png)|*.png|" \ "BMP files (*.bmp)|*.bmp|" \ "JPEG files (*.jpg)|*.jpg|" \ "PCX files (*.pcx)|*.pcx|" \ "TIFF files (*.tif)|*.tif|" \ "All Files |*|" dlg = wx.wxFileDialog(self, "Save As", ".", "", wildcard, wx.wxSAVE) if dlg.ShowModal() == wx.wxID_OK: f = dlg.GetPath() dummy, ftype = os.path.splitext(f) # strip . ftype = ftype[1:] if ftype in image_type_map.keys(): self.client.save(dlg.GetPath(),ftype) else: msg = "Extension is currently used to determine file type." \ "'%s' is not a valid extension." \ "You may use one of the following extensions. %s" \ % (ftype,image_type_map.keys()) d = wx.wxMessageDialog(self,msg,style=wx.wxOK) d.ShowModal() d.Destroy() dlg.Destroy() def file_close(self, event): self.Close() def format_font(self,event): font_attr,color_attr = 'font','color' if event.GetId() == self.TITLE_FONT: texts = [self.client.title] elif event.GetId() == self.AXIS_FONT: texts = [self.client.x_title,self.client.y_title] #texts = [self.client.y_title] elif event.GetId() == self.LABEL_FONT: texts = [self.client.x_axis,self.client.y_axis] font_attr,color_attr = 'label_font','label_color' data = wx.wxFontData() current_color = get_color(getattr(texts[0],color_attr)) current_font = getattr(texts[0],font_attr) data.SetColour(current_color) data.SetInitialFont(current_font) dlg = wx.wxFontDialog(self, data) if dlg.ShowModal() == wx.wxID_OK: data = dlg.GetFontData() font = data.GetChosenFont() color = data.GetColour() rgb = color.Red(),color.Green(),color.Blue() for text in texts: setattr(text,color_attr,rgb) setattr(text,font_attr,font) self.client.update() dlg.Destroy() def title(self,event): if event.GetId() == self.TITLE_TEXT: title = self.client.title prompt = 'Enter graph title' elif event.GetId() == self.X_TEXT: title = self.client.x_title prompt = 'Enter x axis title' elif event.GetId() == self.Y_TEXT: title = self.client.y_title prompt = 'Enter y axis title' dlg = wx.wxTextEntryDialog(self, prompt,'', title.text) if dlg.ShowModal() == wx.wxID_OK: title.text = dlg.GetValue() dlg.Destroy() self.client.update() def update(self): self.client.update() def __getattr__(self,key): try: return self.__dict__[key] except KeyError: return getattr(self.__dict__['client'],key) """ def __setattr__(self,key,val): #print key,val #if plot_canvas._attributes.has_key(key): # self.__dict__['client'].__dict__[key] = val # return None self.__dict__[key] = val """ # global functions def lena_obj(): return image_object(lena(),colormap='grey') def _InitObjects(): # 100 points sin function, plotted as green circles data1 = 2.*pi*arange(200)/200. data1.shape = (100, 2) data1[:,1] = sin(data1[:,0]) #markers1 = poly_marker(data1, color='green', marker='circle',size=1) markers1 = line_object(data1) # 50 points cos function, plotted as red line data1 = 2.*pi*arange(100)/100. data1.shape = (50,2) data1[:,1] = cos(data1[:,0]) #lines = poly_line(data1, color='red') lines = line_object(data1) # A few more points... #markers2 = poly_marker([(0., 0.), (pi/4., 1.), (pi/2, 0.), # (3.*pi/4., -1)], color='blue', # fillcolor='green', marker='cross') markers2 = line_object([(0., 0.), (pi/4., 1.), (pi/2, 0.),(3.*pi/4., -1)]) # An Image return [markers1]#, lines, markers2] def test_axis(): a = axis_object(rotate = 0) graph_area = box_object((10,10),(100,100)) bounds = (-1.,1.) a.calculate_ticks(bounds) dummy_dc = 0 a.layout(graph_area,dummy_dc) print a.tick_points bounds = (0.,1.) a.calculate_ticks(bounds) a.layout(graph_area,dummy_dc) print a.tick_points print a.tick_start print a.tick_stop if __name__ == '__main__': class MyApp(wx.wxApp): def OnInit(self): frame = plot_frame(wx.NULL, -1, "Graph",size=(400,400)) frame.Show(wx.TRUE) self.SetTopWindow(frame) #frame.OnPlotDraw(None) return wx.TRUE app = MyApp(0) app.MainLoop()