Ticket #97: scheduler_additional_prefs.patch

File scheduler_additional_prefs.patch, 12.3 KB (added by ben@axnick.com.au, 17 years ago)

patchfile

  • plugins/Scheduler/plugin.py 

    diff --git a/plugins/Scheduler/plugin.py b/plugins/Scheduler/plugin.py
index 869fe0f..c43bd28 100644
    a b class plugin_Scheduler:  
    1313        self.config = deluge.pref.Preferences()
    1414        self.button_state_temp = [[0] * 7 for dummy in xrange(24)]
    1515        self.status = -1
    16         self.prevact = None
    1716
    1817        #Load config
    1918        self.button_state = None
    20         self.dllimit = self.ullimit = None
    21         self.dlmax = self.ulmax = None
     19        self.settings_structure = [["low_down", "max_download_speed", float],
     20                                   ["low_up", "max_upload_speed", float],
     21                                   ["high_down", "max_download_speed", float],
     22                                   ["high_up", "max_upload_speed", float],
     23                                   ["low_activetorrents", "max_active_torrents", float],
     24                                   ["low_numslots", "max_upload_slots_global", float],
     25                                   ["low_maxconns", "max_connections_global", float],
     26                                   ["high_activetorrents", "max_active_torrents", float],
     27                                   ["high_numslots", "max_upload_slots_global", float],
     28                                   ["high_maxconns", "max_connections_global", float]]
     29               
     30        self.settings = {}
     31       
    2232        try:
    2333            reader = open(self.conf_file, "rb")
    2434            data = pickle.load(reader)
     35           
    2536            self.button_state = data[0]
    26             self.dllimit = float(data[1][0])
    27             self.ullimit = float(data[1][1])
    28             self.dlmax = float(data[1][2])
    29             self.ulmax = float(data[1][3])
     37            for i, item in enumerate(self.settings_structure):
     38                self.settings[item[0]] = data[1][i]
     39
    3040            reader.close()
    3141        except:
    3242            if self.button_state is None:
    3343                self.button_state = [[0] * 7 for dummy in xrange(24)]
    34             gdl = self.config.get("max_download_speed")
    35             gul = self.config.get("max_upload_speed")
    36             if self.dllimit is None:
    37                 self.dllimit = float(gdl)
    38             if self.ullimit is None:
    39                 self.ullimit = float(gul)
    40             if self.dlmax is None:
    41                 self.dlmax = float(gdl)
    42             if self.ulmax is None:
    43                 self.ulmax = float(gul)
     44               
     45            for item in self.settings_structure:
     46                if item[0] not in self.settings:
     47                    temp = self.config.get(item[1])
     48                   
     49                    if item[2] is not None:
     50                        temp = item[2](temp)
     51                   
     52                    self.settings[item[0]] = temp
    4453
    4554        now = time.localtime(time.time())
    4655        self.status = self.button_state[now[3]][now[6]]
    … … class plugin_Scheduler:  
    4857
    4958        # Force speed changes when the plugin loads
    5059        self._state(self.status)
    51 
     60   
    5261    def unload(self):
    5362        self.status = -1
    54         self.resume()
    5563        self.unlimit()
    5664
    57     def _state(self,state):
     65    def _state(self, state):
    5866        if state == 0:
    5967            self.unlimit()
    6068        elif state == 1:
    6169            self.limit()
    6270        elif state == 2:
    6371            self.pause()
    64         # If we're moving from paused
    65         if state < 2 and self.status == 2:
    66             self.resume()
    67         self.status = state
     72       
    6873        # Update the settings
    69         self.interface.apply_prefs()
     74        self.status = state
    7075
    7176    def update(self):
    7277        # Only do stuff if the status is valid
    … … class plugin_Scheduler:  
    8085                self._state(self.button_state[now[3]][now[6]])
    8186
    8287    def pause(self):
    83         self.prevact = self.config.get("max_active_torrents")
    8488        self.config.set("max_active_torrents", 0)
    85         self.core.apply_queue()
    86 
    87     def resume(self):
    88         if self.prevact != None:
    89             self.config.set("max_active_torrents", self.prevact)
    90         self.core.apply_queue()
    9189
    9290    def limit(self):
    93         self.config.set("max_download_speed", float(self.dllimit))
    94         self.config.set("max_upload_speed", float(self.ullimit))
     91        self.apply_configuration("low")
    9592
    9693    def unlimit(self):
    97         self.config.set("max_download_speed", float(self.dlmax))
    98         self.config.set("max_upload_speed", float(self.ulmax))
     94        self.apply_configuration("high")
    9995
     96    def apply_configuration(self, type):
     97        for item in self.settings_structure:
     98            if item[0].find(type) == 0:
     99                self.config.set(item[1], self.settings[item[0]])
     100       
     101        self.core.apply_queue()
     102        self.interface.apply_prefs()
     103   
    100104    #Configuration dialog
    101105    def configure(self, window):
    102106        global scheduler_select
    103107
    104108        self.button_state_temp = copy.deepcopy(self.button_state)
    105 
     109       
     110        #data
     111        spin = {}
     112        boxen = [
     113                 ["down", _("Download limit:"), -1, 2048],
     114                 ["up", _("Upload limit:"), -1, 1024],
     115                 ["activetorrents", _("Active torrents:"), 0, 128],
     116                 ["numslots", _("Upload Slots:"), 0, 128],
     117                 ["maxconns", _("Max Connections:"), 0, 1024]]
     118       
    106119        #dialog
    107120        dialog = gtk.Dialog(_("Scheduler Settings"))
    108121        dialog.set_default_size(600, 270)
    … … class plugin_Scheduler:  
    114127        #text
    115128        hover_text = gtk.Label()
    116129
    117         dlmax_label = gtk.Label(_("High download limit:"))
    118         ulmax_label = gtk.Label(_("High upload limit:"))
    119         dllimit_label = gtk.Label(_("Low download limit:"))
    120         ullimit_label = gtk.Label(_("Low upload limit:"))
    121 
    122130        #Select Widget
    123131        drawing = scheduler_select(self.button_state_temp, hover_text, self.days)
    124132
    … … class plugin_Scheduler:  
    128136        vbox_sub = gtk.VBox()
    129137        hbox_key = gtk.HBox()
    130138        hbox_info = gtk.HBox()
    131         # max boxen
    132         hbox_max = gtk.HBox()
    133         ebox_max = gtk.EventBox()
    134         ebox_max.add(hbox_max)
    135         ebrd_max = gtk.Frame()
    136         ebrd_max.add(ebox_max)
    137         ebrd_max.set_border_width(2)
    138         hbox_max.set_border_width(2)
    139         ebox_max.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#73D716"))
    140         ebrd_max.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#53B700"))
    141         # limit boxen
    142         hbox_limit = gtk.HBox()
    143         ebox_limit = gtk.EventBox()
    144         ebox_limit.add(hbox_limit)
    145         ebrd_limit = gtk.Frame()
    146         ebrd_limit.add(ebox_limit)
    147         ebrd_limit.set_border_width(2)
    148         hbox_limit.set_border_width(2)
     139        hbox_settings = gtk.HBox()
     140        # high boxen
     141        tbl_high = gtk.Table(len(boxen), 2)
     142        ebox_high = gtk.EventBox()
     143        ebox_high.add(tbl_high)
     144        ebrd_high = gtk.Frame()
     145        ebrd_high.add(ebox_high)
     146        ebrd_high.set_border_width(2)
     147        tbl_high.set_border_width(2)
     148        ebox_high.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#73D716"))
     149        ebrd_high.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#53B700"))
     150        # low boxen
     151        tbl_low = gtk.Table(len(boxen), 2)
     152        ebox_low = gtk.EventBox()
     153        ebox_low.add(tbl_low)
     154        ebrd_low = gtk.Frame()
     155        ebrd_low.add(ebox_low)
     156        ebrd_low.set_border_width(2)
     157        tbl_low.set_border_width(2)
    149158        # Green
    150159        # Yellow
    151         ebox_limit.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#EDD400"))
    152         ebrd_limit.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#CDB400"))
     160        ebox_low.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#EDD400"))
     161        ebrd_low.modify_bg(gtk.STATE_NORMAL,gtk.gdk.color_parse("#CDB400"))
    153162
    154163        #seperator
    155164        sep = gtk.HSeparator()
    156 
    157         # max spinbuttons
    158         dminput = gtk.SpinButton()
    159         dminput.set_numeric(True)   
    160         dminput.set_range(-1, 2048)
    161         dminput.set_increments(1, 10)
    162         dminput.set_value(float(self.dlmax))
    163         uminput = gtk.SpinButton()
    164         uminput.set_numeric(True)
    165         uminput.set_range(-1, 1024)
    166         uminput.set_increments(1, 10)
    167         uminput.set_value(float(self.ulmax))
    168 
    169         # limit spinbuttons
    170         dlinput = gtk.SpinButton()
    171         dlinput.set_numeric(True)   
    172         dlinput.set_range(-1, 2048)
    173         dlinput.set_increments(1, 10)
    174         dlinput.set_value(float(self.dllimit))
    175         ulinput = gtk.SpinButton()
    176         ulinput.set_numeric(True)
    177         ulinput.set_range(-1, 1024)
    178         ulinput.set_increments(1, 10)
    179         ulinput.set_value(float(self.ullimit))
    180 
     165       
    181166        #pack
    182167        dialog.vbox.pack_start(vbox_main)
    183168
    … … class plugin_Scheduler:  
    186171        vbox_main.pack_start(hbox_key, False, True)
    187172        vbox_main.pack_start(hbox_info, False, True)
    188173        vbox_main.pack_start(sep, False, True)
    189         vbox_main.pack_start(ebrd_max, False, True, 5)
    190         vbox_main.pack_start(ebrd_limit, False, True, 5)
     174        vbox_main.pack_start(hbox_settings)
    191175
    192176        hbox_main.pack_start(vbox_sub, False, True, 5)
    193177        hbox_main.pack_start(drawing)
    194178
    195179        hbox_key.pack_start(gtk.Label(_("Green is the high limits, yellow is the low limits and red is stopped")), True, False)
    196180        hbox_info.pack_start(gtk.Label(_("If a limit is set to -1, it is unlimitted.")), True, False)
    197 
    198         hbox_max.pack_start(dlmax_label, True, False)
    199         hbox_max.pack_start(dminput, True, False)
    200         hbox_max.pack_start(ulmax_label, True, False)
    201         hbox_max.pack_start(uminput, True, False)
    202 
    203         hbox_limit.pack_start(dllimit_label, True, False)
    204         hbox_limit.pack_start(dlinput, True, False)
    205         hbox_limit.pack_start(ullimit_label, True, False)
    206         hbox_limit.pack_start(ulinput, True, False)
     181       
     182        hbox_settings.pack_start(ebrd_high, True, True, 5)
     183        hbox_settings.pack_start(gtk.Label())
     184        hbox_settings.pack_start(ebrd_low, True, True, 5)
     185                     
     186        for box in [tbl_high, tbl_low]:
     187            for y, val in enumerate(boxen):
     188                if box is tbl_high: type = "high"
     189                else: type = "low"
     190                key = type + "_" + val[0]
     191               
     192                label = gtk.Label(val[1])
     193                label.set_alignment(0.0, 0.6)
     194                spin[key] = gtk.SpinButton()
     195                spin[key].set_numeric(True)   
     196                spin[key].set_range(val[2], val[3])
     197                spin[key].set_increments(1, 10)
     198                spin[key].set_value(self.settings[key])
     199               
     200                box.attach(label, 0, 1, y, y + 1)
     201                box.attach(spin[key], 1, 2, y, y + 1, False, False)
    207202
    208203        for index in xrange(len(self.days)):
    209204            vbox_sub.pack_start(gtk.Label(self.days[index]))
    … … class plugin_Scheduler:  
    219214                self.button_state = copy.deepcopy(drawing.button_state)
    220215                changed = True
    221216           
    222             if not self.dlmax == float(dminput.get_value()):
    223                 self.dlmax = float(dminput.get_value())
    224                 changed = True
    225 
    226             if not self.ulmax == float(uminput.get_value()):
    227                 self.ulmax = float(uminput.get_value())
    228                 changed = True
    229 
    230             if not self.dllimit == float(dlinput.get_value()):
    231                 self.dllimit = float(dlinput.get_value())
    232                 changed = True
    233 
    234             if not self.ullimit == float(ulinput.get_value()):
    235                 self.ullimit = float(ulinput.get_value())
    236                 changed = True
     217            for key in spin.keys():
     218                if not self.settings[key] == spin[key].get_value():
     219                    self.settings[key] = spin[key].get_value()
     220                    changed = True
    237221
    238222            now = time.localtime(time.time())
    239223            if changed:
    240224                self._state(self.button_state[now[3]][now[6]])
    241225
    242226            writer = open(self.conf_file, "wb")
    243             pickle.dump([drawing.button_state,[self.dllimit, self.ullimit, self.dlmax, self.ulmax]], writer)
     227           
     228            out = []
     229           
     230            for item in self.settings_structure:
     231                out.append(self.settings[item[0]])
     232               
     233            pickle.dump([drawing.button_state, out], writer)
    244234            writer.close()
    245 
     235           
    246236        dialog.destroy()
    247237
    248238class scheduler_select(gtk.DrawingArea):