C:/work/RevealedSystems/EyeSpy-RS/eyespy/src/objects/logic/entity/filter/baseFilter.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 time
from objects.logic.common.globalStrings import globalStrings
from objects.logic.common.logger import logger




## The baseFilter class contains all filtering logic needed to determine if a given
# networkEntity should be displayed. Usually the baseFilter will expose a single shouldDisplay() method
# returning a boolean value which will indicate whether the item should be displayed
# or not.
#   
# Internally the baseFilter class just contain all global filter settings. 
class baseFilter():
    def __init__(self):
        self.minXferCheck = False
        self.minXfer = -1
        
        self.maxIdleTimeCheck = False
        self.maxIdleTime = -1
        
        self.lineZoomOption = "Always"
        self.lineZoomLevel = globalStrings.DISP_SETT_COUNTRY_STATE
        
        self.labelZoomOption = "Always"
        self.labelZoomLevel = globalStrings.DISP_SETT_COUNTRY_STATE
        
        self.filteredItems = []        
        
        zoomFactor = 0
        
        # zoom priority dictionary        
        self.zoomRanking = dict()
        
        self.zoomRanking[globalStrings.DISP_SETT_CITY] = 0
        self.zoomRanking[globalStrings.DISP_SETT_COUNTRY_STATE] = 1
        self.zoomRanking[globalStrings.DISP_SETT_CONTINENT] = 2
        self.zoomRanking[globalStrings.DISP_SETT_WORLDWIDE] = 3
        
        self.initilized = False
    
    ## will return a string indicating what the zoom level is, given some large integer.
    # possible values are: "WorldWide", "Continent", "Country/State" or "City"
    # @param zoomFactor Integer (fig_axes Axes Range)
    # @return String
    def getUserFriendlyZoomLevel(self, zoomFactor):       
                
        if zoomFactor >= 8500000: return globalStrings.DISP_SETT_WORLDWIDE
        elif zoomFactor < 8500000 and zoomFactor >= 2000000: return globalStrings.DISP_SETT_CONTINENT
        elif zoomFactor < 2000000 and zoomFactor >= 500000: return globalStrings.DISP_SETT_COUNTRY_STATE
        else: return globalStrings.DISP_SETT_CITY
        
    
    
    ## Returns True if the lines should be displayed given the current Zoom/Settings combination
    # @return Boolean    
    def shouldDisplayLines(self):
        # figure out zoom factor, then decide
        if self.lineZoomOption == "Always":
            return  True
        elif self.lineZoomOption == "Never":
            return False
        else:
            try:
                currZoomRank = self.zoomRanking[self.getUserFriendlyZoomLevel(self.zoomFactor)]                
                settingLineZoomRank = self.zoomRanking[ self.lineZoomLevel]
            except Exception, ex:
                # probably something out of range
                errMsg = ": Could not determine Line zoom ranking (Defaulting). Error: %s" % (ex)
                logger.log(__name__ + errMsg)
                
                return True                
            else:
                if currZoomRank <= settingLineZoomRank:
                    return True
                else:
                    return False
    
    
    ## Returns True if the map labels should be displayed given the current Zoom/Settings combination
    # @return Boolean
    def shouldDisplayLabels(self):
        # figure out zoom factor, then decide
        if self.labelZoomOption == "Always":
            return True
        elif self.labelZoomOption == "Never":
            return False
        else:
            try:
                currZoomRank = self.zoomRanking[self.getUserFriendlyZoomLevel(self.zoomFactor)]                
                settingLabelZoomRank = self.zoomRanking[ self.labelZoomLevel]
            except Exception, ex:
                # probably something out of range
                errMsg = ": Could not determine Label zoom ranking (Defaulting). Error: %s" % (ex)
                logger.log(__name__ + errMsg)
                
                return True                
            else:
                if currZoomRank <= settingLabelZoomRank:
                    return True
                else:
                    return False    
    
    ## returns a boolean indicating if the supplied networkEntity object should be displayed or not
    # @param networkEntity networkEntity Object
    # @return Boolean
    def shouldDisplayEntity(self, networkEntity):
        
        if self.initilized == False: 
            return False

        if self.minXferCheck == True:
            ajdXfer = float(networkEntity.totalBytes)/float(self.minXferScale) 
            if ajdXfer < self.minXfer:
                return False
            
        if self.maxIdleTimeCheck == True:
            ts = time.time()
            
            deltaTime = (ts - networkEntity.lastUpdateTS) / self.idleTimeScale
            if deltaTime > self.maxIdleTime:
                return False
            
        
        return True
    
    
    
    ## Sets its internal members based on an optionsConfigurator object, and a zoom Factor value
    # @param config optionsConfigurator object
    # @param zoomFactor
    def setFromDisplayConfig(self, config, zoomFactor):
    
        self.zoomFactor = zoomFactor
             
        self.minXferCheck, self.minXfer, self.minXferScale = config.glb_getMinXferOptions()
        self.maxIdleTimeCheck, self.maxIdleTime, self.idleTimeScale = config.glb_getMaxIdleOptions()
        
        self.lineZoomOption, self.lineZoomLevel = config.glb_getLineOptions()
        self.labelZoomOption, self.labelZoomLevel = config.glb_getLabelOptions()

        
        self.initilized = True
        

---