hooke.py

   1 #!/usr/bin/env python
   2
   3 '''
   4 HOOKE - A force spectroscopy review & analysis tool
   5
   6 (C) 2008 Massimo Sandal
   7
   8 Copyright (C) 2008 Massimo Sandal (University of Bologna, Italy).
   9
  10 This program is released under the GNU General Public License version 2.
  11 '''
  12
  13 from libhooke import HOOKE_VERSION
  14 from libhooke import WX_GOOD
  15
  16 import os
  17
  18 import wxversion
  19 wxversion.select(WX_GOOD)
  20 import wx
  21 import wxmpl
  22 from wx.lib.newevent import NewEvent
  23
  24 import matplotlib.numerix as nx
  25 import scipy as sp
  26
  27 from threading import *
  28 import Queue
  29
  30 from hooke_cli import HookeCli
  31 from libhooke import *
  32 import libhookecurve as lhc
  33
  34 #import file versions, just to know with what we're working...
  35 from hooke_cli import __version__ as hookecli_version
  36
  37 global __version__
  38 global events_from_gui
  39 global config
  40 global CLI_PLUGINS
  41 global GUI_PLUGINS
  42 global LOADED_PLUGINS
  43 global PLOTMANIP_PLUGINS
  44 global FILE_DRIVERS
  45
  46 __version__=HOOKE_VERSION[0]
  47 __release_name__=HOOKE_VERSION[1]
  48
  49 events_from_gui=Queue.Queue() #GUI ---> CLI COMMUNICATION
  50
  51 print 'Starting Hooke.'
  52 #CONFIGURATION FILE PARSING
  53 config_obj=HookeConfig()
  54 config=config_obj.load_config('hooke.conf')
  55
  56 #IMPORTING PLUGINS
  57
  58 CLI_PLUGINS=[]
  59 GUI_PLUGINS=[]
  60 PLOTMANIP_PLUGINS=[]
  61 LOADED_PLUGINS=[]
  62
  63 plugin_commands_namespaces=[]
  64 plugin_gui_namespaces=[]
  65 for plugin_name in config['plugins']:
  66     try:
  67         plugin=__import__(plugin_name)
  68         try:
  69             eval('CLI_PLUGINS.append(plugin.'+plugin_name+'Commands)') #take Command plugin classes
  70             plugin_commands_namespaces.append(dir(eval('plugin.'+plugin_name+'Commands')))
  71         except:
  72             pass
  73         try:
  74             eval('GUI_PLUGINS.append(plugin.'+plugin_name+'Gui)') #take Gui plugin classes
  75             plugin_gui_namespaces.append(dir(eval('plugin.'+plugin_name+'Gui')))
  76         except:
  77             pass
  78     except ImportError:
  79         print 'Cannot find plugin ',plugin_name
  80     else:
  81         LOADED_PLUGINS.append(plugin_name)
  82         print 'Imported plugin ',plugin_name
  83
  84 #eliminate names common to all namespaces
  85 for i in range(len(plugin_commands_namespaces)):
  86     plugin_commands_namespaces[i]=[item for item in plugin_commands_namespaces[i] if (item != '__doc__' and item != '__module__' and item != '_plug_init')]
  87 #check for conflicts in namespaces between plugins
  88 #FIXME: only in commands now, because I don't have Gui plugins to check
  89 #FIXME: how to check for plugin-defined variables (self.stuff) ??
  90 plugin_commands_names=[]
  91 whatplugin_defines=[]
  92 plugin_gui_names=[]
  93 for namespace,plugin_name in zip(plugin_commands_namespaces, config['plugins']):
  94     for item in namespace:
  95         if item in plugin_commands_names:
  96             i=plugin_commands_names.index(item) #we exploit the fact index gives the *first* occurrence of a name...
  97             print 'Error. Plugin ',plugin_name,' defines a function already defined by ',whatplugin_defines[i],'!'
  98             print 'This should not happen. Please disable one or both plugins and contact the plugin authors to solve the conflict.'
  99             print 'Hooke cannot continue.'
 100             exit()
 101         else:
 102             plugin_commands_names.append(item)
 103             whatplugin_defines.append(plugin_name)
 104
 105
 106 config['loaded_plugins']=LOADED_PLUGINS #FIXME: kludge -this should be global but not in config!
 107 #IMPORTING DRIVERS
 108 #FIXME: code duplication
 109 FILE_DRIVERS=[]
 110 LOADED_DRIVERS=[]
 111 for driver_name in config['drivers']:
 112     try:
 113         driver=__import__(driver_name)
 114         try:
 115             eval('FILE_DRIVERS.append(driver.'+driver_name+'Driver)')
 116         except:
 117             pass
 118     except ImportError:
 119         print 'Cannot find driver ',driver_name
 120     else:
 121         LOADED_DRIVERS.append(driver_name)
 122         print 'Imported driver ',driver_name
 123 config['loaded_drivers']=LOADED_DRIVERS
 124
 125 #LIST OF CUSTOM WX EVENTS FOR CLI ---> GUI COMMUNICATION
 126 #FIXME: do they need to be here?
 127 list_of_events={}
 128
 129 plot_graph, EVT_PLOT = NewEvent()
 130 list_of_events['plot_graph']=plot_graph
 131
 132 plot_contact, EVT_PLOT_CONTACT = NewEvent()
 133 list_of_events['plot_contact']=plot_contact
 134
 135 measure_points, EVT_MEASURE_POINTS = NewEvent()
 136 list_of_events['measure_points']=measure_points
 137
 138 export_image, EVT_EXPORT_IMAGE = NewEvent()
 139 list_of_events['export_image']=export_image
 140
 141 close_plot, EVT_CLOSE_PLOT = NewEvent()
 142 list_of_events['close_plot'] = close_plot
 143
 144 show_plots, EVT_SHOW_PLOTS = NewEvent()
 145 list_of_events['show_plots'] = show_plots
 146
 147 get_displayed_plot, EVT_GET_DISPLAYED_PLOT = NewEvent()
 148 list_of_events['get_displayed_plot'] = get_displayed_plot
 149 #------------
 150
 151 class CliThread(Thread):
 152
 153     def __init__(self,frame,list_of_events):
 154         Thread.__init__(self)
 155
 156         #here we have to put temporary references to pass to the cli object.
 157         self.frame=frame
 158         self.list_of_events=list_of_events
 159
 160         self.debug=0 #to be used in the future
 161
 162     def run(self):
 163         print '\n\nThis is Hooke, version',__version__ , __release_name__
 164         print
 165         print '(c) Massimo Sandal & others, 2006-2008. Released under the GNU Lesser General Public License Version 3'
 166         print 'Hooke is Free software.'
 167         print '----'
 168         print ''
 169
 170         def make_command_class(*bases):
 171             #FIXME: perhaps redundant
 172             return type(HookeCli)("HookeCliPlugged", bases + (HookeCli,), {})
 173         cli = make_command_class(*CLI_PLUGINS)(self.frame,self.list_of_events,events_from_gui,config,FILE_DRIVERS)
 174         cli.cmdloop()
 175
 176 '''
 177 GUI CODE
 178
 179 FIXME: put it in a separate module in the future?
 180 '''
 181 class MainMenuBar(wx.MenuBar):
 182     '''
 183     Creates the menu bar
 184     '''
 185     def __init__(self):
 186         wx.MenuBar.__init__(self)
 187         '''the menu description. the key of the menu is XX&Menu, where XX is a number telling
 188         the order of the menus on the menubar.
 189         &Menu is the Menu text
 190         the corresponding argument is ('&Item', 'itemname'), where &Item is the item text and itemname
 191         the inner reference to use in the self.menu_items dictionary.
 192
 193         See create_menus() to see how it works
 194
 195         Note: the mechanism on page 124 of "wxPython in Action" is less awkward, maybe, but I want
 196         binding to be performed later. Perhaps I'm wrong :)
 197         '''
 198
 199         self.menu_desc={'00&File':[('&Open playlist','openplaymenu'),('&Exit','exitmenu')],
 200         '01&Edit':[('&Export text...','exporttextmenu'),('&Export image...','exportimagemenu')],
 201         '02&Help':[('&About Hooke','aboutmenu')]}
 202         self.create_menus()
 203
 204     def create_menus(self):
 205         '''
 206         Smartish routine to create the menu from the self.menu_desc dictionary
 207         Hope it's a workable solution for the future.
 208         '''
 209         self.menus=[] #the menu objects to append to the menubar
 210         self.menu_items={} #the single menu items dictionary, to bind to events
 211
 212         names=self.menu_desc.keys() #we gotta sort, because iterating keys goes in odd order
 213         names.sort()
 214
 215         for name in names:
 216             self.menus.append(wx.Menu())
 217             for menu_item in self.menu_desc[name]:
 218                 self.menu_items[menu_item[1]]=self.menus[-1].Append(-1, menu_item[0])
 219
 220         for menu,name in zip(self.menus,names):
 221             self.Append(menu,name[2:])
 222
 223 class MainPanel(wx.Panel):
 224     def __init__(self,parent,id):
 225
 226        wx.Panel.__init__(self,parent,id)
 227        self.splitter = wx.SplitterWindow(self)
 228
 229 ID_FRAME=100
 230 class MainWindow(wx.Frame):
 231         '''we make a frame inheriting wx.Frame and setting up things on the init'''
 232         def __init__(self,parent,id,title):
 233
 234             #-----------------------------
 235             #WX WIDGETS INITIALIZATION
 236
 237             wx.Frame.__init__(self,parent,ID_FRAME,title,size=(800,600),style=wx.DEFAULT_FRAME_STYLE|wx.NO_FULL_REPAINT_ON_RESIZE)
 238
 239             self.mainpanel=MainPanel(self,-1)
 240             self.cpanels=[]
 241
 242             self.cpanels.append(wx.Panel(self.mainpanel.splitter,-1))
 243             self.cpanels.append(wx.Panel(self.mainpanel.splitter,-1))
 244
 245             self.statusbar=wx.StatusBar(self,-1)
 246             self.SetStatusBar(self.statusbar)
 247
 248             self.mainmenubar=MainMenuBar()
 249             self.SetMenuBar(self.mainmenubar)
 250
 251             self.controls=[]
 252             self.figures=[]
 253             self.axes=[]
 254
 255             #This is our matplotlib plot
 256             self.controls.append(wxmpl.PlotPanel(self.cpanels[0],-1))
 257             self.controls.append(wxmpl.PlotPanel(self.cpanels[1],-1))
 258             #These are our figure and axes, so to have easy references
 259             #Also, we initialize
 260             self.figures=[control.get_figure() for control in self.controls]
 261             self.axes=[figure.gca() for figure in self.figures]
 262
 263             self.cpanels[1].Hide()
 264             self.mainpanel.splitter.Initialize(self.cpanels[0])
 265
 266             self.sizer_dance() #place/size the widgets
 267
 268             self.controls[0].SetSize(self.cpanels[0].GetSize())
 269             self.controls[1].SetSize(self.cpanels[1].GetSize())
 270
 271             #-------------------------------------------
 272             #NON-WX WIDGETS INITIALIZATION
 273
 274             #Flags.
 275             self.click_plot=0
 276
 277             #FIXME: These could become a single flag with different (string?) values
 278             self.on_measure_distance=False
 279             self.on_measure_force=False
 280
 281             self.plot_fit=False
 282
 283             #Number of points to be clicked
 284             self.num_of_points = 2
 285
 286             #Data.
 287             self.current_x_ext=[[],[]]
 288             self.current_y_ext=[[],[]]
 289             self.current_x_ret=[[],[]]
 290             self.current_y_ret=[[],[]]
 291
 292             self.current_x_unit=[None,None]
 293             self.current_y_unit=[None,None]
 294
 295             #Initialize xaxes, yaxes
 296             #FIXME: should come from config
 297             self.current_xaxes=0
 298             self.current_yaxes=0
 299
 300             #Other
 301
 302
 303             self.index_buffer=[]
 304
 305             self.clicked_points=[]
 306
 307             self.events_from_gui = events_from_gui
 308
 309             '''
 310             This dictionary keeps all the flags and the relative functon names that
 311             have to be called when a point is clicked.
 312             That is:
 313             - if point is clicked AND foo_flag=True
 314             - foo()
 315
 316             Conversely, foo_flag is True if a corresponding event is launched by the CLI.
 317
 318             self.ClickedPoints() takes care of handling this
 319             '''
 320
 321             self.click_flags_functions={'measure_points':[False, 'MeasurePoints']}
 322
 323             #Custom events from CLI --> GUI functions!
 324             #FIXME: Should use the self.Bind() syntax
 325             EVT_PLOT(self, self.PlotCurve)
 326             EVT_PLOT_CONTACT(self, self.PlotContact)
 327             EVT_GET_DISPLAYED_PLOT(self, self.OnGetDisplayedPlot)
 328             EVT_MEASURE_POINTS(self, self.OnMeasurePoints)
 329             EVT_EXPORT_IMAGE(self,self.ExportImage)
 330             EVT_CLOSE_PLOT(self, self.OnClosePlot)
 331             EVT_SHOW_PLOTS(self, self.OnShowPlots)
 332
 333             #This event and control decide what happens when I click on the plot 0.
 334             wxmpl.EVT_POINT(self, self.controls[0].GetId(), self.ClickPoint0)
 335             wxmpl.EVT_POINT(self, self.controls[1].GetId(), self.ClickPoint1)
 336
 337             #RUN PLUGIN-SPECIFIC INITIALIZATION
 338             #make sure we execute _plug_init() for every command line plugin we import
 339             for plugin_name in config['plugins']:
 340                 try:
 341                     plugin=__import__(plugin_name)
 342                     try:
 343                         eval('plugin.'+plugin_name+'Gui._plug_init(self)')
 344                         pass
 345                     except AttributeError:
 346                         pass
 347                 except ImportError:
 348                     pass
 349
 350
 351
 352         #WX-SPECIFIC FUNCTIONS
 353         def sizer_dance(self):
 354             '''
 355             adjust size and placement of wxpython widgets.
 356             '''
 357             self.splittersizer = wx.BoxSizer(wx.VERTICAL)
 358             self.splittersizer.Add(self.mainpanel.splitter, 1, wx.EXPAND)
 359
 360             self.plot1sizer = wx.BoxSizer()
 361             self.plot1sizer.Add(self.controls[0], 1, wx.EXPAND)
 362
 363             self.plot2sizer = wx.BoxSizer()
 364             self.plot2sizer.Add(self.controls[1], 1, wx.EXPAND)
 365
 366             self.panelsizer=wx.BoxSizer()
 367             self.panelsizer.Add(self.mainpanel, -1, wx.EXPAND)
 368
 369             self.cpanels[0].SetSizer(self.plot1sizer)
 370             self.cpanels[1].SetSizer(self.plot2sizer)
 371
 372             self.mainpanel.SetSizer(self.splittersizer)
 373             self.SetSizer(self.panelsizer)
 374
 375         def binding_dance(self):
 376             self.Bind(wx.EVT_MENU, self.OnOpenPlayMenu, self.menubar.menu_items['openplaymenu'])
 377             self.Bind(wx.EVT_MENU, self.OnExitMenu, self.menubar.menu_items['exitmenu'])
 378             self.Bind(wx.EVT_MENU, self.OnExportText, self.menubar.menu_items['exporttextmenu'])
 379             self.Bind(wx.EVT_MENU, self.OnExportImage, self.menubar.menu_items['exportimagemenu'])
 380             self.Bind(wx.EVT_MENU, self.OnAboutMenu, self.menubar.menu_items['aboutmenu'])
 381
 382         # DOUBLE PLOT MANAGEMENT
 383         #----------------------
 384         def show_both(self):
 385             '''
 386             Shows both plots.
 387             '''
 388             self.mainpanel.splitter.SplitHorizontally(self.cpanels[0],self.cpanels[1])
 389             self.mainpanel.splitter.SetSashGravity(0.5)
 390             self.mainpanel.splitter.SetSashPosition(300) #FIXME: we should get it and restore it
 391             self.mainpanel.splitter.UpdateSize()
 392
 393         def close_plot(self,plot):
 394             '''
 395             Closes one plot - only if it's open
 396             '''
 397             if not self.cpanels[plot].IsShown():
 398                 return
 399             if plot != 0:
 400                 self.current_plot_dest = 0
 401             else:
 402                 self.current_plot_dest = 1
 403             self.cpanels[plot].Hide()
 404             self.mainpanel.splitter.Unsplit(self.cpanels[plot])
 405             self.mainpanel.splitter.UpdateSize()
 406
 407
 408         def OnClosePlot(self,event):
 409             self.close_plot(event.to_close)
 410
 411         def OnShowPlots(self,event):
 412             self.show_both()
 413
 414
 415         #FILE MENU FUNCTIONS
 416         #--------------------
 417         def OnOpenPlayMenu(self, event):
 418             pass
 419
 420         def OnExitMenu(self,event):
 421             pass
 422
 423         def OnExportText(self,event):
 424             pass
 425
 426         def OnExportImage(self,event):
 427             pass
 428
 429         def OnAboutMenu(self,event):
 430             pass
 431
 432         #PLOT INTERACTION
 433         #----------------
 434         def PlotCurve(self,event):
 435             '''
 436             plots the current ext,ret curve.
 437             '''
 438             dest=0
 439
 440             #FIXME: BAD kludge following. There should be a well made plot queue mechanism, with replacements etc.
 441             #---
 442             #If we have only one plot in the event, we already have one in self.plots and this is a secondary plot,
 443             #do not erase self.plots but append the new plot to it.
 444             if len(event.plots) == 1 and event.plots[0].destination != 0 and len(self.plots) == 1:
 445                 self.plots.append(event.plots[0])
 446             #if we already have two plots and a new secondary plot comes, we substitute the previous
 447             if len(event.plots) == 1 and event.plots[0].destination != 0 and len(self.plots) > 1:
 448                 self.plots[1] = event.plots[0]
 449             else:
 450                 self.plots = event.plots
 451
 452             #FIXME. Should be in PlotObject, somehow
 453             c=0
 454             for plot in self.plots:
 455                 if self.plots[c].styles==[]:
 456                     self.plots[c].styles=[None for item in plot.vectors]
 457
 458             for plot in self.plots:
 459                 '''
 460                 MAIN LOOP FOR ALL PLOTS (now only 2 are allowed but...)
 461                 '''
 462                 if 'destination' in dir(plot):
 463                     dest=plot.destination
 464
 465                 #if the requested panel is not shown, show it
 466                 if not ( self.cpanels[dest].IsShown() ):
 467                     self.show_both()
 468
 469                 self.axes[dest].hold(False)
 470                 self.current_vectors=plot.vectors
 471                 self.current_title=plot.title
 472                 self.current_plot_dest=dest #let's try this way to take into account the destination plot...
 473
 474                 c=0
 475                 for vectors_to_plot in self.current_vectors:
 476                     if len(vectors_to_plot)==2: #3d plots are to come...
 477                         if len(plot.styles) > 0 and plot.styles[c] == 'scatter':
 478                             self.axes[dest].scatter(vectors_to_plot[0],vectors_to_plot[1])
 479                         else:
 480                             self.axes[dest].plot(vectors_to_plot[0],vectors_to_plot[1])
 481
 482                         self.axes[dest].hold(True)
 483                         c+=1
 484                     else:
 485                         pass
 486
 487                 #FIXME: tackles only 2d plots
 488                 self.axes[dest].set_xlabel(plot.units[0])
 489                 self.axes[dest].set_ylabel(plot.units[1])
 490
 491                 #FIXME: set smaller fonts
 492                 self.axes[dest].set_title(plot.title)
 493
 494                 if plot.xaxes:
 495                     #swap X axis
 496                     xlim=self.axes[dest].get_xlim()
 497                     self.axes[dest].set_xlim((xlim[1],xlim[0]))
 498                 if plot.yaxes:
 499                     #swap Y axis
 500                     ylim=self.axes[dest].get_ylim()
 501                     self.axes[dest].set_ylim((ylim[1],ylim[0]))
 502
 503                 self.controls[dest].draw()
 504
 505
 506         def PlotContact(self,event):
 507             '''
 508             plots the contact point
 509             '''
 510             self.axes[0].hold(True)
 511             self.current_contact_index=event.contact_index
 512
 513             #now we fake a clicked point
 514             self.clicked_points.append(ClickedPoint())
 515             self.clicked_points[-1].absolute_coords=self.current_x_ret[dest][self.current_contact_index], self.current_y_ret[dest][self.current_contact_index]
 516             self.clicked_points[-1].is_marker=True
 517
 518             self._replot()
 519             self.clicked_points=[]
 520
 521
 522         def ClickPoint0(self,event):
 523             self.current_plot_dest=0
 524             self.ClickPoint(event)
 525         def ClickPoint1(self,event):
 526             self.current_plot_dest=1
 527             self.ClickPoint(event)
 528
 529         def ClickPoint(self,event):
 530             '''
 531             this function decides what to do when we receive a left click on the axes.
 532             We trigger other functions:
 533             - the action chosen by the CLI sends an event
 534             - the event raises a flag : self.click_flags_functions['foo'][0]
 535             - the raised flag wants the function in self.click_flags_functions[1] to be called after a click
 536             '''
 537             for key, value in self.click_flags_functions.items():
 538                 if value[0]:
 539                     eval('self.'+value[1]+'(event)')
 540
 541         def OnMeasurePoints(self,event):
 542             '''
 543             trigger flags to measure N points
 544             '''
 545             self.click_flags_functions['measure_points'][0]=True
 546             if 'num_of_points' in dir(event):
 547                 self.num_of_points=event.num_of_points
 548
 549
 550         def MeasurePoints(self,event,current_set=1):
 551             dest=self.current_plot_dest
 552             try:
 553                 current_set=event.set
 554             except AttributeError:
 555                 pass
 556
 557             #find the current plot matching the clicked destination
 558             plot=self._plot_of_dest()
 559             if len(plot.vectors)-1 < current_set: #what happens if current_set is 1 and we have only 1 vector?
 560                 current_set=current_set-len(plot.vectors)
 561
 562             xvector=plot.vectors[current_set][0]
 563             yvector=plot.vectors[current_set][1]
 564
 565             self.clicked_points.append(ClickedPoint())
 566             self.clicked_points[-1].absolute_coords=event.xdata, event.ydata
 567             self.clicked_points[-1].find_graph_coords(xvector,yvector)
 568             self.clicked_points[-1].is_marker=True
 569             self.clicked_points[-1].is_line_edge=True
 570             self.clicked_points[-1].dest=dest
 571
 572             self._replot()
 573
 574             if len(self.clicked_points)==self.num_of_points:
 575                 self.events_from_gui.put(self.clicked_points)
 576                 #restore to default state:
 577                 self.clicked_points=[]
 578                 self.click_flags_functions['measure_points'][0]=False
 579
 580
 581         def OnGetDisplayedPlot(self,event):
 582             if 'dest' in dir(event):
 583                 self.GetDisplayedPlot(event.dest)
 584             else:
 585                 self.GetDisplayedPlot(self.current_plot_dest)
 586
 587         def GetDisplayedPlot(self,dest):
 588             '''
 589             returns to the CLI the currently displayed plot for the given destination
 590             '''
 591             displayed_plot=self._plot_of_dest(dest)
 592             events_from_gui.put(displayed_plot)
 593
 594         def ExportImage(self,event):
 595             '''
 596             exports an image as a file.
 597             Current supported file formats: png, eps
 598             (matplotlib docs say that jpeg should be supported too, but with .jpg it doesn't work for me!)
 599             '''
 600             #dest=self.current_plot_dest
 601             dest=event.dest
 602             filename=event.name
 603             self.figures[dest].savefig(filename)
 604
 605         def _find_nearest_point(self, mypoint, dataset=1):
 606             '''
 607             Given a clicked point on the plot, finds the nearest point in the dataset (in X) that
 608             corresponds to the clicked point.
 609             '''
 610             dest=self.current_plot_dest
 611
 612             xvector=plot.vectors[dataset][0]
 613             yvector=plot.vectors[dataset][1]
 614
 615             #Ye Olde sorting algorithm...
 616             #FIXME: is there a better solution?
 617             index=0
 618             best_index=0
 619             best_diff=10^9 #hope we never go over this magic number :(
 620             for point in xvector:
 621                 diff=abs(point-mypoint)
 622                 if diff<best_diff:
 623                     best_index=index
 624                     best_diff=diff
 625                 index+=1
 626
 627             return best_index,xvector[best_index],yvector[best_index]
 628
 629
 630         def _plot_of_dest(self,dest=None):
 631             '''
 632             returns the plot that has the current destination
 633             '''
 634             if dest==None:
 635                 dest=self.current_plot_dest
 636
 637             plot=None
 638             for aplot in self.plots:
 639                 if aplot.destination == dest:
 640                     plot=aplot
 641             return plot
 642
 643         def _replot(self):
 644             '''
 645             this routine is needed for a fresh clean-and-replot of interface
 646             otherwise, refreshing works very badly :(
 647
 648             thanks to Ken McIvor, wxmpl author!
 649             '''
 650             dest=self.current_plot_dest
 651             #we get current zoom limits
 652             xlim=self.axes[dest].get_xlim()
 653             ylim=self.axes[dest].get_ylim()
 654             #clear axes
 655             self.axes[dest].cla()
 656
 657             #Plot curve:
 658             #find the current plot matching the clicked destination
 659             plot=self._plot_of_dest()
 660             #plot all superimposed plots
 661             c=0
 662             for plotset in plot.vectors:
 663                 if len(plot.styles) > 0 and plot.styles[c]=='scatter':
 664                     self.axes[dest].scatter(plotset[0], plotset[1])
 665                 else:
 666                     self.axes[dest].plot(plotset[0], plotset[1])
 667                 c+=1
 668             #plot points we have clicked
 669             for item in self.clicked_points:
 670                 if item.is_marker:
 671                     if item.graph_coords==(None,None): #if we have no graph coords, we display absolute coords
 672                         self.axes[dest].scatter([item.absolute_coords[0]],[item.absolute_coords[1]])
 673                     else:
 674                         self.axes[dest].scatter([item.graph_coords[0]],[item.graph_coords[1]])
 675
 676             if self.plot_fit:
 677                 print 'DEBUGGING WARNING: use of self.plot_fit is deprecated!'
 678                 self.axes[dest].plot(self.plot_fit[0],self.plot_fit[1])
 679
 680             self.axes[dest].hold(True)
 681             #set old axes again
 682             self.axes[dest].set_xlim(xlim)
 683             self.axes[dest].set_ylim(ylim)
 684             #set title and names again...
 685             self.axes[dest].set_title(self.current_title)
 686             self.axes[dest].set_xlabel(plot.units[0])
 687             self.axes[dest].set_ylabel(plot.units[1])
 688             #and redraw!
 689             self.controls[dest].draw()
 690
 691
 692 class MySplashScreen(wx.SplashScreen):
 693     """
 694     Create a splash screen widget.
 695     That's just a fancy addition... every serious application has a splash screen!
 696     """
 697     def __init__(self, frame):
 698         # This is a recipe to a the screen.
 699         # Modify the following variables as necessary.
 700         #aBitmap = wx.Image(name = "wxPyWiki.jpg").ConvertToBitmap()
 701         aBitmap=wx.Image(name='hooke.jpg').ConvertToBitmap()
 702         splashStyle = wx.SPLASH_CENTRE_ON_SCREEN | wx.SPLASH_TIMEOUT
 703         splashDuration = 2000 # milliseconds
 704         splashCallback = None
 705         # Call the constructor with the above arguments in exactly the
 706         # following order.
 707         wx.SplashScreen.__init__(self, aBitmap, splashStyle,
 708                                  splashDuration, None, -1)
 709         wx.EVT_CLOSE(self, self.OnExit)
 710         self.frame=frame
 711         wx.Yield()
 712
 713     def OnExit(self, evt):
 714         self.Hide()
 715
 716         self.frame.Show()
 717         # The program will freeze without this line.
 718         evt.Skip()  # Make sure the default handler runs too...
 719
 720
 721 #------------------------------------------------------------------------------
 722
 723 def main():
 724
 725     #save the directory where Hooke is located
 726     config['hookedir']=os.getcwd()
 727
 728     #now change to the working directory.
 729     try:
 730         os.chdir(config['workdir'])
 731     except OSError:
 732         print "Warning: Invalid work directory."
 733
 734     app=wx.PySimpleApp()
 735
 736     def make_gui_class(*bases):
 737             return type(MainWindow)("MainWindowPlugged", bases + (MainWindow,), {})
 738
 739     main_frame = make_gui_class(*GUI_PLUGINS)(None, -1, ('Hooke '+__version__))
 740
 741     #FIXME. The frame.Show() is called by the splashscreen here! Ugly as hell.
 742
 743     mysplash=MySplashScreen(main_frame)
 744     mysplash.Show()
 745
 746     my_cmdline=CliThread(main_frame, list_of_events)
 747     my_cmdline.start()
 748
 749
 750     app.MainLoop()
 751
 752 main()