C:/work/RevealedSystems/EyeSpy-RS/eyespy/src/objects/logic/configuration/optionsConfigurator.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 options configurator is the interface for the "options.ini" configuration file
# which stores all settings found in the "Options" window.
# file. All access to this file needs to be done via this object
##
# 
#         --- Getters ---
#     
class optionsConfigurator(configurator):

     
    
    ## Return a lon/lat/valid tuple based on the current configuration
    # @return Tuple
    def ident_getConfigCoordinates(self):
        lon = None
        lat = None
        configValid = self.ident_getConfigValid()
        
        if self.ident_getIdentByIPAddr() == True:
            lon  = self.getConfigValue("Identification", "info_longitude", "", False)
            lat  = self.getConfigValue("Identification", "info_latitude", "", False)
            
            #config no good
            if lon == "" or lat == "":
                return 0, 0, configValid
            else:
                return float(lon), float(lat), configValid
            
            
        else:
            (lon, lat) =  self.ident_getManualCoord()
            return lon, lat, configValid
            
            
    ## Returns True if the Home Location is identified "by IP Address"
    # @return Boolean
    def ident_getIdentByIPAddr(self):
        identMethod = self.getConfigValue("Identification", "ident_method", "", False)
        
        if identMethod == "BYIPADDR":
            return True
        else:
            return False
        
    
    
    ## Returns True if the Home Location is identified "by Coordinates"
    # @return Boolean
    def ident_getIdentByCoord(self):
        identMethod = self.getConfigValue("Identification", "ident_method", "", False)
        
        if identMethod == "BYCOORD":
            return True
        else:
            return False
        
    
    ## Returns the currently set IP Address. otherwise it will return "None
    # @return Boolean
    def ident_getIPAddr(self):
        ipAddr = self.getConfigValue("Identification", "ipaddress", "", True)
        return ipAddr
    
    
    
    ## Returns a Tuple of all geographical properties.
    # i.e. (lon, lat, city, state/prov, country, org, isp).
    #
    # All values, including lon and lat info are returned as strings
    # @return Tuple
    def ident_getIPGeoInfo(self):
        lon      = self.getConfigValue("Identification", "info_longitude", "", True)
        lat      = self.getConfigValue("Identification", "info_latitude", "", True)
        city     = self.getConfigValue("Identification", "info_city", "", True)
        statProv = self.getConfigValue("Identification", "info_state_prov", "", True)
        country  = self.getConfigValue("Identification", "info_country", "", True)
        org      = self.getConfigValue("Identification", "info_organization", "", True)
        ISP      = self.getConfigValue("Identification", "info_isp", "", True)
        
        return (self.readFmat(lon), lat, city, statProv, country, org, ISP)
    
    
    
    ## Returns a Tuple of longitude/latitude floats
    # @return Tuple
    def ident_getManualCoord(self):
        lon     = self.getConfigValue("Identification", "manual_longitude", "0.00", True)
        lat     = self.getConfigValue("Identification", "manual_latitude", "0.00", True)
        
        return (float(lon), float(lat))
    
    
    ## Network related gets
    
    ## Returns true if the configuration Home Location value is a valid one
    # @return Boolean
    def ident_getConfigValid(self):
        configValid = self.getConfigValue("Identification", "configuration_valid", "N", True)
        
        return configValid
    
    
    ## Returns true if the Record Network Taffic flag is set.
    # @return Boolean
    def network_getRecordTraffic(self):
        recordTraffic = self.getConfigValue("Network", "record_traffic", "N", True)
        
        if recordTraffic == "Y":
            return True
        else:
            return False


    ## Returns the value of the "Never Stop Recording" button
    # @return Boolean
    def network_getNeverStopRecording(self):
        neverStorRecording = self.getConfigValue("Network", "never_stop_recording", "N", True)
        
        if neverStorRecording == "Y":
            return True
        else:
            return False
    
    
    ## Returns the Recording Maximim Limit
    # @return Integer
    def network_getRecordingMaxLimit(self):
        recordingMaxLimit = self.getConfigValue("Network", "recording_max_limit", "100", True)
        
        return int(recordingMaxLimit)
    
    
    ## Returns True if the selected network adapter should be saved.
    # @return Boolean
    def network_getSaveDeviceSelection(self):
        saveSelection = self.getConfigValue("Network", "save_device_selection", "N", True)
        
        if saveSelection == "Y":
            return True
        else:
            return False
        
        
    ## Returns The selected network adapter
    # @return String
    def network_getSelectedDevice(self):
        selectedDevice = self.getConfigValue("Network", "selected_device", "", True)
        
        return selectedDevice
    
    
    
    ## Returns The URL of the License (GNU.org)
    # @return String
    def navigation_getLicenseSite(self):
        licenseSite = self.getConfigValue("navigation", "license_site", globalStrings.defLicenseSite, True)
        
        return licenseSite
    
    def navigation_getAppHomePage(self):
        homePage = self.getConfigValue("navigation", "home_page", globalStrings.defHomePage, True)
        
        return homePage
    

    """
        --- Setters ---
    """    
    
    
    ## Sets the Home Location identification to "BYIPADDR"
    def ident_setIdentByIPAddr(self):
        self.setConfigValue("Identification", "ident_method", "BYIPADDR")
    
    
    ## Sets the Home Location identification to "BYCOORD"
    def ident_setIdentByCoord(self):
        self.setConfigValue("Identification", "ident_method", "BYCOORD")
            
        
    
    ## Sets the Home IP Address
    def ident_setIPAddr(self, ipAddr):
        self.setConfigValue("Identification", "ipaddress", ipAddr)
    
    def ident_setIPGeoInfo(self, (lon, lat, city, stateProv, country, org, ISP)):
        self.setConfigValue("Identification", "info_longitude", lon)
        self.setConfigValue("Identification", "info_latitude", lat)
        self.setConfigValue("Identification", "info_city", city)
        self.setConfigValue("Identification", "info_state_prov", stateProv)
        self.setConfigValue("Identification", "info_country", country)
        self.setConfigValue("Identification", "info_organization", org)
        self.setConfigValue("Identification", "info_isp", ISP)
    
    
    
    ## Sets the Home Coordinates using a longitude/latitude tuple
    # @param lon  Home Longitude
    # @param lat Home Latitude
    def ident_setManualCoord(self, (lon, lat)):
        
        lon = str(lon)
        lat = str(lat)
        
        if lon == None or lon == "": lon = "0.00"
        if lat == None or lat == "": lat = "0.00"
        
        self.setConfigValue("Identification", "manual_longitude", lon)
        self.setConfigValue("Identification", "manual_latitude", lat)

    
    ## Sets the configuration_valid flag.
    # @param configValid Boolean
    def ident_setConfigValid(self, configValid):
        if configValid == True: configValid = "Y" 
        else: configValid = "N"
        
        self.setConfigValue("Identification", "configuration_valid", configValid)
    
    
    
    ## Sets the record_traffic flag.
    # @param value Boolean   
    def network_setRecordTraffic(self, value):        
        if value == True: value = "Y" 
        else: value = "N"
        
        self.setConfigValue("Network", "record_traffic", value)
        
    
    
    ## Sets the never_stop_recording flag.
    # @param value Boolean    
    def network_setNeverStopRecording(self, value):        
        if value == True: value = "Y" 
        else: value = "N"
        
        self.setConfigValue("Network", "never_stop_recording", value)
    
    
    
    ## Sets the recording_max_limit value (how much to record)
    # @param maxLimit Integer
    def network_setRecordingMaxLimit(self, maxLimit):            
        self.setConfigValue("Network", "recording_max_limit", str(maxLimit))
        
        
        
    ## Sets the save_device_selection value ("remember this choice")
    # @param saveSelection Booleans
    def network_setSaveDeviceSelection(self, saveSelection):
        if saveSelection == True: saveSelection = "Y" 
        else: saveSelection = "N"
                    
        self.setConfigValue("Network", "save_device_selection", saveSelection)
        
    
    
    ## Sets the elected_device value (the network adapter)
    # @param selectedDevice String
    def network_setSelectedDevice(self, selectedDevice):        
        self.setConfigValue("Network", "selected_device", selectedDevice)
        
               
        
        
    

    
    

        
        

---