C:/work/RevealedSystems/EyeSpy-RS/eyespy/src/objects/logic/configuration/displayConfigurator.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/>.

from objects.logic.common.exception import exception
from objects.logic.common.logger import logger
from objects.logic.configuration.configurator import configurator
from objects.logic.common.globalStrings import globalStrings



## The displayConfigurator class is the interface for the "displaySettings.ini" configuration
# file, which stores all configuration found in the "Display Settings" window.
# All access to this file needs to be done via this object

##
# 
#         --- Getters ---
#     
class displayConfigurator(configurator):

    
    
    ##will return tuple indicating:
    #    a) whether min data xfrer is enabled.
    #    b) min xfer value.
    #    c) the scale (i.e. kb, mb, gb).
    # @return Tuple
    def glb_getMinXferOptions(self):
        mdxh = self.getConfigValue("Global", "min_data_xfer_hide", True, True)
        mdx = self.getConfigValue("Global", "min_data_xfer", "1000", True)
        mdxs = self.getConfigValue("Global", "min_data_xfer_scale", "10", True)
        
        if mdxh == "True": 
            mdxh = True
        else:
            mdxh = False
            
        
        return (mdxh, int(mdx), int(mdxs))
    
    
    ## will return tuple indicating:
    #    a) whether min data xfrer is enabled.
    #    b) min idle time.
    #    c) the scale (i.e. secs, min, hr). 
    # @return Tuple   
    def glb_getMaxIdleOptions(self):
        mith = self.getConfigValue("Global", "max_idle_time_hide", True, True)
        mit  = self.getConfigValue("Global", "max_idle_time", "30", True)
        mits = self.getConfigValue("Global", "max_idle_time_scale", "60", True)
        
        if mith == "True": 
            mith = True
        else:
            mith = False


        return (mith, int(mit), int(mits))
    
    
    ## Returns the total fade time in seconds (max idle time * scale)
    # @return Integer
    def glb_getFadeTime(self):
       mit  = self.getConfigValue("Global", "max_idle_time", "30", True)
       mits = self.getConfigValue("Global", "max_idle_time_scale", "60", True)

       return int(mit) * int(mits)

    
    
    ## Returns the Line options as a tuple 
    # @return Tuple
    def glb_getLineOptions(self):
        lins = self.getConfigValue("Global", "lines_show", "Only", True)
        linz = self.getConfigValue("Global", "lines_zoom", globalStrings.DISP_SETT_COUNTRY_STATE, True)
        
        return (lins, linz)
    
    
    
    ## Returns the Label options as a tuple 
    # @return Tuple
    def glb_getLabelOptions(self):
        labs = self.getConfigValue("Global", "labels_show", "Only", True)
        labz = self.getConfigValue("Global", "labels_zoom", globalStrings.DISP_SETT_COUNTRY_STATE, True)
        
        return (labs, labz)
    
    
    ## Returns the Display Transfer Scale
    # @return Integer
    def glb_getDisplayScale(self):
         dispXs = self.getConfigValue("Global", "display_xfer_scale", "1000000", True)
         return int(dispXs)
         
         
    ## Returns the map refresh rate
    # @return String (Low, Med, High)
    def glb_getRefreshRate(self):
        refRate = self.getConfigValue("Global", "map_refresh_rate", "Med", True)
        
        return refRate
    
    
    ## Returns the label which should be used to describe each Screen Endpoint
    # @return String
    def glb_getDisplayLabel(self):
        displayLabel = self.getConfigValue("Global", "display_label", "_DEFAULT_", True)
        
        return displayLabel
        
        
        
    # returns a list all items in the [AppColorCodes] section
    # @return List
    def app_getProcessColorCodes(self):
        return self.getSection("AppColorCodes")
    
    # returns a dictionary of all value/pair items in the [AppColorCodes] section
    # @return Dictionary
    def app_getProcessColorCodesDict(self):
        procColorDict = dict()
        procColorList = self.app_getProcessColorCodes()
        
        for proc, color in procColorList:
            procColorDict[proc] = color 
            
        return procColorDict

    ## returns the default process color
    # @return String (representing a hex number)
    def app_getProcessDefaultColor(self):
        procDefColor = self.getConfigValue("Application", "proc_default_color", "#FF0000", True)
        
        return procDefColor
    
    ## Returns a Boolean indicating the level of map detail
    # @return Boolean (True = High Detail, False = Low Detail)
    def map_getMapDetail(self):
        mapDetailLevel = self.getConfigValue("Map", "map_detail_level", "N", True)
        
        if mapDetailLevel == "Y": 
            mapDetailLevel = True
        else:
            mapDetailLevel = False
                
        return mapDetailLevel
    
    
    
    ## Returns a Boolean indicating whether to draw country/state borders onto the map
    # @return Boolean
    def map_getDrawCSBorders(self):
        drawCSBorders = self.getConfigValue("Map", "map_draw_cs_borders", "Y", True)        
        
        if drawCSBorders == "Y": 
            drawCSBorders = True
        else:
            drawCSBorders = False
            
        return drawCSBorders 
    
    
    
    ## Returns a Boolean indicating whether to draw Rivers onto the map
    # @return Boolean
    def map_getDrawRivers(self):
        drawRivers = self.getConfigValue("Map", "map_draw_rivers", "N", True)
        
        if drawRivers == "Y": 
            drawRivers = True
        else:
            drawRivers = False
            
        return drawRivers        
        
     
    
    """
        --- Setters ---
    """
    
    
    ## Sets the transfer settings
    # @param mdxh min_data_xfer_hide value
    # @param mdx min_data_xfer value
    # @param mdxs min_data_xfer_scale value
    def glb_setMinXferOptions(self, (mdxh, mdx, mdxs)):        
        mdxh = str(mdxh)
        mdx  = str(mdx)
        mdxs = str(mdxs)
        
        self.setConfigValue("Global", "min_data_xfer_hide", mdxh)
        self.setConfigValue("Global", "min_data_xfer", mdx)
        self.setConfigValue("Global", "min_data_xfer_scale", mdxs)
        
    
    ## Sets the Max Idle/Hide settings
    # @param mith max_idle_time_hide value
    # @param mit max_idle_time value
    # @param mits max_idle_time_scale value
    def glb_setMaxIdleOptions(self, (mith, mit, mits)):
        mith = str(mith)
        mit = str(mit)
        mts = str(mits)
        
        self.setConfigValue("Global", "max_idle_time_hide", mith)
        self.setConfigValue("Global", "max_idle_time", mit)
        self.setConfigValue("Global", "max_idle_time_scale", mits)
    
    
    
    ## Sets the Line Options
    # @param lins lines_show value
    # @param linz lines_zoom value
    def glb_setLineOptions(self, (lins, linz)):
        lins = str(lins)
        linz = str(linz)
        
        self.setConfigValue("Global", "lines_show", lins)
        self.setConfigValue("Global", "lines_zoom", linz)
    
    
    ## Sets the Label Options
    # @param labs labels_show value
    # @param labz labels_zoom value 
    def glb_setLabelOptions(self, (labs, labz)):
        labs = str(labs)
        labz = str(labz)
        
        self.setConfigValue("Global", "labels_show", labs)
        self.setConfigValue("Global", "labels_zoom", labz)
    
    
    ## Sets the Display Scale
    # @param dispXs display_xfer_scale value
    def glb_setDisplayScale(self, dispXs):
        dispXs = str(dispXs)
        
        self.setConfigValue("Global", "display_xfer_scale", dispXs)
    
    
    
    ## Sets the Refresh Rate
    # @param refRate map_refresh_rate value
    def glb_setRefreshRate(self, refRate):
        refRate = str(refRate)
        
        self.setConfigValue("Global", "map_refresh_rate", refRate)
    
    
    
    ## Sets the Display Label
    # @param displayLabel display_label value
    def glb_setDisplayLabel(self, displayLabel):
        self.setConfigValue("Global", "display_label", displayLabel)

        
    ## Sets the Application Color as a dictionary of color/value pairs
    # @param colorCodeDict Dictionary of Process->Color pairs
    def app_setProcessColorCodes(self, colorCodeDict):
        for processName, color in colorCodeDict.iteritems():
            self.setConfigValue("AppColorCodes", processName, color)
    
    
    
    ## Sets the Application Default Color
    # @param defColor String representing default Color value (as a Hex value)     
    def app_setProcessDefaultColor(self, defColor):
        self.setConfigValue("Application", "proc_default_color", defColor)
    
    ## Sets the map detail level
    # @param value True = High, False = Low
    def map_setMapDetail(self, value):
        if value == True: value = 'Y'
        else: value = 'N'
        
        self.setConfigValue("Map", "map_detail_level", value)
    
    
    
    ## Sets whether to draw borders onto the map
    # @param value Boolean
    def map_setDrawCSBorders(self, value):
        if value == True: value = 'Y'
        else: value = 'N'
        
        self.setConfigValue("Map", "map_draw_cs_borders", value)
         
    
    
    ## Sets whether to draw Rivers onto the map
    # @param value Boolean
    def map_setDrawRivers(self, value):
        if value == True: value = 'Y'
        else: value = 'N'
        
        self.setConfigValue("Map", "map_draw_rivers", value)

    
    

        
        

---