Ignore:
Timestamp:
Feb 13, 2018, 4:52:00 PM (19 months ago)
Author:
Juanma
Message:

WIP

File:
1 edited

Legend:

Unmodified
Added
Removed
  • taskscheduler/trunk/fuentes/scheduler-gui.install/usr/share/taskscheduler/bin/taskScheduler.py

    r6764 r6811  
    1919from taskscheduler.taskscheduler import TaskScheduler as scheduler
    2020from taskscheduler.cronParser import cronParser
    21 from fixedDateBox import DetailBox as fixedDateTask
    22 from intervalDateBox import DetailBox as intervalDateTask
    23 from dailyDateBox import DetailBox as dailyDateTask
     21from detailDateBox import DetailBox as detailDateBox
    2422from edupals.ui.n4dgtklogin import *
    2523import signal
     
    3432GLADE_FILE=BASE_DIR+"rsrc/taskScheduler.ui"
    3533REMOVE_ICON=BASE_DIR+"rsrc/trash.svg"
     34EDIT_ICON=BASE_DIR+"rsrc/edit.svg"
     35NO_EDIT_ICON=BASE_DIR+"rsrc/no_edit.svg"
    3636LOCK_PATH="/var/run/taskScheduler.lock"
    3737WIDGET_MARGIN=6
     
    4848                self.ldm_helper='/usr/sbin/sched-ldm.sh'
    4949                self.i18n={}
    50                 self.types={'fix':fixedDateTask,'repeat':'TaskRepeat','days':fixedDateTask}
    5150                       
    5251        #def __init__           
     
    119118                self.btn_manage_tasks=builder.get_object("btn_manage_tasks")
    120119                self.btn_manage_tasks.connect("button-release-event", self._manage_tasks)
    121                 self.btn_remote_tasks=builder.get_object("btn_remote_tasks")
    122                 self.btn_local_tasks=builder.get_object("btn_local_tasks")
    123                 self.handler_remote=self.btn_remote_tasks.connect("clicked",self.view_tasks_clicked,True)
    124                 self.handler_local=self.btn_local_tasks.connect("clicked",self.view_tasks_clicked,False)
    125120                self.txt_search=builder.get_object("txt_search")
    126121                self.txt_search.connect('changed',self.match_tasks)
     122                self.nav_box=builder.get_object("nav_box")
     123                self.nav_box.set_visible(False)
     124                self.btn_fixed_sched=builder.get_object("btn_fixed_tasks")
     125                self.btn_fixed_sched.set_visible(False)
     126                self.btn_fixed_sched.set_no_show_all(True)
     127                self.btn_daily_sched=builder.get_object("btn_daily_tasks")
     128                self.btn_daily_sched.set_visible(False)
     129                self.btn_daily_sched.set_no_show_all(True)
     130                self.btn_repeat_sched=builder.get_object("btn_repetitive_tasks")
     131                self.btn_repeat_sched.set_visible(False)
     132                self.btn_repeat_sched.set_no_show_all(True)
     133                self.btn_all_sched=builder.get_object("btn_all_tasks")
     134                self.btn_all_sched.set_visible(False)
     135                self.btn_all_sched.set_no_show_all(True)
     136                self.btn_advanced_sched=Gtk.Button()
     137                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-countdown.svg")
     138                img=Gtk.Image().new_from_pixbuf(px)
     139                self.btn_fixed_sched.set_image(img)
     140                self.btn_fixed_sched.set_image_position(Gtk.PositionType.TOP)
     141                self.btn_fixed_sched.set_label(_("Fixed task"))
     142                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-calendar.svg")
     143                img=Gtk.Image().new_from_pixbuf(px)
     144                self.btn_daily_sched.set_image(img)
     145                self.btn_daily_sched.set_image_position(Gtk.PositionType.TOP)
     146                self.btn_daily_sched.set_label(_("Daily task"))
     147                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-swatches.svg")
     148                img=Gtk.Image().new_from_pixbuf(px)
     149                self.btn_repeat_sched.set_image(img)
     150                self.btn_repeat_sched.set_image_position(Gtk.PositionType.TOP)
     151                self.btn_repeat_sched.set_label(_("Repeat task"))
     152                px=GdkPixbuf.Pixbuf.new_from_file("/home/lliurex/Circle-icons-genius.svg")
     153                img=Gtk.Image().new_from_pixbuf(px)
     154                self.btn_all_sched.set_image(img)
     155                self.btn_all_sched.set_image_position(Gtk.PositionType.TOP)
     156                self.btn_all_sched.set_label(_("All tasks"))
     157                #Nav bar <--
    127158                #tasks list
    128159                self._load_task_list_gui(builder)
     
    133164                image.set_from_file(REMOVE_ICON)               
    134165                self.remove_icon=image.get_pixbuf()
     166                image.set_from_file(EDIT_ICON)         
     167                self.edit_icon=image.get_pixbuf()
     168                image.set_from_file(NO_EDIT_ICON)               
     169                self.no_edit_icon=image.get_pixbuf()
    135170
    136171                self.stack.add_titled(self.tasks_box, "tasks", "Tasks")
    137172                self.stack.add_titled(self.manage_box, "manage", "Manage")
    138173                self.stack.add_titled(self.add_task_box, "add", "Add Task")
    139 #               self.stack.add_titled(self.loginBox, "login", "Login")
    140174                self.stack.add_titled(self.login, "login", "Login")
    141175                #Packing
    142176                self.main_box.pack_start(self.stack,True,False,5)
     177
    143178                self.toolbar.props.no_show_all=True
     179                self.nav_box.props.no_show_all=True
    144180                self.window.connect("destroy",self.quit)
    145181                self.window.set_resizable(False)
     
    161197                self.tasks_label=builder.get_object("tasks_label")
    162198                self.tasks_tv=builder.get_object("tasks_treeview")
    163                 self.task_details_grid=fixedDateTask(self.scheduler)
    164 #               self.task_details_grid=DetailBox.DetailBox(self.scheduler)
    165                 td_grid=self.task_details_grid.render_form(builder.get_object("task_details_grid"))
    166                 self.detailGrid=builder.get_object("task_details_grid")
    167 
    168                 self.task_details_grid.btn_apply.set_sensitive(True)
    169                 self.task_details_grid.btn_apply.connect("clicked",self.update_task)
    170                 self.task_details_grid.chk_node.connect("toggled",self._reload_grid)
    171                 self.tasks_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf,str,str,str)
     199                self.tasks_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf,GdkPixbuf.Pixbuf,str,str,str,str)
    172200                self.tasks_store_filter=self.tasks_store.filter_new()
    173201                self.tasks_store_filter.set_visible_func(self.filter_tasklist)
     
    180208                column.pack_start(cell,True)
    181209                column.add_attribute(cell,"markup",0)
    182                 column.add_attribute(cell,"cell_background",6)
     210                column.add_attribute(cell,"cell_background",7)
     211                column.add_attribute(cell,"foreground",8)
    183212                column.set_expand(True)
    184213                self.tasks_tv.append_column(column)
     
    188217                column.pack_start(cell,True)
    189218                column.add_attribute(cell,"markup",1)
    190                 column.add_attribute(cell,"cell_background",6)
     219                column.add_attribute(cell,"cell_background",7)
     220                column.add_attribute(cell,"foreground",8)
    191221                column.set_expand(True)
    192222                column.set_visible(False)
     
    198228                column.pack_start(cell,False)
    199229                column.add_attribute(cell,"markup",2)
    200                 column.add_attribute(cell,"cell_background",6)
     230                column.add_attribute(cell,"cell_background",7)
     231                column.add_attribute(cell,"foreground",8)
    201232                column.set_expand(True)
    202233                self.tasks_tv.append_column(column)             
    203234
     235                column=Gtk.TreeViewColumn(_("Edit"))
     236
     237                cell=Gtk.CellRendererPixbuf()
     238                column.pack_start(cell,True)
     239                column.add_attribute(cell,"pixbuf",3)
     240                column.add_attribute(cell,"cell_background",7)
     241                self.col_edit=column
     242                self.tasks_tv.append_column(column)
     243               
    204244                column=Gtk.TreeViewColumn(_("Remove"))
    205245                cell=Gtk.CellRendererPixbuf()
    206 #               cell.set_property('cell_background','red')
    207246                column.pack_start(cell,True)
    208                 column.add_attribute(cell,"pixbuf",3)
    209                 column.add_attribute(cell,"cell_background",6)
     247                column.add_attribute(cell,"pixbuf",4)
     248                column.add_attribute(cell,"cell_background",7)
    210249                self.col_remove=column
    211250                self.tasks_tv.append_column(column)
    212                
     251
    213252                column=Gtk.TreeViewColumn(_("Command"))
    214                 cell=Gtk.CellRendererText()
    215                 column.pack_start(cell,True)
    216                 column.add_attribute(cell,"markup",4)
    217                 column.set_expand(True)
    218                 column.set_visible(False)
    219                 self.tasks_tv.append_column(column)
    220                
    221                 column=Gtk.TreeViewColumn(_("Type"))
    222253                cell=Gtk.CellRendererText()
    223254                column.pack_start(cell,True)
     
    226257                column.set_visible(False)
    227258                self.tasks_tv.append_column(column)
     259               
     260                column=Gtk.TreeViewColumn(_("Type"))
     261                cell=Gtk.CellRendererText()
     262                column.pack_start(cell,True)
     263                column.add_attribute(cell,"markup",6)
     264                column.set_expand(True)
     265                column.set_visible(False)
     266                self.tasks_tv.append_column(column)
    228267
    229268                self.tasks_tv.set_search_column(2)
     
    232271                #Add tasks
    233272                self.add_task_box=builder.get_object("add_task_box")
    234                 self.add_task_grid=fixedDateTask(self.scheduler)
    235 #               self.add_task_grid=DetailBox(self.scheduler)
    236                 at_grid=self.add_task_grid.render_form(builder.get_object("add_task_grid"),False)
     273                self.add_task_grid=detailDateBox(self.scheduler)
     274                at_grid=self.add_task_grid.render_form(builder.get_object("add_task_grid"))
    237275                at_grid=builder.get_object("add_task_grid")
    238276                self.cmb_task_names=builder.get_object("cmb_task_names")
     
    240278                builder.get_object("btn_back_add").connect("clicked", self.cancel_add_clicked)
    241279                builder.get_object("btn_cancel_add").connect("clicked", self.cancel_add_clicked)
    242                 builder.get_object("btn_confirm_add").connect("clicked", self.save_task_details)
    243                 self.chk_remote=builder.get_object("swt_remote")
    244                 self.chk_local=builder.get_object("swt_local")
     280                self.btn_confirm_add=builder.get_object("btn_confirm_add")
     281                self.btn_confirm_add.connect("clicked", self.save_task_details)
    245282        #def _load_task_list_gui
    246283
     
    314351        def _signin(self,user=None,pwd=None,server=None,data=None):
    315352                self.scheduler.set_credentials(user,pwd,server)
    316                 if server=='localhost':
    317                         self.btn_local_tasks.set_active(True)
    318                         self.btn_remote_tasks.set_visible(False)
    319                         self.btn_local_tasks.set_visible(False)
    320                 else:
    321                         self.btn_remote_tasks.set_active(True)
     353                self.stack.set_visible_child_name("tasks")
     354                self.populate_tasks_tv()
    322355                self.toolbar.show()
     356                self.nav_box.show()
    323357        #def _signin
    324358
    325359        def populate_tasks_tv(self,sw_remote=False):
    326360                self._debug("Populating task list")
    327                 self.task_details_grid.btn_apply.set_sensitive(False)
    328361                self.scheduled_tasks={}
    329362                tasks=[]
     
    333366                if type(tasks)==type({}):       
    334367                        parser=cronParser()
     368                        self.i18n['cmd']={}
     369                        self.i18n['name']={}
    335370                        for task_name in tasks.keys():
    336371                                for serial in tasks[task_name].keys():
    337372                                        task=tasks[task_name][serial]
    338373                                        task['sw_remote']=''
    339                                         color='silver'
    340                                         if 'sched' in task.keys():
    341                                                 task['sched']==task['sched']
    342                                                 color='orange'
     374                                        color_palette=['goldenrod','DarkSlateGrey','Burlywood','DarkSlateGrey','DarkSlateBlue','bisque','LightSteelBlue','DarkSlateGrey']
     375                                        bg_color=color_palette[0]
     376                                        fg_color=color_palette[1]
     377                                        if 'kind' in task.keys():
     378                                                if 'fixed' in task['kind']:
     379                                                        bg_color=color_palette[2]
     380                                                        fg_color=color_palette[3]
     381                                                elif 'repeat' in task['kind']:
     382                                                        bg_color=color_palette[4]
     383                                                        fg_color=color_palette[5]
     384                                                elif 'daily' in task['kind']:
     385                                                        bg_color=color_palette[6]
     386                                                        fg_color=color_palette[7]
    343387                                        else:
    344                                                 task['sched']=''
    345 #                                       self.scheduled_tasks[task_name]=tasks[task_name][serial]
     388                                                task['kind']=''
     389                                        remote='Local task'
     390                                        if 'spread' in task.keys():
     391                                                if task['spread']==True:
     392                                                        remote="Client task"
     393                                        else:
     394                                                task['spread']=False
    346395                                        self.scheduled_tasks[task_name]=tasks[task_name]
    347 #                                       for task in tasks[task_name][serial]:
    348396                                        sw_tasks=True
    349397                                        parsed_calendar=''
     
    351399                                        task['cmd']=task['cmd'].replace(self.ldm_helper+' ','')
    352400                                        task['action']=self.scheduler.get_task_description(task['cmd'])
    353                                         self.i18n['cmd']={_(task['action']):task['action']}
    354                                         self.i18n['name']={_(task_name):task_name}
    355                                         row=self.tasks_store.append(("<span font='Roboto'><b>"+_(task['action'])+"</b></span>\n"+\
     401                                        if 'name' in task.keys():
     402                                                name=task['name']
     403                                        else:
     404                                                name=_(task['action'])
     405                                        self.i18n['cmd'].update({name:task['action']})
     406                                        self.i18n['name'].update({_(task_name):task_name})
     407                                        img=self.edit_icon
     408                                        if 'protected' in task.keys():
     409                                                if task['protected']==True:
     410                                                        img=self.no_edit_icon
     411                                        row=self.tasks_store.append(("<span font='Roboto'><b>"+name+"</b></span>\n"+\
    356412                                                                "<span font='Roboto' size='small'><i>"+\
    357413                                                                _(task_name)+"</i></span>",serial,"<span font='Roboto' size='small'>"+\
    358                                                                 parsed_calendar+"</span>",self.remove_icon,task['sw_remote'],task['sched'],color))
    359                 if sw_tasks:
    360                         self.task_details_grid.btn_apply.set_sensitive(True)
     414                                                                parsed_calendar+"</span>\n"+"<span font='Roboto' size='small'><i>"+remote+"</i></span>",img,self.remove_icon,str(task['spread']),','.join(task['kind']),bg_color,fg_color))
    361415        #def populate_tasks_tv
    362416       
     
    384438                task={}
    385439                task['data']=model[data][0].split('\n')
     440                if _("client task") in model[data][2]:
     441                        task['spread']=True
     442                else:
     443                        task['spread']=False
    386444                task['serial']=model[data][1].split('\n')[0]
    387445                cmd=task['data'][0][task['data'][0].find("<b>")+3:task['data'][0].find("</b>")]
     
    398456
    399457                task['serial']=model[data][1]
    400                 if self.btn_remote_tasks.get_active():
    401                         task['type']='remote'
    402                         task['sw_remote']=True
    403                 else:
    404                         task['type']='local'
    405                         task['sw_remote']=False
    406458                return(task)
    407459
    408         def _click_on_delete(self,event):
    409                 sw_show=True
     460        def _click_on_list(self,event):
     461                action=''
    410462                try:
    411463                        row=self.tasks_tv.get_path_at_pos(int(event.x),int(event.y))
     
    414466                if row:
    415467                        if row[1]==self.col_remove:
    416                                 sw_show=False
    417                 return sw_show
     468                                action='remove'
     469                        elif row[1]==self.col_edit:
     470                                action='edit'
     471                self._debug(action)
     472                return action
    418473
    419474        def task_clicked(self,treeview,event=None):
    420475                self._debug("task clicked %s"%event)
    421                 if self.task_details_grid:
    422                         self.task_details_grid.clear_screen()
    423476                selection=self.tasks_tv.get_selection()
    424477                model,data=selection.get_selected()
     
    426479                        return
    427480                task={}
    428                 sw_show=True
     481                action=''
    429482                if event!=None:
    430                         sw_show=self._click_on_delete(event)
     483                        action=self._click_on_list(event)
    431484                task=self._process_model(model,data)
    432                 if sw_show:
    433                         if task['name'] in self.scheduled_tasks.keys():
    434                                 if task['serial'] in self.scheduled_tasks[task['name']].keys():
    435                                         task['data']=self.scheduled_tasks[task['name']][task['serial']]
    436                                         self._debug("Loading details of task %s of group %s remote %s"% (task['serial'],task['name'],task['sw_remote']))
    437                                         self.task_details_grid.set_task_data(task)
    438                                         self.task_details_grid.load_task_details()
    439                 else:
     485                if action=='remove':
    440486                        self.lbl_question.set_text(_("Are you sure to delete this task?"))
    441487                        for widget in self.main_box.get_children():
     
    447493                        except:
    448494                                pass
    449                         self.inf_question.connect('response',self.manage_remove_responses,model,task['name'],task['serial'],task['cmd'],task['type'],data)
     495                        self.inf_question.connect('response',self.manage_remove_responses,model,task)
     496                elif action=='edit':
     497                        if task['name'] in self.scheduled_tasks.keys():
     498                                if task['serial'] in self.scheduled_tasks[task['name']].keys():
     499                                        task['data']=self.scheduled_tasks[task['name']][task['serial']]
     500                                        self._debug("Loading details of task %s of group %s"% (task['serial'],task['name']))
     501                                        self.add_task_grid.set_task_data(task)
     502                                        self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
     503                                        self.cmb_task_names.append_text(_(task['name']))
     504                                        self.cmb_task_cmds.append_text(_(task['cmd']))
     505                                        self.cmb_task_names.set_active(0)
     506                                        self.cmb_task_cmds.set_active(0)
     507                                        self.add_task_grid.load_task_details()
     508                                        if 'protected' in task['data'].keys():
     509                                                if task['data']['protected']:
     510                                                        self.btn_confirm_add.set_sensitive(False)
     511                                        else:
     512                                                self.btn_confirm_add.set_sensitive(True)
     513                                        self.stack.set_visible_child_name("add")
    450514        #def task_clicked                       
    451515
     
    453517                task={}
    454518                name=self.cmb_task_names.get_active_text()
    455 #               task_name=self.orig_tasks[name]
    456519                task['name']=self.i18n['name'][name]
    457520                action=self.cmb_task_cmds.get_active_text()
     
    459522                tasks=self.scheduler.get_available_tasks()
    460523                task['cmd']=tasks[task['name']][i18n_action]
    461                 task['sw_remote']=False
    462 #               task_type='local'
    463                 if self.btn_remote_tasks.get_active():
    464                         task['sw_remote']=True
    465 #                       task_type='remote'
    466                 self.add_task_grid.set_task_data(task)
    467524                task=self.add_task_grid.get_task_details()
    468525
    469                 self._debug("Writing task info...")
    470                 if self.chk_remote.get_active():
    471                         status=self.scheduler.write_tasks(task,'remote')
    472                 if self.chk_local.get_active():
    473                         status=self.scheduler.write_tasks(task,'local')
     526                self._debug("Writing task info...%s"%task)
     527                status=self.scheduler.write_tasks(task,'local')
    474528                if status:
    475529                        self._show_info(_("Task saved"))
     
    482536                if widget:
    483537                        if not widget.get_active():
    484                                 if sw_remote:
    485                                         self._block_widget_state(True,widget,self.handler_remote)
    486                                 else:                                   
    487                                         self._block_widget_state(True,widget,self.handler_local)
    488538                                return True
    489539                self._debug("loading tasks (remote: %s)" % sw_remote)
    490540                if sw_remote:
    491                         self.btn_local_tasks.set_active(False)
    492                         self.btn_local_tasks.props.active=False
    493541                        self.last_task_type='remote'
    494542                else:
    495                         self.btn_remote_tasks.set_active(False)
    496                         self.btn_remote_tasks.props.active=False
    497543                        self.last_task_type='local'
    498544                self._debug("Task clicked")
    499                 self.populate_tasks_tv(sw_remote)
     545                self.populate_tasks_tv()
    500546                self.tasks_tv.set_model(self.tasks_store_filter)
    501547                self.tasks_tv.set_cursor(0)
     
    505551
    506552        def load_add_task_details(self):
    507                 if not self.btn_remote_tasks.get_visible():
    508                         self.chk_remote.set_visible(False)
    509                         self.chk_local.set_active(1)
    510                         self.chk_remote.set_active(0)
    511                         self.chk_local.set_sensitive(False)
    512                 else:
    513                         if self.btn_remote_tasks.get_active():
    514                                 self.chk_remote.set_active(1)
    515                                 self.chk_local.set_active(0)
    516                         else:
    517                                 self.chk_local.set_active(1)
    518                                 self.chk_remote.set_active(0)
    519 
    520                 self._block_widget_state(False,self.btn_remote_tasks,self.handler_remote)
    521                 self._block_widget_state(False,self.btn_local_tasks,self.handler_local)
    522553                tasks=[]
    523554                names=[]
    524 #               self.orig_tasks={}
    525555                self.cmb_task_names.remove_all()
    526556                tasks=self.scheduler.get_available_tasks()
    527557                for name in tasks.keys():
    528                         print("APPEND: %s"%name)
    529558                        if name not in names:
    530559                                names.append(name)
    531560                                self.i18n['name'].update({_(name):name})
    532 #                               self.orig_tasks[_(name)]=name
    533                                 print("PROCESS %s"%name)
    534561                                self.cmb_task_names.append_text(_(name))
    535562               
     
    544571                task_name=self.cmb_task_names.get_active_text()
    545572                if task_name:
    546 #                       orig_name=self.orig_tasks[task_name]
    547573                        orig_name=self.i18n['name'][task_name]
    548                         print(tasks)
    549574                        for action in tasks[orig_name].keys():
    550575                                if action not in actions:
     
    570595                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
    571596                self.stack.set_visible_child_name("add")
    572                 if self.btn_remote_tasks.get_active():
    573                         self.last_task_type='remote'
    574                 else:
    575                         self.last_task_type='local'
    576597                self.load_add_task_details()
    577598        #def add_task_clicked   
     
    580601                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
    581602                self.stack.set_visible_child_name("tasks")     
    582                 if self.last_task_type=='remote':
    583                         self._block_widget_state(True,self.btn_remote_tasks,self.handler_remote)
    584                 else:
    585                         self._block_widget_state(True,self.btn_local_tasks,self.handler_local)
    586603                self._debug("Cancel add clicked")
    587604                self._reload_grid()
     
    591608                cursor=self.tasks_tv.get_cursor()[0]
    592609                self._debug("CURSOR %s"%widget)
    593                 if self.btn_remote_tasks.get_active():
    594 #                       task_type='remote'
    595                         sw_remote=True
    596                 else:
    597 #                       task_type='local'
    598                         sw_remote=False
    599610                self._debug("Reload grid")
    600                 self.populate_tasks_tv(sw_remote)
     611                self.populate_tasks_tv()
    601612                if cursor:
    602613                        self._debug("Restoring cursor")
     
    607618        #def _reload_grid
    608619
    609         def manage_remove_responses(self,widget,response,model,task_name,task_serial,task_cmd,task_type,data):
     620        def manage_remove_responses(self,widget,response,model,task):
    610621                self.inf_question.hide()
    611622                if response==Gtk.ResponseType.OK:
    612                         self._debug("Removing task %s - %s - %s"%(task_name,task_serial,task_cmd))
    613                         if task_name in self.i18n['name'].keys():
    614                                 name=self.i18n['name'][task_name]
    615                         else:
    616                                 name=task_name
    617                         if task_cmd in self.i18n['cmd'].keys():
    618                                 cmd=self.i18n['cmd'][task_cmd]
    619                         else:
    620                                 cmd=task_cmd
    621                         if self.scheduler.remove_task(name,task_serial,cmd,task_type):
    622                                 self.populate_tasks_tv(task_type)
     623                        self._debug("Removing task %s"%(task))
     624                        if task['name'] in self.i18n['name'].keys():
     625                                task['name']=self.i18n['name'][task['name']]
     626                        if task['cmd'] in self.i18n['cmd'].keys():
     627                                task['cmd']=self.i18n['cmd'][task['cmd']]
     628                        if self.scheduler.remove_task(task):
     629                                self.populate_tasks_tv()
    623630                                self.tasks_tv.set_cursor(0)
    624631                        else:
     
    636643        def _manage_tasks(self,widget,event):
    637644                self._debug("Loading manage tasks form")
    638                 if self.btn_remote_tasks.get_active():
    639                         self.last_task_type='remote'
    640                 else:
    641                         self.last_task_type='local'
    642645                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
    643646                self.stack.set_visible_child_name("manage")
    644                 self._block_widget_state(False,self.btn_remote_tasks,self.handler_remote)
    645                 self._block_widget_state(False,self.btn_local_tasks,self.handler_local)
    646647        #def _manage_tasks     
    647648
     
    649650                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
    650651                self.stack.set_visible_child_name("tasks")     
    651                 if self.last_task_type=='remote':
    652                         self._block_widget_state(True,self.btn_remote_tasks,self.handler_remote)
    653                 else:
    654                         self._block_widget_state(True,self.btn_local_tasks,self.handler_local)
    655 
    656         ###
    657         #Changes the state of a widget blocking the signals
    658         ###
    659         def _block_widget_state(self,state,widget,handler):
    660                 widget.handler_block(handler)
    661                 widget.set_active(state)
    662                 GObject.timeout_add(100,widget.handler_unblock,handler)
    663         #def _block_widget_state
    664652       
    665653        def set_css_info(self):
Note: See TracChangeset for help on using the changeset viewer.