configreader.py

这是一个嵌入式linux系统下的命令工具包

            self.config['gui_displaystats']=int(self.gui_displaystats_checkbox.GetValue())
            self.config['gui_displaymiscstats']=int(self.gui_displaymiscstats_checkbox.GetValue())
            self.config['security']=int(self.security_checkbox.GetValue())
            self.config['auto_kick']=int(self.autokick_checkbox.GetValue())
            buffering=int(self.buffering_checkbox.GetValue())
            self.config['buffer_reads']=buffering
            if buffering:
                self.config['write_buffer_size']=self.defaults['write_buffer_size']
            else:
                self.config['write_buffer_size']=0
            self.config['breakup_seed_bitfield']=int(self.breakup_checkbox.GetValue())
            if self.autoflush_checkbox.GetValue():
                self.config['auto_flush']=5
            else:
                self.config['auto_flush']=0
            if sys.version_info >= (2,3) and socket.has_ipv6:
                self.config['ipv6_enabled']=int(self.ipv6enabled_checkbox.GetValue())
            self.config['gui_forcegreenonfirewall']=int(self.gui_forcegreenonfirewall_checkbox.GetValue())
            self.config['minport']=self.minport_data.GetValue()
            self.config['maxport']=self.maxport_data.GetValue()
            self.config['random_port']=int(self.randomport_checkbox.GetValue())
            self.config['gui_font']=self.gui_font_data.GetValue()
            self.config['gui_ratesettingsdefault']=self.gui_ratesettingsdefault_data.GetStringSelection()
            self.config['max_download_rate']=self.maxdownload_data.GetValue()
            self.config['gui_ratesettingsmode']=self.gui_ratesettingsmode_data.GetStringSelection()
            self.config['gui_default_savedir']=self.gui_default_savedir_ctrl.GetValue()
            self.config['gui_saveas_ask']=1-self.gui_savemode_data.GetSelection()
            self.config['gui_checkingcolor']=ColorToHex(self.checkingcolor)
            self.config['gui_downloadcolor']=ColorToHex(self.downloadcolor)
            self.config['gui_seedingcolor']=ColorToHex(self.seedingcolor)
            
            if (sys.platform == 'win32'):
                self.config['win32_taskbar_icon']=int(self.win32_taskbar_icon_checkbox.GetValue())
#                self.config['upnp_nat_access']=int(self.upnp_checkbox.GetValue())
                self.config['upnp_nat_access']=self.upnp_data.GetSelection()

            if self.advancedConfig:
                for key,val in self.advancedConfig.items():
                    self.config[key] = val

            self.writeConfigFile()
            self._configReset = True
            self.Close()
          except:
            self.parent.exception()

        def cancelConfigs(evt, self = self):
            self.Close()

        def savepath_set(evt, self = self):
          try:
            d = self.gui_default_savedir_ctrl.GetValue()
            if d == '':
                d = self.config['last_saved']
            dl = wxDirDialog(self.panel, 'Choose a default directory to save to', 
                d, style = wxDD_DEFAULT_STYLE | wxDD_NEW_DIR_BUTTON)
            if dl.ShowModal() == wxID_OK:
                self.gui_default_savedir_ctrl.SetValue(dl.GetPath())
          except:
            self.parent.exception()

        def checkingcoloricon_set(evt, self = self):
          try:
            newcolor = self.getColorFromUser(self.panel,self.checkingcolor)
            self.setColorIcon(self.checkingcolor_icon, self.checkingcolor_iconptr, newcolor)
            self.checkingcolor = newcolor
          except:
            self.parent.exception()

        def downloadcoloricon_set(evt, self = self):
          try:
            newcolor = self.getColorFromUser(self.panel,self.downloadcolor)
            self.setColorIcon(self.downloadcolor_icon, self.downloadcolor_iconptr, newcolor)
            self.downloadcolor = newcolor
          except:
            self.parent.exception()

        def seedingcoloricon_set(evt, self = self):
          try:
            newcolor = self.getColorFromUser(self.panel,self.seedingcolor)
            self.setColorIcon(self.seedingcolor_icon, self.seedingcolor_iconptr, newcolor)
            self.seedingcolor = newcolor
          except:
            self.parent.exception()
            
        EVT_BUTTON(self.configMenuBox, saveButton.GetId(), saveConfigs)
        EVT_BUTTON(self.configMenuBox, cancelButton.GetId(), cancelConfigs)
        EVT_BUTTON(self.configMenuBox, defaultsButton.GetId(), setDefaults)
        EVT_BUTTON(self.configMenuBox, advancedButton.GetId(), self.advancedMenu)
        EVT_BUTTON(self.configMenuBox, savepathButton.GetId(), savepath_set)
        EVT_LEFT_DOWN(self.checkingcolor_iconptr, checkingcoloricon_set)
        EVT_LEFT_DOWN(self.downloadcolor_iconptr, downloadcoloricon_set)
        EVT_LEFT_DOWN(self.seedingcolor_iconptr, seedingcoloricon_set)

        self.configMenuBox.Show ()
        border.Fit(panel)
        self.configMenuBox.Fit()
      except:
        self.parent.exception()


    def Close(self):
        self.CloseAdvanced()
        if self.configMenuBox is not None:
            try:
                self.configMenuBox.Close ()
            except wxPyDeadObjectError, e:
                pass
            self.configMenuBox = None

    def advancedMenu(self, event = None):
      try:
        if not self.advancedConfig:
            for key in ['ip', 'bind', 'min_peers', 'max_initiate', 'display_interval',
        'alloc_type', 'alloc_rate', 'max_files_open', 'max_connections', 'super_seeder',
        'ipv6_binds_v4', 'double_check', 'triple_check', 'lock_files', 'lock_while_reading',
        'expire_cache_data']:
                self.advancedConfig[key] = self.config[key]

        if (self.advancedMenuBox is not None):
            try:
                self.advancedMenuBox.Close ()
            except wxPyDeadObjectError, e:
                self.advancedMenuBox = None

        self.advancedMenuBox = wxFrame(None, -1, 'BitTorrent Advanced Preferences', size = (1,1),
                            style = wxDEFAULT_FRAME_STYLE|wxFULL_REPAINT_ON_RESIZE)
        if (sys.platform == 'win32'):
            self.advancedMenuBox.SetIcon(self.icon)

        panel = wxPanel(self.advancedMenuBox, -1)
#        self.panel = panel

        def StaticText(text, font = self.FONT, underline = False, color = None, panel = panel):
            x = wxStaticText(panel, -1, text, style = wxALIGN_LEFT)
            x.SetFont(wxFont(font, wxDEFAULT, wxNORMAL, wxNORMAL, underline))
            if color is not None:
                x.SetForegroundColour(color)
            return x

        colsizer = wxFlexGridSizer(cols = 1, hgap = 13, vgap = 13)
        warningtext = StaticText('CHANGE THESE SETTINGS AT YOUR OWN RISK', self.FONT+4, True, 'Red')
        colsizer.Add(warningtext, 1, wxALIGN_CENTER)

        self.ip_data = wxTextCtrl(parent = panel, id = -1, 
                    value = self.advancedConfig['ip'],
                    size = (self.FONT*13, int(self.FONT*2.2)), style = wxTE_PROCESS_TAB)
        self.ip_data.SetFont(self.default_font)
        
        self.bind_data = wxTextCtrl(parent = panel, id = -1, 
                    value = self.advancedConfig['bind'],
                    size = (self.FONT*13, int(self.FONT*2.2)), style = wxTE_PROCESS_TAB)
        self.bind_data.SetFont(self.default_font)
        
        if sys.version_info >= (2,3) and socket.has_ipv6:
            self.ipv6bindsv4_data=wxChoice(panel, -1,
                             choices = ['separate sockets', 'single socket'])
            self.ipv6bindsv4_data.SetFont(self.default_font)
            self.ipv6bindsv4_data.SetSelection(self.advancedConfig['ipv6_binds_v4'])

        self.minpeers_data = wxSpinCtrl(panel, -1, '', (-1,-1), (self.FONT*7, -1))
        self.minpeers_data.SetFont(self.default_font)
        self.minpeers_data.SetRange(10,100)
        self.minpeers_data.SetValue(self.advancedConfig['min_peers'])
        # max_initiate = 2*minpeers

        self.displayinterval_data = wxSpinCtrl(panel, -1, '', (-1,-1), (self.FONT*7, -1))
        self.displayinterval_data.SetFont(self.default_font)
        self.displayinterval_data.SetRange(100,2000)
        self.displayinterval_data.SetValue(int(self.advancedConfig['display_interval']*1000))

        self.alloctype_data=wxChoice(panel, -1,
                         choices = ['normal', 'background', 'pre-allocate', 'sparse'])
        self.alloctype_data.SetFont(self.default_font)
        self.alloctype_data.SetStringSelection(self.advancedConfig['alloc_type'])

        self.allocrate_data = wxSpinCtrl(panel, -1, '', (-1,-1), (self.FONT*7,-1))
        self.allocrate_data.SetFont(self.default_font)
        self.allocrate_data.SetRange(1,100)
        self.allocrate_data.SetValue(int(self.advancedConfig['alloc_rate']))

        self.locking_data=wxChoice(panel, -1,
                           choices = ['no locking', 'lock while writing', 'lock always'])
        self.locking_data.SetFont(self.default_font)
        if self.advancedConfig['lock_files']:
            if self.advancedConfig['lock_while_reading']:
                self.locking_data.SetSelection(2)
            else:
                self.locking_data.SetSelection(1)
        else:
            self.locking_data.SetSelection(0)

        self.doublecheck_data=wxChoice(panel, -1,
                           choices = ['no extra checking', 'double-check', 'triple-check'])
        self.doublecheck_data.SetFont(self.default_font)
        if self.advancedConfig['double_check']:
            if self.advancedConfig['triple_check']:
                self.doublecheck_data.SetSelection(2)
            else:
                self.doublecheck_data.SetSelection(1)
        else:
            self.doublecheck_data.SetSelection(0)

        self.maxfilesopen_choices = ['50', '100', '200', 'no limit ']
        self.maxfilesopen_data=wxChoice(panel, -1, choices = self.maxfilesopen_choices)
        self.maxfilesopen_data.SetFont(self.default_font)
        setval = self.advancedConfig['max_files_open']
        if setval == 0:
            setval = 'no limit '
        else:
            setval = str(setval)
        if not setval in self.maxfilesopen_choices:
            setval = self.maxfilesopen_choices[0]
        self.maxfilesopen_data.SetStringSelection(setval)

        self.maxconnections_choices = ['no limit ', '20', '30', '40', '50', '60', '100', '200']
        self.maxconnections_data=wxChoice(panel, -1, choices = self.maxconnections_choices)
        self.maxconnections_data.SetFont(self.default_font)
        setval = self.advancedConfig['max_connections']
        if setval == 0:
            setval = 'no limit '
        else:
            setval = str(setval)
        if not setval in self.maxconnections_choices:
            setval = self.maxconnections_choices[0]
        self.maxconnections_data.SetStringSelection(setval)

        self.superseeder_data=wxChoice(panel, -1,
                         choices = ['normal', 'super-seed'])
        self.superseeder_data.SetFont(self.default_font)
        self.superseeder_data.SetSelection(self.advancedConfig['super_seeder'])

        self.expirecache_choices = ['never ', '3', '5', '7', '10', '15', '30', '60', '90']
        self.expirecache_data=wxChoice(panel, -1, choices = self.expirecache_choices)
        setval = self.advancedConfig['expire_cache_data']
        if setval == 0:
            setval = 'never '
        else:
            setval = str(setval)
        if not setval in self.expirecache_choices:
            setval = self.expirecache_choices[0]
        self.expirecache_data.SetFont(self.default_font)
        self.expirecache_data.SetStringSelection(setval)
       

        twocolsizer = wxFlexGridSizer(cols = 2, hgap = 20)
        datasizer = wxFlexGridSizer(cols = 2, vgap = 2)
        datasizer.Add(StaticText('Local IP: '), 1, wxALIGN_CENTER_VERTICAL)
        datasizer.Add(self.ip_data)
        datasizer.Add(StaticText('IP to bind to: '), 1, wxALIGN_CENTER_VERTICAL)
        datasizer.Add(self.bind_data)
        if sys.version_info >= (2,3) and socket.has_ipv6:
            datasizer.Add(StaticText('IPv6 socket handling: '), 1, wxALIGN_CENTER_VERTICAL)
            datasizer.Add(self.ipv6bindsv4_data)
        datasizer.Add(StaticText('Minimum number of peers: '), 1, wxALIGN_CENTER_VERTICAL)
        datasizer.Add(self.minpeers_data)
        datasizer.Add(StaticText('Display interval (ms): '), 1, wxALIGN_CENTER_VERTICAL)
        datasizer.Add(self.displayinterval_data)
        datasizer.Add(StaticText('Disk allocation type:'), 1, wxALIGN_CENTER_VERTICAL)
        datasizer.Add(self.alloctype_data)
        datasizer.Add(StaticText('Allocation rate (MiB/s):'), 1, wxALIGN_CENTER_VERTICAL)
        datasizer.Add(self.allocrate_data)
        datasizer.Add(StaticText('File locking:'), 1, wxALIGN_CENTER_VERTICAL)
        datasizer.Add(self.locking_data)
        datasizer.Add(StaticText('Extra data checking:'), 1, wxALIGN_CENTER_VERTICAL)
        datasizer.Add(self.doublecheck_data)
        datasizer.Add(StaticText('Max files open:'), 1, wxALIGN_CENTER_VERTICAL)
        datasizer.Add(self.maxfilesopen_data)