def __init__(self, parent, id = -1):

        pre = wx.PrePanel()

        res = xmlres.loadGuiResource('ViewSelectPanel.xrc')
        res.LoadOnPanel(pre, parent, "ID_VIEWSELECTPANEL")
        self.PostCreate(pre)
        
        self._view_select = xrc.XRCCTRL(self, "ID_VIEW_SELECT")
        
        self._find_text = xrc.XRCCTRL(self, "ID_REFRESH_FIND")
        self._clear_filter = xrc.XRCCTRL(self, "ID_CLEAR_FIND")
        self._filter_text = xrc.XRCCTRL(self, "ID_TEXT_FILTER")
                
        # temp var for delayed selection of view
        self._the_view = -1

        self._our_problem = False
        
        self._initViewSelect()
              
        self.Bind(wx.EVT_LIST_ITEM_SELECTED, self._onViewSelected, self._view_select)
        self.Bind(wx.EVT_TEXT, self._onFilterText, self._filter_text)
        self.Bind(wx.EVT_BUTTON, self._onRefreshFilter, self._find_text)
        self.Bind(wx.EVT_BUTTON, self._onClearFilter, self._clear_filter)
        self.Bind(wx.EVT_TEXT_ENTER, self._onRefreshFilter, self._filter_text)
        self.Bind(wx.EVT_UPDATE_UI, self._onUpdateUI)
        Publisher.subscribe(self._onViewChanged, signals.SET_VIEW)

		def terminate(self, error = False, msg = None):
			""" Thread termination routine
				param error: False if thread is terminate without error
				param msg: message to submit
			"""

			if not self.end_flag:
				if error:

					###for traceback
					etype = msg[0]
					evalue = msg[1]
					etb = traceback.extract_tb(msg[2])
					sys.stderr.write('Error in routine: your routine here\n')
					sys.stderr.write('Error Type: ' + str(etype) + '\n')
					sys.stderr.write('Error Value: ' + str(evalue) + '\n')
					sys.stderr.write('Traceback: ' + str(etb) + '\n')

					### only for displayed application (-nogui)
					if wx.GetApp():
						wx.CallAfter(Publisher.sendMessage, "error", msg)
						### error sound
						wx.CallAfter(playSound, SIMULATION_ERROR_SOUND_PATH)

				else:
					for m in filter(lambda a: hasattr(a, 'finish'), self.model.componentSet):
						### call finished method
						Publisher.sendMessage('%d.finished'%(id(m)))

					### only for displayed application (-nogui)
					if wx.GetApp() : wx.CallAfter(playSound, SIMULATION_SUCCESS_SOUND_PATH)

			self.end_flag = True

 def decrementClientMinutes(self, subminutes):
     """
     subtrack some of the minutes the client is having
     """
     Publisher.sendMessage("sendingRemaing.Minutes",  data=subminutes)
     self.decrement = self.getClientMinutes() - subminutes
     self.saveRunningStatus(self.decrement)
     
     if(self.setClientMinutes(self.decrement) == False):
         raise ValueError("Unable to set client time")
     else:
         try:
             #print "Doing something like sending to the server"
             #Publish a message to the window.py which will send a message to
             #the server.
             try:
                 #print "Duplicating"
                 Publisher.sendMessage("sendRemainingMinutes", data=str(self.getClientMinutes()))
             except:
                 raise 
             else:
                 self._parent.owed_timetext.SetLabel(str(self.getClientMinutes()))
                 
         except:
             return False
         
     #set the client runtime
     self.setClientRuntime(self.getClientRuntime() + int(subminutes))
     try:
         self.incrementRuntime(self.getClientRuntime())
     except:
         raise 

 def __init__(self, ip, portFrom, portTo):
     Thread.__init__(self)
     self.IP = ip
     self.portFrom = portFrom
     self.portTo = portTo
     Publisher.sendMessage("scanThread", "started")
     self.start()

	def __init__(self, model, view, xmlData):
		self.model = model
		self.view = view
		self.xmlData = xmlData
		
		Publisher.subscribe(self.psXmlDataChanged, "status.change.xmldatachanged")
		Publisher.subscribe(self.itemSelected, "config.function.selected")

	def __init__(self, model):
		self.model = model
		self.data = None
		self.config = model.getConfig()
		self.confPath = "."
		Publisher.subscribe(self.psXmlChanged, "status.change.xmlchanged")
		Publisher().subscribe(self.psConfigPathChanged, "config.path.changed")

    def __init__(self, *args, **kwargs):
        MyPanel.__init__(self, *args, **kwargs)        

        sum_box = wx.StaticBox(self, label="Preferences")
        box_sizer = wx.StaticBoxSizer(sum_box, wx.VERTICAL)
        fgs = wx.FlexGridSizer(rows=3, cols=5)
        box_sizer.Add(fgs, proportion=1, flag=wx.EXPAND)

        fgs.AddMany([(wx.StaticText(self, style=wx.ALIGN_LEFT), 0, wx.EXPAND), 
                    (wx.StaticText(self, label="1st", style=wx.ALIGN_LEFT), 0, wx.EXPAND), 
                    (wx.StaticText(self, label="2nd", style=wx.ALIGN_LEFT), 0, wx.EXPAND),  
                    (wx.StaticText(self, label="3rd", style=wx.ALIGN_LEFT), 0, wx.EXPAND), 
                    (wx.StaticText(self, label="Other", style=wx.ALIGN_LEFT), 0, wx.EXPAND) ])

        self.RoomPrefFields = [wx.StaticText(self, size=self.sz_num_field, style=wx.ALIGN_LEFT), 
                wx.StaticText(self, size=self.sz_num_field, style=wx.ALIGN_LEFT), 
                wx.StaticText(self, size=self.sz_num_field, style=wx.ALIGN_LEFT), 
                wx.StaticText(self, size=self.sz_num_field, style=wx.ALIGN_LEFT)] 
        fgs.Add(wx.StaticText(self, label="Rooms   ", style=wx.TE_LEFT), flag = wx.EXPAND)
        for field in self.RoomPrefFields:
            fgs.Add(field, flag=wx.EXPAND)

        self.TimePrefFields = [wx.StaticText(self, size=self.sz_num_field, style=wx.ALIGN_LEFT), 
                wx.StaticText(self, size=self.sz_num_field, style=wx.ALIGN_LEFT), 
                wx.StaticText(self, size=self.sz_num_field, style=wx.ALIGN_LEFT), 
                wx.StaticText(self, size=self.sz_num_field, style=wx.ALIGN_LEFT)]
        fgs.Add(wx.StaticText(self, label="Times   ", style=wx.TE_LEFT), flag = wx.EXPAND)
        for field in self.TimePrefFields:
            fgs.Add(field, flag=wx.EXPAND)

        self.SetSizerAndFit(box_sizer)
        pub.subscribe(self.updatePrefs, "assignments_calced")

    def LoadMarkets(self):
        self.markets = self.session.GetAvailableMarkets()

        if self.markets == None:
            return False

        self.treeMarkets.DeleteAllItems()
        root = self.treeMarkets.AddRoot('Markets')

        # Add all markets to the tree
        items = {}
        for market in self.markets:
            path = ''
            parent = root
            # Iterate over the market path
            for item in market.menuPathParts:
                path = path + item
                if path in items:
                    parent = items[path]
                    continue
                # Add this node if it doesn't exist
                parent = items[path] = self.treeMarkets.AppendItem(parent, item)
            # After all of the parent nodes are present, at the market type
            items[path + market.marketName] = self.treeMarkets.AppendItem(items[path], market.marketName)
            # Attach the market information to the tree object for extraction later
            self.treeMarkets.SetPyData(items[path + market.marketName], market)

        self.treeMarkets.Expand(root)

        pub.sendMessage(SUBJECT_STATUSBAR,
            'Found ' + str(len(self.markets)) + ' available ' + self.session.sessionType + ' markets')

        return True

	def __init__(self, *args, **kwargs):
		"""
		General Notebook class for Diagram Notebook on the right part of DEVSimPy.
		"""

		# for splash screen
		pub.sendMessage('object.added', message='Loading notebook diagram...\n')

		Printable.__init__(self)

		# local copy
		self.parent = args[0]
		self.pages = []			# keeps track of pages

		### to propagate the dsp file path in __setstate__ of Block object
		self.current_dsp_file_path = ""

		#icon under tab
		imgList = wx.ImageList(16, 16)
		for img in [os.path.join(ICON_PATH_16_16,'network.png')]:
			imgList.Add(wx.Image(img, wx.BITMAP_TYPE_PNG).ConvertToBitmap())
		self.AssignImageList(imgList)

		### binding
		self.Bind(wx.EVT_LEFT_DCLICK, self.__AddPage)

	def __onNewFile(self, event):
		data = {
				'file': None,
				'prjid': None
				}

		pub.sendMessage('notebook.addpage', data)

    def __init__(self, iview):
        '''
        Constructor
        '''
        # ---- projectos
        pub().subscribe(self.add_project_in_tree, T.ADD_PROJECT_IN_TREE)
        pub().subscribe(self.pre_close, T.CLOSE_PROJECT)
        pub().subscribe(self.pre_open, T.OPEN_PROJECT)
        pub().subscribe(self.pre_hide, T.HIDE_PROJECT)
        pub().subscribe(self.pre_unhide, T.UNHIDE_PROJECT)
        pub.subscribe(self.pre_delete, T.DELETE_PROJECT)
        pub().subscribe(self.update_language, T.LANGUAGE_CHANGED)

        # ---- vistas
        pub().subscribe(self.add_view_in_tree, T.ADD_VIEW_IN_TREE)
        pub().subscribe(self.delete_view, T.DELETE_VIEW_TREE)

        # --- results
        pub().subscribe(self.add_results_in_tree, T.ADD_RESULTS_IN_TREE)
        pub().subscribe(self.delete_result, T.DELETE_RESULT_TREE)

        self.iview = iview
        self.init_tree()

        # ---- variables de estado
        self.last_sate_project = None
        self.less_project = False

 def _show_toolbars(self, event):
     if self._toolbars_shown:
         pub.sendMessage(topic='HIDE_TOOLBAR', data=None)
         self._toolbars_shown = False
     else:
         pub.sendMessage(topic='SHOW_TOOLBAR', data=None)
         self._toolbars_shown = True

 def _RealtimeMode(self):
     now = datetime.datetime.now() 
     oldtime = self.lastupdate + datetime.timedelta(seconds=self.period)
     if self.lastupdate.date().year != 2000:            
         if oldtime.date() != now.date():
             oldtime = datetime.datetime(now.date().year, now.date().month, now.date().day, 9, 30, 0) + datetime.timedelta(seconds=self.period)
         if self.lastupdate.time() == datetime.time(11, 30, 0):
             oldtime = datetime.datetime(self.lastupdate.date().year, self.lastupdate.date().month,  self.lastupdate.date().day, 13, 0, 0)\
             + datetime.timedelta(seconds=self.period)
                                    
     
               
     #now =  datetime.datetime(now.year, now.month, now.day, now.hour, now.minute) 
     
     if now > oldtime :
         print now, ",",  oldtime                
         q = GoogleIntradayQuote(self.symbol,self.period, self.num_day)
         if self.lastupdate == q.df.index[-1]:
             return
         if True:#q.dtstamp[-1] == now:
             self.lastupdate = q.df.index[-1]
             if self.period == 60:
                 self.realtimedata = q.df
                 pub.sendMessage(self._message_topic, self.realtimedata) 
             else:                    
                 self.quotedata = q
                 pub.sendMessage(self._message_topic, self.quotedata.df) 

    def pluginMenu(self, evt):

        #Wont need this check once Issue 72 is fixed.
        if self.data.has_key('rtdose'):

            #Load RTPlan and first DICOM slice.
            rtd = self.data['rtdose']
            ct1 = self.data['images'][0]
            #Number of slices.
            N = len(self.data['images'])

            #Get slice spacing t, use difference instead of tags to get direction.
            t = self.data['images'][1].ImagePositionPatient[2]-self.data['images'][0].ImagePositionPatient[2]
            zpos = ct1.ImagePositionPatient[2]
            #Check current type of GFOV and switch.
            if rtd.has_key('GridFrameOffsetVector'):
                if rtd.GridFrameOffsetVector[0] == 0.:
                    logger.info("Found Type A - Relative Coordinates\nConverting to Type B - Absolute")
                    #Convert to Type B (Absolute)
                    rtd.GridFrameOffsetVector = list(np.arange(zpos, zpos + t*N, t))
                elif rtd.GridFrameOffsetVector[0] == zpos:
                    logger.info("Found Type B - Absolute Coordinates\nConverting to Type A - Relative")
                    #Convert to Type A (Relative)
                    rtd.GridFrameOffsetVector = list(np.arange(0., abs(t)*N,abs(t)))
            else:
                logger.info("GridFrameOffsetVector key not found in RT-Dose!")

            #Print results.
            np.set_printoptions(precision=2)
            logger.info(np.array(rtd.GridFrameOffsetVector))
            #Publish new rtdose.
            pub.sendMessage('patient.updated.raw_data', self.data)

        else:
            logger.info("Please load a RT-Dose file!")

    def run(self):

        old = datetime.datetime.now() + datetime.timedelta(minutes = -1)
        old = datetime.datetime(old.year, old.month, old.day, old.hour, old.minute)
        while not self.done:
            try:                
                now = datetime.datetime.now()                
               # print now, "  ", old
                
                if self._IsMarketOpen(now):#now > old: 
                    self._RealtimeMode() 
                    #time.sleep(1)                   
 
                else:
                    q = GoogleIntradayQuote(self.symbol,self.period, self.num_day)
                    self.quotedata = q
                    pub.sendMessage(self._message_topic, self.quotedata.df) 
                    self.done = True 
                time.sleep(1)   
                        
                         
     
                
            except:
                print str(sys.exc_info())
                self.done = False

 def GetQuoteData(self, quote, period=300, num_day=5): 
     try:       
         self.quotedata = GoogleIntradayQuote(quote,period, num_day)
         pub.sendMessage("ANALYSISDATA", self.quotedata.df)
         return self.quotedata
     except:
         pass       

def _createRooms(d, roomInventory, respectRoom, num_prefs = 3):
    """return a prefernece ordered, list of rooms.  
    d is a dictionary of room_prefs {"Room 1":"E51-135", "Room 2":"E62-133"}
    blank requests are ignored.
    Rooms not in inventory will be created if respectRoom = True.
    If room not inventory, and not "respect", will log error."""
    out, all_in_inv = [], True
    for ix_pref in range(1, num_prefs + 1):
        roomName = d.get("Room " + str(ix_pref), "").strip()
        del d["Room " + str(ix_pref)]

        if not roomName:
            continue
        
        #search for it in the list.  
        room_list = filter(lambda x: str(x) == roomName, roomInventory)
        
        if room_list:
            assert len(room_list) == 1
            out.append(room_list[0])
#         elif respectRoom:
#             out.append(ses.Room(roomName, ses.Room.MAX_SIZE))
        else:
            out.append(ses.Room(roomName, ses.Room.MAX_SIZE))
            all_in_inv = False

            #only issue warning if not respect room
            if not respectRoom:
                pub.sendMessage("warning", "Room %s not in inventory" % roomName)


    return out, all_in_inv

    def __init__(self, app):

        self.mainwindow = MyParentFrame()
        self.mainwindow.Bind(wx.EVT_MENU, self.On5MinAnalysis, id=ID_Menu_5Min)
        self.mainwindow.Bind(wx.EVT_MENU, self.On30MinAnalysis, id=ID_Menu_30Min)
        self.mainwindow.Bind(wx.EVT_MENU, self.OnDayAnalysis, id=ID_Menu_Day)
        self.mainwindow.Bind(wx.EVT_MENU, self.OnNewRealtimeWindow, id=ID_Menu_Realtime)

        self.mainwindow.Show(True)
        app.SetTopWindow(self.mainwindow)

        self.mainwindow.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
        self.mainwindow.symbol_ctrl.Bind(wx.EVT_TEXT_ENTER, self.OnSymbolCtrlEnter)

        self.data_manager = DataManager()
        self.data_manager.start()
        self.symbol = "000001"
        self.data_manager.UpdateSymbol(self.symbol)
        # self.realtime_data = self.data_manager.GetQuoteData(self.symbol, 60, 1).df
        # self.analysis_data = self.data_manager.GetQuoteData(self.symbol, 1800, 30).df
        self._lastclose = self.data_manager.GetLastClose(self.symbol)
        self.realtime_data = None
        self.analysis_data = None
        # for d in self.data_manager.symbol_quote_dict.keys():
        pub.subscribe(self.AnalysisDataArrive, "ANALYSISDATA")
        pub.subscribe(self.RealtimeDataArrive, "REALTIMEDATA")
        self.mainwindow.SetFocus()
        self.realtime_window = None
        self.analysis_window = None

 def _update_strategy(self, value=None):
     '''
         Called when a control_panel's value is changed and is valid.  Also
     called when the user changes the method of a stage.
     '''
     strategy = self.get_current_strategy()
     pub.sendMessage('SET_CURRENT_STRATEGY', data=strategy)

    def save(self):
        fout = open("library.db",'wb')
        pickle.dump(self.books,fout)
        fout.close()

        print "Saved", len(self.books), "books"
        pub.sendMessage("SAVED",len(self.books))