root/experimental/components/rc2007_gui/rc2007_gui.py @ 4805

#! /usr/bin/env python

'''
/****************************************************************************

Copyright 2007 Virginia Polytechnic Institute and State University

This file is part of the OSSIE rc2007_gui.

OSSIE rc2007_gui is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

OSSIE rc2007_gui is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with OSSIE rc2007_gui; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

****************************************************************************/

'''

from omniORB import CORBA
from omniORB import URI
import CosNaming
import CF, CF__POA
import standardInterfaces__POA
import customInterfaces__POA
import sys

import threading
import time        # primarily availble for time.sleep() statements

import wx          # gui stuff
import wx_inits    # my frame init code: specific to this application


#-------------------------------------------------------------
# rc2007_gui_i class definition (main component class)
#-------------------------------------------------------------
class rc2007_gui_i(CF__POA.Resource):
    def __init__(self, uuid, label, poa):
        CF._objref_Resource.__init__(self._this())
        print "rc2007_gui_i __init__: " + label
        self.naming_service_name = label
        self.poa = poa

        self.inPort0_servant = dataIn_complexShort_i(self, "gui_sound_in")
        self.inPort0_var = self.inPort0_servant._this()

        self.outPort0_servant = dataOut_complexShort_i(self, "gui_sound_out")
        self.outPort0_var = self.outPort0_servant._this()
        self.outPort0_active = False

        
        self.WorkModule_created = False

        self.propertySet = []
        self.work_mod = None
        
    def start(self):
        print "rc2007_gui start called"
        
    def stop(self):
        print "rc2007_gui stop called"
        
    def getPort(self, id):
        if str(id) == "gui_sound_in":
            return self.inPort0_var
        if str(id) == "gui_sound_out":
            return self.outPort0_var
        
        return None  #port not found in available ports list
        
    def initialize(self):
        print "rc2007_gui initialize called"
    
    def configure(self, props):
        ''' The configure method is called twice by the framework:
        once to read the default properties in the component.prf
        file, and once to read the component instance properties
        storred in the waveform.sad file.  This method should be
        called before the start method.  This method is where
        the properties are read in by the component.  
        ''' 

        print "rc2007_gui configure called"
        

    def query(self, props):
        return self.propertySet
    
    def releaseObject(self):
        # release the main work module
        self.work_mod.Release()
        
        # release the main process threads for the ports
        self.outPort0_servant.releasePort()
                
        # deactivate the ports
        iid0 = self.poa.reference_to_id(self.inPort0_var)
        oid0 = self.poa.reference_to_id(self.outPort0_var)

        self.poa.deactivate_object(iid0)
        self.poa.deactivate_object(oid0)


#------------------------------------------------------------------
# dataIn_complexShort_i class definition
#------------------------------------------------------------------
class dataIn_complexShort_i(standardInterfaces__POA.complexShort):
    def __init__(self, parent, name):
        self.parent = parent
        self.name = name

    def pushPacket(self, I, Q):
        self.parent.work_mod.AddData(I, Q)


#------------------------------------------------------------------
# dataOut_complexShort_i class definition
#------------------------------------------------------------------
class dataOut_complexShort_i(CF__POA.Port):
    def __init__(self, parent, name):
        self.parent = parent
        self.outPorts = {}
        self.name = name
        
        self.data_buffer = []
        self.data_event = threading.Event()
        self.data_buffer_lock = threading.Lock()
        
        self.is_running = True
        self.process_thread = threading.Thread(target = self.Process)
        self.process_thread.start()

    def connectPort(self, connection, connectionId):
        port = connection._narrow(standardInterfaces__POA.complexShort)
        self.outPorts[str(connectionId)] = port
        self.parent.outPort0_active = True

    def disconnectPort(self, connectionId):
        self.outPorts.pop(str(connectionId))
        if len(self.outPorts)==0:
            self.parent.outPort0_active = False

    def releasePort(self):
        # shut down the Process thread
        self.is_running = False
        self.data_event.set()

    def send_data(self, I, Q):
        self.data_buffer_lock.acquire()
        self.data_buffer.insert(0, (I,Q))
        self.data_buffer_lock.release()
        self.data_event.set()

    def Process(self):
        while self.is_running:
            self.data_event.wait()
            while len(self.data_buffer) > 0:
                self.data_buffer_lock.acquire()
                new_data = self.data_buffer.pop()
                self.data_buffer_lock.release()
                
                for port in self.outPorts.values():
                    port.pushPacket(new_data[0], new_data[1])
                
                self.data_event.clear()



#-------------------------------------------------------------------
# ORB_Init class definition
#-------------------------------------------------------------------
class ORB_Init:
    """Takes care of initializing the ORB and bind the object"""
    
    def __init__(self, uuid, label):
        # initialize the orb
        self.orb = CORBA.ORB_init()
        
        

def ORB_start_fun():
        orb_ref = orb

        # get the POA
        obj_poa = orb_ref.orb.resolve_initial_references("RootPOA")
        poaManager = obj_poa._get_the_POAManager()
        poaManager.activate()
        
        ns_obj = orb_ref.orb.resolve_initial_references("NameService")
        rootContext = ns_obj._narrow(CosNaming.NamingContext)
        
        # create the main component object
        orb_ref.USRP_Commander_GUI_Obj = USRP_Commander_GUI_i(orb_ref,
                                                              uuid, 
                                                              label, 
                                                              obj_poa)
        USRP_Commander_GUI_var = orb_ref.USRP_Commander_GUI_Obj._this()
        
        name = URI.stringToName(label)
        rootContext.rebind(name, USRP_Commander_GUI_var)


        orb_ref.orb.run()


#-------------------------------------------------------------------
# wx.App for the GUI
#-------------------------------------------------------------------
class App(wx.App):
    def OnInit(self):
        self.frame = wx_inits.Frame()
        self.frame.Show()
        self.SetTopWindow(self.frame)

        return True


class my_threads:
    def __init__(self):

        # start the orb that has already been initialized in a thread
        self.orb_thread = threading.Thread(target=ORB_start_fun)
        self.orb_thread.start()

        self.app_thread = threading.Thread(target=app.MainLoop)
        self.app_thread.start()

        
#-------------------------------------------------------------------
# Code run when this file is executed
#-------------------------------------------------------------------
if __name__ == "__main__":
    if len(sys.argv) != 3:
        print sys.argv[0] + " <id> <usage name> "
    
    uuid = str(sys.argv[1])
    label = str(sys.argv[2])
    
    print "Identifier - " + uuid + "  Label - " + label
    
    # initialize the orb, but do not start it
    orb = ORB_Init(uuid, label)
    
    # initialize the wx stuff
    app = App()

    # now that orb and app exist, I can start them
    # note that they must be created first so that they can reference
    # each other when they start 
    threads_running = my_threads()