C:/work/RevealedSystems/EyeSpy-RS/eyespy/src/objects/gui/mainFrame.py

Go to the documentation of this file.

# Copyright (C) 2008-2009  Mark Hanegraaff
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.


import wx
import images
from threading import  Event, RLock

from matplotlib.figure import Figure

import time
import copy

import webbrowser

from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg

from objects.logic.common.exception import exception
from objects.logic.common.globalStrings import globalStrings
from objects.logic.common.logger import logger
from networkSettings import networkSettings
from figureAxesWrapper import figureAxesWrapper
from objects.gui.displayer.applicationEntityDisplayer import applicationEntityDisplayer 
from objects.logic.entity.networkEntity import networkEntity

from objects.gui.displaySettings import displaySettings
from objects.gui.filterSettings import filterSettings
from objects.gui.appOptions import appOptions

from objects.gui.peerGridDisplay import peerGridDisplay
from objects.gui.mainFrameToolbar import mainFrameToolbar
from objects.gui.mainFrameMenuBar import mainFrameMenuBar
from objects.gui.mainFrameToolWindow import mainFrameToolWindow
from objects.gui.pictureSaverDialog import pictureSaverDialog
from objects.gui.traceDisplayDialog import traceDisplayDialog
from objects.gui.aboutDialog import aboutDialog
from objects.gui.mainFrameMap import mainFrameMap

from objects.gui.mainFramePopupMenu import mainFramePopupMenu


from objects.logic.entity.filter.baseFilter import baseFilter
from objects.logic.entity.filter.customFilter import customFilter
from objects.gui.animatedLoaderIcon import animatedLoaderIcon
from objects.gui.startupSplashScreen import startupSplashScreen

from objects.gui.threads.mouseHoverThread import mouseHoverThread, EVT_DISPLAY_TOOLINFOWIN
from objects.gui.threads.redrawThread import redrawThread

from objects.geoip.geoIPUtils import geoIPUtils



VIEW_STATE_ZOOM = "VIEW_STATE_ZOOM"
VIEW_STATE_PAN = "VIEW_STATE_PAN"
VIEW_STATE_UNDEFINED = "VIEW_STATE_UNDEFINED"
VIEW_STATE_SETHOMELOC = "VIEW_STATE_SETHOMELOC"
                                


## FigureCanvasWxAgg subclass, overriding the _onPaint method, so that
# the draw method is only called for the first two paint events. After that,
# the canvas will only be redrawn when it is resized.
# I forget why this is needed. It was recommended by the Matplotlib documentation. I'm not sure how useful it really is.
class NoRepaintCanvas(FigureCanvasWxAgg):
    def __init__(self, *args, **kwargs):
        FigureCanvasWxAgg.__init__(self, *args, **kwargs)
        self._drawn = 0

    def _onPaint(self, evt):
        #
        #Called when wxPaintEvt is generated
        #
        if not self._isRealized:
            self.realize()
        if self._drawn < 2:
            self.draw(repaint = False)
            self._drawn += 1
        self.gui_repaint(drawDC=wx.PaintDC(self))


## The mainFrame class represents the application's main window. This is where the action is.
# All event processing is managed from this class, and just about all gui components originate from here
# in one way or another.
class mainFrame(wx.Frame):
            
    def __init__(self, parent, id, title, eyeSpyApp, displayConfig, appConfig, color = None,\
        dpi = None, style = wx.NO_FULL_REPAINT_ON_RESIZE, **kwargs):
        
        startupSplah = startupSplashScreen(None)
        
        self.mainApp = eyeSpyApp
        self.selectedNetworkDevice = None
        
        self.dispConf = displayConfig 
        self.optConfig = appConfig        
                
        wx.Frame.__init__(self, parent, id, title)
        
        # set the icon
        appIcon = wx.Icon(globalStrings.eyespy_icon, wx.BITMAP_TYPE_ICO)
        self.SetIcon(appIcon)


        try:            
            #self.menuBarContainer = mainFrameMenuBar(self)
            self.toolbarContainer = mainFrameToolbar(self)            
            self.createStatusBar()
            self.createPanel()
        except exception, e:
            startupSplah.Close()
            self.die(e.reason)
            return
        
        #rubberbanding related
        self.rubber_start        = wx.Point(0,0)
        self.rubber_end          = wx.Point(0,0)
        
        self.lbuttonDown         = False
        
        self.initializeThreads()
        
        #display related                
        self.displayMode = VIEW_STATE_ZOOM
        self.displayer = applicationEntityDisplayer(self.dispConf)
        
        self.cursor = wx.StockCursor(wx.CURSOR_ARROW)
        
        self.currentZoomLevel = None
        
        # network device selection
        saveDeviceSelection        = appConfig.network_getSaveDeviceSelection()
        
        if saveDeviceSelection == True:
            self.selectedNetworkDevice = appConfig.network_getSelectedDevice()


        # Mouse events
        self.currentMousePosition = None
        self.lastMouseMoveTime = None
        
        self.numPeers = 0  
        self.numDisplayedPeers = 0
        
        # tip window
        self.tipWin = None                        
        self.canDisplayTipWin = True
        
        #filtering
        self.PeerFilter = customFilter()

        # window message related
        self.isWindowMinimined = False
        
        ## Add matplotlib gui hooks
        self.figure = Figure(None, dpi)
        self.canavas = NoRepaintCanvas(self.panel, -1, self.figure)
        
        ## draw the initial plot  
        self.createMap(self.dispConf.map_getMapDetail(), self.dispConf.map_getDrawCSBorders(), self.dispConf.map_getDrawRivers())        
        
        ## Additional initialization        
        self._resizeflag = True
        self._SetSize()
        
        # right click menu
        self.rclickMenu = mainFramePopupMenu(self)
                    
        #bind events
        self.doBindings()
        
        self.animLoaderIcon = animatedLoaderIcon(self.toolbarContainer.toolbar, globalStrings.animated_img_in_progress, (800 - 50,3))
        
        self.startMouseHoverThread()
        
        startupSplah.Close()
        
        self.redrawCycle()
        
        
        # as a final step, check to see if the GEO IP Database is installed.
        # If it is not, then output a warning
        # check to see if any GEO IP files need to be updated
        geoUtils = geoIPUtils("")
        if (geoUtils.isGEOIPDatabaseInstalled() == False):
            
            msg = "EyeSpy makes use of a non free GEO IP Database which is not shipped with the application.\n\n"
            msg += "EyeSpy supports the MaxMind Database which is available by either purchasing a commercial license from MaxMind "
            msg += "or by downloading a free, personal use copy of it from their web site. Once downloaded, the database can be imported using EyeSpy's 'About' page.\n\n"
            
            msg += "Although EyeSpy is a free application, usage of the GEO IP Database is still bound by MaxMind's terms.\n\n"
            
            msg += "For additional Information, please visit EyeSpy's home page."
            msg += "\n\n"
            msg += "( " + self.optConfig.navigation_getAppHomePage() + " )"
            
            dlg = wx.MessageDialog(None, msg, 'Please Note...', wx.ICON_WARNING)
            result = dlg.ShowModal()
            dlg.Destroy()
            


    ## Defines the GUI thread variables, and initialized the class' lock
    def initializeThreads(self):
        self.lck = RLock()
        
        #Redraw Thread
        self.autoRedrawThread = None                            
        
        #Mouse Hover Thread        
        self.mouseHoverThread = None                



    ## Performs a mouse hit test. Given a mouse position it will either return nothing
    # or it will return a list of networkEntityObjects representing the Endpoints below right under mouse
    # This method is normally called when the mouseHoverThread detects that the mouse has stopped moving
    # @param pos Mouse Position object
    # @return List of networkEntity objects
    def hitTest(self, pos):    
        entityDict = self.mainApp.entityMan.getSafeFilteredEntityCollectionByGeoLoc(None)
                
        w_h = self.canavas.get_width_height()        
        x,y = pos.x, w_h[1] - pos.y
        
        #get zoom factor
        zoomFactor = self.fig_axes.getZoomFactor()
        
        #get hit range factor
        hitRange = zoomFactor/90 #(90 is the magic number)
        
        mouseMapX, mouseMapY = self.fig_axes.getAxesXYFromMouseXY( x, y)                
        
        for key, entList in entityDict.iteritems():
            
            entX, entY = self.worldMainMap.main_map(key[0], key[1])
            
            #get deltas
            deltaX = abs(entX - mouseMapX)
            deltaY = abs(entY - mouseMapY)
                        
            if (mouseMapX >= entX - hitRange and mouseMapX <= entX + hitRange):
                if (mouseMapY >= entY - hitRange and mouseMapY <= entY + hitRange):
                    # hit                    
                    return entList
        return None  
     
     
                 
    ## "OnSize" handler
    # @param event Standard wx.Button event 
    def _OnSize(self, event):
        size = event.GetSize()
        self._resizeflag = True
        
        self.panelSize = size
        #print "size:", size.width, size.height
                
                
                
    ## "OnMinimize" handler. Handles the main window being minimized
    # @param event Standard wx.Button event        
    def _OnMinimize(self, event):
        self.isWindowMinimined = not self.isWindowMinimined
        print "Minimized"
        
        # redraw when restoring
        if self.isWindowMinimined == False:
            self.redrawCycle()                                                                          
    
    
    
    ## "OnLButtonDown" handler. Deals with things like potential zooming and panning
    # @param event Standard wx.Button event 
    def _OnLButtonDown(self, event):
        if not event: return
        
        pos = event.GetPosition()
        
        # if outside the figure, get out of here...
        if not self.fig_axes.axes.in_axes(pos.x, pos.y): return
        #MH##if not self.fig_axes.axes.in_axes(pos): return
        
        if self.displayMode == VIEW_STATE_ZOOM or self.displayMode == VIEW_STATE_PAN:
            # Left mouse button down, change cursor to
            # something else to denote event capture
            self.rubber_start = event.GetPosition()
            
            self.rubber_end = self.rubber_start
            self.lbuttonDown = True
    
    
    
    ## "OnMouseWheel" handler. Deals with in-place zooming
    # @param event Standard wx.Button event
    def _OnMouseWheel(self, event):
        rot = event.GetWheelRotation()
        
        if rot >= 0:
            self.handleZoomIn(None)
        else:
            self.handleZoomOut(None)
            
            
            
    ## "OnIdle" handler. Mainly deals with resizing and repaining the screen.
    # @param evt Standard wx.Button event
    def _OnIdle(self, evt):
        if self._resizeflag:                                 
            # resize the panel
            
            self.lck.acquire(1)
            try: 
                self.SetSizeWH(self.panelSize.width, self.panelSize.height)
                self.panel.SetSize( wx.Size( self.panelSize.width, self.panelSize.height ) )
                
                # redraw
                self._resizeflag = False
                self._SetSize()
            finally:
                self.lck.release()                        
            
            # reposition the animated loader icon
            self.animLoaderIcon.changePos((self.panelSize.width - 50, 3))
        
        
    
    ## "OnMouseMove" handler. Mainly deals with zooming and panning issues.
    # @param event Standard wx.Button event
    def _OnMouseMove(self, event):
        if not event: return                    
                
        pos = event.GetPosition()
        
        # save current Position
        self.currentMousePosition = pos
        self.lastMouseMoveTime = time.time()
        
        self.setStatusBarText(pos);      
        
        
        if self.displayMode == VIEW_STATE_PAN:
            self.rubber_end =  event.GetPosition()
            pass
        
        elif self.displayMode == VIEW_STATE_ZOOM:            
            if self.lbuttonDown: #if I am holding the mouse button, then zoom
                dc= wx.ClientDC(self.canavas)
                
                
                # Set logical function to XOR for rubberbanding
                dc.SetLogicalFunction(wx.XOR)
                
                wbrush = wx.Brush(wx.Colour(255,255,255), wx.TRANSPARENT)
                wpen = wx.Pen(wx.Colour(200, 200, 200), 1, wx.DOT)
                
                dc.SetBrush(wbrush)
                dc.SetPen(wpen)
                
                # reset dc bounding box
                dc.ResetBoundingBox()
                dc.BeginDrawing()
    
                w = (self.rubber_end.x - self.rubber_start.x)
                h = (self.rubber_end.y - self.rubber_start.y)
                
                
                # To erase previous rectangle
                dc.DrawRectangle(self.rubber_start.x, self.rubber_start.y, w, h)
                
                # Draw new rectangle
                self.rubber_end =  event.GetPosition()
                
                w = (self.rubber_end.x - self.rubber_start.x)
                h = (self.rubber_end.y - self.rubber_start.y)
                
                # Set clipping region to rectangle corners
                dc.SetClippingRegion(self.rubber_start.x, self.rubber_start.y, w,h)
                dc.DrawRectangle(self.rubber_start.x, self.rubber_start.y, w, h) 
                dc.EndDrawing()
    
    
    
    ## "OnLButtonUp" handler. Mainly deals with zooming and panning issues.
    # @param event Standard wx.Button event 
    def _OnLButtonUp(self, event):        
        if not event: return
        
        self.canDisplayTipWin = True
        
        if self.displayMode == VIEW_STATE_PAN:
            self._OnPan(event)            
              
        
        elif self.displayMode == VIEW_STATE_ZOOM:             
            self._OnZoom(event)
                                    
        elif self.displayMode == VIEW_STATE_SETHOMELOC:
            self._OnSetHomeLocation(event)            
            
            
            
    ## "OnZoom" is just a helper function for the OnLButtonUp event handler. As you may guess, it deals with zooming
    # @param event Standard wx.Button event
    def _OnZoom(self, event):
        pos = event.GetPosition()
        if not self.fig_axes.axes.in_axes(pos.x, pos.y): 
        #MH##if not self.fig_axes.axes.in_axes(pos):
                self.lbuttonDown = False
                self.rubber_start = None
                self.rubber_end = None
                
                self.redrawCanavasLock()
                
                return
        self.rubber_end = event.GetPosition()              
        # make sure this event is not triggered accidentally
        if (self.rubber_end == None or self.rubber_start == None): return        
        if abs(self.rubber_end.x-self.rubber_start.x)<5 or abs(self.rubber_end.y-self.rubber_start.y)<5:
                self.rubber_start = None
                self.rubber_end = None
                self.lbuttonDown = False
                self.redrawCanavasLock()
                return
        
        #invert the x/y axis for this
        w_h = self.canavas.get_width_height()
        self.rubber_start.y = w_h[1] - self.rubber_start.y
        self.rubber_end.y = w_h[1] - self.rubber_end.y
        
        # track whether we have changed the zoom factor
        # i.e. from continent to city/state
        # if so, refresh the map points
        newZoomFactor = None
        filter = baseFilter()
        
        self.lck.acquire(1)
        try: 
            self.fig_axes.freeZoomChangeAspect(self.rubber_start, self.rubber_end, self.canavas.GetSize())
            newZoomLevel = filter.getUserFriendlyZoomLevel(self.fig_axes.getZoomFactor())
        finally:
            self.lck.release()
            
        # if the zoom level changes, then redraw the map points
        if self.currentZoomLevel is not None and (self.currentZoomLevel != newZoomLevel):                
            self.redrawCycle()
        
        self.currentZoomLevel = newZoomLevel            
        
        self.redrawCanavasLock()
        
        self.lbuttonDown = False
        self.rubber_start = None
        self.rubber_end = None
    
    
    
    ## "OnPan" is just a helper function for the OnLButtonUp event handler. As you may guess, it deals with panning
    # @param event Standard wx.Button event
    def _OnPan(self, event):
        self.rubber_end = event.GetPosition()            
            
        self.lck.acquire(1)
        try: 
            self.fig_axes.pan(self.rubber_start, self.rubber_end)
        finally:
            self.lck.release()
        
        self.redrawCanavasLock()
        
        self.lbuttonDown = False
        self.rubber_start = None
        self.rubber_end = None
    
    
    
    ## "OnSetHomeLocation" button handler. It will essentially set the home location marker onto the map.
    # @param event Standard wx.Button event
    def _OnSetHomeLocation(self, event):
        pos = event.GetPosition()
        
        # this should go into a utility somewhere
        w_h = self.canavas.get_width_height()
        x,y = pos.x, w_h[1] - pos.y
        lon, lat = self.fig_axes.getLonLatFromMouseXY(x,y, self.worldMainMap.main_map)
        
        strLon = "%3.2f" % (lon)
        strLat = "%3.2f" % (lat)
        
        strLon = strLon.rjust(10, " ")
        strLat = strLat.rjust(10, " ")
        
        msg = "Would you like to make:\n\nLon:%s\nLat:%s\n\nYour new home location?" % (strLon, strLat)
        
    
        dlg = wx.MessageDialog(None, msg, 'Please Confirm...', wx.YES_NO | wx.ICON_QUESTION)
        result = dlg.ShowModal()
        dlg.Destroy()
        
        if result == wx.ID_YES:
            # set new home location
            self.optConfig.ident_setManualCoord((lon, lat))
            self.optConfig.ident_setIdentByCoord()
            
            self.redrawCycle()
            #self.redrawCanavasLock()
    
    
    
    ## "OnRButtonUp" handler. This is the Right Button up handler. This is how the context menu is displayed
    # @param event Standard wx.Button event   
    def _OnRButtonUp(self, event):
        
        pos = event.GetPosition()
        
        self.canDisplayTipWin = False
        
        self.entListSelection = self.hitTest(pos)
        if self.entListSelection is not None:
            self.entListSelection = copy.deepcopy(self.entListSelection)
        
        
        self.rclickMenu.buildMenuFromEntList(self.entListSelection)
            
        popupMenu = self.rclickMenu.getMenu()
        
        try:      
            self.PopupMenu(popupMenu, event.GetPosition())
        except Exception, e:
            logger.log(__name__ + ": Exception creating popup menu:")
            logger.log(__name__ + str(e))
        
    
    
    ## Helper function used by _OnIdle.
    # This method will essentially force the map to always preserve the aspect ratio of the window (i.e. after the window shape is changed)
    # @param pixels Rectangle used as a reference for the aspect ration. If None, it will use the Client rectangle.
    def _SetSize(self, pixels = None):
        
        if not pixels:
            pixels = self.GetClientSize()
            
        self.fig_axes.adjustAxisToCanavas( pixels )
               

        self.canavas.SetSize(pixels)
        self.figure.set_size_inches(pixels[0]/self.figure.get_dpi(),
                                               pixels[1]/self.figure.get_dpi())
        
        #self.fig_axes.adjustAxisToCanavas( self.canavas.GetSize() )
        self.redrawCanavasLock()
                
        
        
    ## Sets the status bar text.
    # @param pos Mouse position (use to mark the longitude/latitude coordinates).
    def setStatusBarText(self, pos):
        if pos == None: return
        
        filter = baseFilter()
        zoomLevel = filter.getUserFriendlyZoomLevel(self.fig_axes.getZoomFactor())
        
        w_h = self.canavas.get_width_height()        
        x,y = pos.x, w_h[1] - pos.y
        lon, lat = self.fig_axes.getLonLatFromMouseXY(x,y, self.worldMainMap.main_map)
        statusText = "lon:%4.2f, lat:%4.2f -- Zoom: %s -- Tracking: %d Peers -- Displaying: %d Peers"  % (lon, lat, zoomLevel, self.numPeers, self.numDisplayedPeers)
        self.statusBar.SetStatusText(statusText)
    


    ## Creates a the actual Map which is displayed onto the main window (onto the canavas to be precise).
    # Note that all parameters are retrieved from the application configuration file.
    # @param mapDetail Map Detail Level 
    # @param drawCSBorders True if the map should display country and state borders
    # @param drawRivers True if the map should display rivers 
    def createMap(self, mapDetail, drawCSBorders, drawRivers):
        ax = self.figure.add_axes([0,0,0.99,0.99])
        self.fig_axes = figureAxesWrapper(ax)
        self.fig_axes.axes.set_axis_bgcolor('aqua')
        
        self.worldMainMap = mainFrameMap(self.fig_axes)
        self.worldMainMap.createMap(mapDetail, drawCSBorders, drawRivers)
        
        # set initial zoom
        self.fig_axes.computeFullXYLim()
        self.fig_axes.resetZoom()
        
        filter = baseFilter()            
        self.currentZoomLevel = filter.getUserFriendlyZoomLevel(self.fig_axes.getZoomFactor())
    
    
    
    ## Re-Creates the map. This is usually done right after some map setting is being changed (the app allows you to do this without restarting).
    # @param mapDetail Map Detail Level 
    # @param drawCSBorders True if the map should display country and state borders
    # @param drawRivers True if the map should display rivers    
    def recreateMap(self, mapDetail, drawCSBorders, drawRivers):
        
        recycleThreads = self.redrawThreadIsRunning()         
        
        popup = wx.SplashScreen(wx.Image(name = globalStrings.redraw_map_message).ConvertToBitmap(), 
                                         wx.SPLASH_CENTRE_ON_SCREEN , -1, self)        
        
        if recycleThreads:
            self.stopAllThreads()
        else:
            self.stopMouseHoverThread()
        
        xlim, ylim = self.fig_axes.getCurrentXYLim()
        self.figure.clear()        
        del self.worldMainMap
        del self.fig_axes.axes
        del self.fig_axes
        
        self.createMap(mapDetail, drawCSBorders, drawRivers)

        self.fig_axes.computeFullXYLim()
        self.fig_axes.setCurrentXYLim(xlim, ylim)
        
        if recycleThreads:
            self.startAllThreads()
        else:
            self.startMouseHoverThread()

        popup.Close()
        
        
    ## Handles a redraw cycle.
    # redraws all map plots while keeping the background (map) intact.
    # @param userPriority True if the user is actively interacting with the screen (i.e zoom or pan), in which case, skip this cycle
    def redrawCycle(self, userPriority = False):        
        # don't redraw if user is trying to interact with the screen.
        if userPriority == True and self.lbuttonDown == True:
            return
                
        start = time.time()
        
        #take care of a few things before getting lock
        
        displayConfigIsGood = True
                    
                            
        try:
            self.dispConf.loadConfig()
        except Exception, ex:
            print "there was an exception loading the display configuration: " + str(ex)
        
        self.PeerFilter.setFromDisplayConfig(self.dispConf, self.fig_axes.getZoomFactor())
        
        try:
            self.optConfig.loadConfig()
        except Exception, ex:
            print "there was an exception loading the display configuration: " + str(ex)
        
        
        homeLon, homeLat, locValid = self.optConfig.ident_getConfigCoordinates()
   
        latitudes = list()
        longitudes= list()
        
        entityDict = self.mainApp.entityMan.getSafeFilteredEntityCollectionByGeoLoc(self.PeerFilter)
        
        showLines  = self.PeerFilter.shouldDisplayLines()
        showLabels = self.PeerFilter.shouldDisplayLabels()
        
        self.displayer.setDisplayConfigurator(self.dispConf)
        
        
        self.lck.acquire(1)
        try:                
            
            displayedItems = self.worldMainMap.draw(entityDict, self.displayer, 
                                                    showLines, showLabels,
                                                    homeLon, homeLat) 
            
            self.canavas.draw()       
            
            self.numPeers = self.mainApp.entityMan.getEntityCollectionSize()
            self.numDisplayedPeers = displayedItems
                
        except Exception, e:
            logger.log(__name__ + ": Exception during redraw cycle.")
            logger.log(e)
        finally:
            end = time.time()
            #print "Draw Cycle Time: %3.3f" % (end - start)
            self.lck.release()
                        
            self.setStatusBarText(self.currentMousePosition)

      
   
                    
    ## Creates new Panel and adds it to the frame    
    def createPanel(self):
        
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.SetSizer(self.sizer)
        self.SetSize( wx.Size( 800, 600 ) )
        
        self.Centre()
        
        self.panel = wx.Panel(self)        
        
        self.sizer.Add(self.panel, 1, wx.EXPAND)
        self.Layout()
        
    
    
    ## Binds all useful Mouse and sizing events to this frame.
    def doBindings(self):
        
        self.Bind(wx.EVT_SIZE, self._OnSize)
        self.Bind(wx.EVT_IDLE, self._OnIdle)
        
        self.Bind(wx.EVT_ICONIZE, self._OnMinimize)
        
        self.canavas.Bind(wx.EVT_LEFT_DOWN, self._OnLButtonDown)
        self.canavas.Bind(wx.EVT_MOUSEWHEEL, self._OnMouseWheel)        
        
        self.canavas.Bind(wx.EVT_LEFT_UP, self._OnLButtonUp)
        self.canavas.Bind(wx.EVT_RIGHT_UP, self._OnRButtonUp)
        self.canavas.Bind(wx.EVT_MOTION, self._OnMouseMove)
        
        
        self.Connect(-1, -1, EVT_DISPLAY_TOOLINFOWIN, self.handleDisplayToolWindow)
        
        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)        


    ## Callback function used by the network monitor to report errors back the main window.
    # This is used to to display messages in a Dialog box visible to the user.
    # @param errorMsg Error message String 
    def handleMonitorErrorCallback(self, errorMsg):        
        self.handleStopMonitoring(None)
        
        err = "There was an error monitoring the network. Monitoring will now stop:\n\n%s" % errorMsg
        dlg = wx.MessageDialog(None, err, 'Error', wx.ICON_ERROR)
        result = dlg.ShowModal()
        dlg.Destroy()
    
    
    
    ## "Start Monitoring" Button handler. This button is essentially what "starts" the application. 
    # @param event Standard wx.Button event
    def handleStartMonitoring(self, event):
        if self.redrawThreadIsRunning():
            return
                    
        if self.selectedNetworkDevice == None:
            
            dlg = wx.MessageDialog(None, 'No network device was selected, would you like to choose one now?',
                          'Please Confirm', wx.YES_NO | wx.ICON_QUESTION)
            result = dlg.ShowModal()
            dlg.Destroy()
            
            if result == wx.ID_YES:
                self.handleConfigureNetwork(event)
            else: 
                return
            
        # the device may have been open since the user was given
        # a choice    
        if self.selectedNetworkDevice != None:
            
            # give the user the option of starting from scratch
            if self.mainApp.entityMan.getEntityCollectionSize() > 0:
                dlg = wx.MessageDialog(None, 'Would you like to clear all data before proceeing?',
                          'Please Confirm', wx.YES_NO | wx.ICON_QUESTION)
                result = dlg.ShowModal()
                dlg.Destroy()
                    
                if result == wx.ID_YES:
                    self.mainApp.entityMan.removeAllEntities()
                    self.mainApp.initStorage(True, True)
                else:
                    self.mainApp.initStorage(False, True)
            else:
                self.mainApp.initStorage(True, True)
                                                            
            try:                
                self.mainApp.startStorageManager()
                
                self.mainApp.netMon.networkIface.registerErrorCallBackFunc(self.handleMonitorErrorCallback)
                self.mainApp.netMon.startListening(self.selectedNetworkDevice)
            except exception, e:
                dlg = wx.MessageDialog(None, e.reason, 'Error', wx.ICON_ERROR)
                result = dlg.ShowModal()
                dlg.Destroy()
            else:                
                # start the drawing Thread 
                self.startRedrawthread()
                self.animLoaderIcon.play()
                
    
    ## "Stop Monitoring" Button handler. This button will stop all networking activities. 
    # @param event Standard wx.Button event
    def handleStopMonitoring(self, event):
        
        if self.selectedNetworkDevice != None:
            self.mainApp.shutdownStorage()
            self.mainApp.netMon.stopListening()
            
        # stop the drawing Thread 
        self.stopRedrawThread()
        self.animLoaderIcon.stop()
            
    
    
    ## "Go Home" Button handler. This button will cause the map to zoom all the way out. 
    # @param event Standard wx.Button event
    def handleGoHome(self, event):        
        # restore the ax postion I saved at creation time        
        self.lck.acquire(1)
        try: 
            self.fig_axes.resetZoom()
        finally:
            self.lck.release()
        
        # redraw map points if zoom level has changed
        filter = baseFilter()
        newZoomLevel = filter.getUserFriendlyZoomLevel(self.fig_axes.getZoomFactor())
        
        if self.currentZoomLevel is not None and (self.currentZoomLevel != newZoomLevel):                
            self.redrawCycle()
        
        self.currentZoomLevel = newZoomLevel
                
        
        #redraw the canavas
        self.redrawCanavasLock()
    
    
    
    ## "Pan" Button handler. This button will cause the cursor to go into "Pan" mode. 
    # @param event Standard wx.Button event  
    def handlePan(self, event):
        self.displayMode = VIEW_STATE_PAN
        self.cursor = wx.StockCursor(wx.CURSOR_SIZING)  
        
        self.canavas.SetCursor(self.cursor)



    ## "Zoom" Button handler. This button will cause the cursor to go into "Zoom" mode. 
    # @param event Standard wx.Button event  
    def handleFreeZoom(self, event):
        self.cursor = wx.StockCursor(wx.CURSOR_ARROW)
        self.displayMode = VIEW_STATE_ZOOM        
         
        self.canavas.SetCursor(self.cursor)


    
    ## "Zoom In" Button handler. This button will cause the map to Zoom in predefined amount. 
    # @param event Standard wx.Button event
    def handleZoomIn(self, event):
        self.lck.acquire(1)
        try:
            self.fig_axes.zoomIn(self.canavas.GetSize())
        finally:
            self.lck.release()
        
        self.redrawCanavasLock()
    
    
    
    ## "Zoom Out" Button handler. This button will cause the map to Zoom Out predefined amount. 
    # @param event Standard wx.Button event
    def handleZoomOut(self, event):
        self.lck.acquire(1)
        try:
            self.fig_axes.zoomOut(self.canavas.GetSize())
        finally:
            self.lck.release()
            
        self.redrawCanavasLock()
    
    
    
    ## "Capture ScreenShot" Button handler. This button will allow the user to save a ScreenShot to a file. 
    # @param event Standard wx.Button event
    def handleCaptureScreenshot(self, event):
        saveDlg = pictureSaverDialog(self, self.figure)        
    
    
    
    ## "Configure Network" Button handler. Will invoke the Network Configuration window. 
    # @param event Standard wx.Button event
    def handleConfigureNetwork(self, event):
        try:
            devDict = self.mainApp.netMon.getDeviceProperties()
        except exception, e:
            dlg = wx.MessageDialog(None, e.reason, 'Error', wx.ICON_ERROR)
            result = dlg.ShowModal()
            dlg.Destroy()
            logger.log(__name__ + ": " + e.reason)
        else:
            try:
                self.optConfig.loadConfig()
            except Exception, e:
                errMsg = "There was an error reading the options configuration file\nAlthough you configuration will be restored all application options will be set to their starting values. \nThis is usually due to a missing or corrupt configuration file\n\nDetailed Error:\n%s " % (str(e))
                
                dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
                result = dlg.ShowModal()
                dlg.Destroy()
            
            try:
                netSettings = networkSettings(self, devDict)
                netSettings.loadConfig(self.optConfig)
            except Exception, ex:
                errMsg = "Could not display Network Settings window: %s" % (str(ex))
                
                dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
                result = dlg.ShowModal()
                dlg.Destroy()
                return
            try:
                if netSettings.ShowModal() == wx.ID_OK:            
                   self.selectedNetworkDevice = netSettings.chosenDevice
                   saveDeviceSelection   = netSettings.saveSelection
                   
                   self.optConfig.network_setSaveDeviceSelection(saveDeviceSelection)
                   
                   if saveDeviceSelection == True:
                       self.optConfig.network_setSelectedDevice(self.selectedNetworkDevice)
                              
            except Exception, e:
                errMsg = "Could not save network settings: %s" % (str(e))
                
                dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
                result = dlg.ShowModal()
                dlg.Destroy()

            finally:
                if netSettings != None:
                    netSettings.Destroy()
                    
    
    
    ## "Set Home Location" Button handler. Will Allow the user to pin a new Home Location onto the map using the mouse. 
    # @param event Standard wx.Button event      
    def handleSetHomeLocation(self, event):
        self.cursor = wx.StockCursor(wx.CURSOR_BULLSEYE)
        self.canavas.SetCursor(self.cursor)
        
        self.displayMode = VIEW_STATE_SETHOMELOC
    
    
    
    
    ## "Options" Button handler. Will bring up the Options window. 
    # @param event Standard wx.Button event
    def handleOptions(self, event): 
        try:
            self.optConfig.loadConfig()
        except Exception, e:
            errMsg = "There was an error reading the options configuration file\nAlthough you configuration will be restored all application options will be set to their starting values. \nThis is usually due to a missing or corrupt configuration file\n\nDetailed Error:\n%s " % (str(e))
            
            dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
            result = dlg.ShowModal()
            dlg.Destroy()
                   
        try:       
            opt = appOptions(self, self.mainApp.entityMan.geoIP)
            opt.loadConfiguration(self.optConfig)
        except Exception, e:
            errMsg = "There was an error displaying application options%s" % (str(e))
            
            dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
            result = dlg.ShowModal()
            dlg.Destroy() 
            
            return   
        
        try:    
            if opt.ShowModal() == wx.ID_OK:
                # write values back to the registry
                if opt.ipAddrValid == True:
                    self.optConfig.ident_setIPAddr(opt.getIPAddress())
                    self.optConfig.ident_setIPGeoInfo(opt.getIPGeoInfo())
                    
                if opt.coordValid == True:
                    self.optConfig.ident_setManualCoord(opt.getCoordinates())
                    
                if opt.getIdentifyByIP() == True:
                    self.optConfig.ident_setIdentByIPAddr()
                else:
                    self.optConfig.ident_setIdentByCoord()
    
                self.optConfig.ident_setConfigValid(opt.getConfigValid())
                
                self.optConfig.network_setRecordTraffic(opt.getNetworkRecordTraffic())
                self.optConfig.network_setNeverStopRecording(opt.getNetworkUnlimitedCapture())
                self.optConfig.network_setRecordingMaxLimit(opt.getNetworkMaxStorage())
                
                if opt.networkSettingsChanged == True and self.redrawThreadIsRunning() == True:
                    try:
                        dlg = wx.MessageDialog(None, "Network Settings will take effect when monitoring is restarted", 'Info', wx.ICON_EXCLAMATION)
                        result = dlg.ShowModal()
                    finally:                
                        dlg.Destroy()
                    
                # force a draw cycle                        
                self.redrawCycle()
                
        except Exception, e:
            errMsg = "There was an error saving options.\nDetailed Error:\n%s " % (str(e))
            
            dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
            result = dlg.ShowModal()
            dlg.Destroy()                
        finally:
            if opt is not None:
                opt.Destroy()
    
    
    
    ## "View Filter" Button handler. Will bring up "Filters" window.
    # @param event Standard wx.Button event
    def handleViewFilter(self, event):
        fs = None        
        
        try:
            fs = filterSettings(self, self.PeerFilter)
            if fs.ShowModal() == wx.ID_OK:
                if fs.somethingRemoved == True:
                    self.redrawCycle()
                     
        finally:
            if fs is not None: fs.Destroy()
    
    
    
    ## "Display Settings" Button handler. Will bring up the Display Settings window. 
    # @param event Standard wx.Button event
    def handleDisplaySettings(self, event):
        try:
            self.dispConf.loadConfig()
        except Exception, ex:
            errMsg = "There was an error reading the display settings configuration file\nAlthough you configuration will be restored all display settings parameters will be set to their starting values. \nThis is usually due to a missing or corrupt configuration file\n\nDetailed Error:\n%s " % (str(ex))
            
            dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
            result = dlg.ShowModal()
            dlg.Destroy()
        
        ds = None           
        
        try:
            ds = displaySettings(self)
            ds.loadConfiguration(self.dispConf)
        except Exception, e:
            errMsg = "There was an error opening Display Settings window.\nDetailed Error:\n%s" % (str(e))
            
            dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
            result = dlg.ShowModal()
            dlg.Destroy()
            return            
        try:                                       
            if ds.ShowModal() == wx.ID_OK:
                # save settings back to INI file
                self.dispConf.glb_setMinXferOptions(ds.getGlbPeerXferOptions())
                self.dispConf.glb_setMaxIdleOptions(ds.getGlbPeerIdleOptions())
                
                self.dispConf.glb_setLineOptions(ds.getGlbLineOptions())
                self.dispConf.glb_setLabelOptions(ds.getGlbLabelOptions())
                
                self.dispConf.glb_setDisplayScale(ds.getGlbDisplayScale())
                self.dispConf.glb_setRefreshRate(ds.getGlbRefreshRate())
                self.dispConf.glb_setDisplayLabel(ds.getGlbDisplayLabel())                
                
                self.dispConf.app_setProcessColorCodes(ds.getAppColorDict())
                self.dispConf.app_setProcessDefaultColor(ds.getAppDefaultColor())
                
                if ds.refreshRateConfigChanged == True and self.redrawThreadIsRunning() == True:
                    try:
                        dlg = wx.MessageDialog(None, "Refresh Rate change will take effect once monitoring is restarted.", 'Info', wx.ICON_EXCLAMATION)
                        dlg.ShowModal()
                    finally:                
                        dlg.Destroy()
                        
                # map options
                self.dispConf.map_setMapDetail(ds.getMapDetailLevel())
                self.dispConf.map_setDrawCSBorders(ds.getMapDrawCSBorders())
                self.dispConf.map_setDrawRivers(ds.getMapDrawRivers())
                
                if ds.mapOptionsChanged:
                    self.recreateMap(self.dispConf.map_getMapDetail(), self.dispConf.map_getDrawCSBorders(), self.dispConf.map_getDrawRivers())
                
                # force a draw cycle                        
                self.redrawCycle()
        except Exception, e:
            errMsg = "There was an error saving display settings.\nDetailed Error:\n%s " % (str(e))
            
            dlg = wx.MessageDialog(None, errMsg, 'Error', wx.ICON_ERROR)
            result = dlg.ShowModal()
            dlg.Destroy()
        
        finally:                            
            if ds is not None: ds.Destroy()
    
    
    
    ## "About" Button handler. Will bring up the application's About window. 
    # @param event Standard wx.Button event
    def handleShowAbout(self, event):
        aboutDlg = aboutDialog(self, self.optConfig)
        aboutDlg.ShowModal()
        aboutDlg.Destroy()        
            
    
    
    ## Exits the application
    # @param event Standard wx.Button event      
    def handleExit(self, event):
        self.OnCloseWindow(event)    
        
    
    
    ## Displays the informational tooltip window once the mouse has paused over an Endpoint.
    # @param event Standard wx.Button event
    def handleDisplayToolWindow(self, event):
        if self.canDisplayTipWin == False: return
        
        entList = copy.deepcopy(event.entityList)
        
        x,y = self.currentMousePosition.x, self.currentMousePosition.y        
        
        # tipwindow takes screen coordinates so we have to transform
        x,y=self.ClientToScreen((x,y))        
        
        entList = copy.deepcopy(entList)
                
        tipWin = mainFrameToolWindow(self, entList, x, y)      
        
    
    
    
    ## Creates a new Status Bar
    def createStatusBar(self):
        self.statusBar = self.CreateStatusBar()

    
    """
        Threading functions
    """
    
    
    ## Starts all GUI Threads
    def startAllThreads(self):
        self.stopRedrawThread()
        self.stopMouseHoverThread()
        
        self.startRedrawthread()
        self.startMouseHoverThread()
    
    
    
    ## Stops all GUI Threads    
    def stopAllThreads(self):
        self.stopRedrawThread()
        self.stopMouseHoverThread()        
    
    
    
    ## Starts the Redraw thread
    def startRedrawthread(self):
        if self.redrawThreadIsRunning() == True:
            return
        
        logger.log(__name__ + "Starting Redraw Thread")
        ## make sure only one of these is running at a time
        
        self.autoRedrawThread = redrawThread(self)
        self.autoRedrawThread.reset()        
        
        # display
        refreshInterval = self.dispConf.glb_getRefreshRate()
    
        self.autoRedrawThread.setRefreshInterval(refreshInterval)
        
                
        self.autoRedrawThread.start()
    
    
    
    ## Stops the Redraw thread        
    def stopRedrawThread(self):
        # should never time out, but you never know        
        logger.log(__name__ + ": Stopping Redraw Thread")
        
        # sometime if the app is closed, this object is destroyed
        # probably because of a bug...
        if (self.redrawThreadIsRunning() == True):
            self.autoRedrawThread.killSignalAndWait(5)
    
    
    ## Returns true if the redraw thread is already running
    # @return boolean
    def redrawThreadIsRunning(self):
        if self.autoRedrawThread != None and self.autoRedrawThread.isAlive() == True:        
            return True
        else:
            return False
    
    
    
    ## Returns true if the Mouse Hover thread is already running
    # @return boolean    
    def mouseHoverThreadIsRunning(self):
        if self.mouseHoverThread != None and self.mouseHoverThread.isAlive() == True:        
            return True
        else:
            return False

    
    
    ## Starts the Mouse Hover Thread
    def startMouseHoverThread(self):
        
        if self.mouseHoverThreadIsRunning() == True:
            return
        
        logger.log(__name__ + "Starting Mouse Hover Thread")
        ## make sure only one of these is running at a time
        
        
        self.mouseHoverThread = mouseHoverThread(self)
        self.mouseHoverThread.reset()
                
        self.mouseHoverThread.start()
    
    
    ## Stops the Mouse Hover Thread
    def stopMouseHoverThread(self):
        # should never time out, but you never know
        logger.log(__name__ + "Stopping Mouse Hover Thread")
        
        # sometime if the app is closed, this object is destroyed
        # probably because of a bug...
        if (self.mouseHoverThread != None):
            self.mouseHoverThread.killSignalAndWait(10);
    
    """
        context menu related
    """ 
    
    
    ## Main message handler. 
    # @param event Standard wx.Button event
    def popupMenuCallBack(self, event):
        itemTuple = self.rclickMenu.getMenuItem(event.GetId())
        
        menuName, menuCat, menuParam = itemTuple
        
        if menuCat == "DISPLAY_SETTING":            
            self.handleDisplaySettings(event)
            
        if menuCat == "SHOW_OPTIONS":            
            self.handleOptions(None)
        
        if menuCat == "VIEW_FILTERS":            
            self.handleViewFilter(None)
            
        if menuCat == "SHOWDETAILS":
            peerList = peerGridDisplay(self)
            peerList.fromEntList(self.entListSelection)
            peerList.Show(True)
            
        if menuCat == "SHOWDETAILSVIS":
            entDict = self.mainApp.entityMan.getSafeFilteredEntityCollectionByGeoLoc(None)
            
            peerList = peerGridDisplay(self)
        
            peerList.fromEntGeoLocDict(entDict)
            peerList.Show(True)
        
        if menuCat == "SHOWDETAILSALL":
            entDict = self.mainApp.entityMan.getSafeEntityCollectionByPK()
            
            peerList = peerGridDisplay(self)
            peerList.fromEntDict(entDict)
            peerList.Show(True)
            
        if menuCat == "FILTERITEM":
            self.PeerFilter.addToFilter(menuParam)   
            self.redrawCycle()    
            
        if menuCat == "DISPLAY_TRACE":
            
            # this list should be 1 by now, but check again
            if len(self.entListSelection) == 0:
                return
                        
            ent = self.entListSelection[0]
            
            traceDisplay = traceDisplayDialog(self, ent.foreignIPAddress, ent.selfPort, ent.foreignPort)
            traceDisplay.ShowModal()
        
        # ok to display tip window again
        self.canDisplayTipWin = True   
                

        
        
    """ 
        global redrawing functions
    """
    
    
    
    ## Repaints the canavas. 
    def redrawCanavasLock(self):
                
        self.lck.acquire(1)
        try:
            self.canavas.draw()
        finally:
            self.lck.release()
            
    """
        misc
    """
    
    
    ## Displays an error message right before exiting the application.
    # Used if something catastrophic happens during startup.
    # @param why Error String
    def die(self, why):
         dlg = wx.MessageDialog(None, why, 'Error', wx.ICON_ERROR)
         result = dlg.ShowModal()
         dlg.Destroy()

         self.stopAllThreads()
         self.Destroy()
    
    
    ## cleanly shuts down the window and all of its threads.
    # @param event Standard wx.Button event
    def OnCloseWindow(self, event):                                                
        self.stopAllThreads()                  
        self.Destroy()
        
        self.mainApp.shutdownStorage()  
        self.mainApp.storage.deleteStorage()
    
    def doNothing(self):
        pass

      
        
            

---