source: taskscheduler/trunk/fuentes/scheduler-gui.install/usr/share/taskscheduler/bin/taskScheduler.py @ 6811

Last change on this file since 6811 was 6811, checked in by Juanma, 19 months ago

WIP

  • Property svn:executable set to *
File size: 23.9 KB
Line 
1#! /usr/bin/python3
2# -*- coding: utf-8 -*-
3import gi
4gi.require_version('Gtk', '3.0')
5gi.require_version('PangoCairo', '1.0')
6import json
7import cairo
8import os
9import subprocess
10import shutil
11import threading
12import platform
13import subprocess
14import sys
15import time
16#import commands
17from gi.repository import Gtk, Gdk, GdkPixbuf, GObject, GLib, PangoCairo, Pango
18import time
19from taskscheduler.taskscheduler import TaskScheduler as scheduler
20from taskscheduler.cronParser import cronParser
21from detailDateBox import DetailBox as detailDateBox
22from edupals.ui.n4dgtklogin import *
23import signal
24signal.signal(signal.SIGINT, signal.SIG_DFL)
25
26import gettext
27gettext.textdomain('taskscheduler')
28_ = gettext.gettext
29
30BASE_DIR="/usr/share/taskscheduler/"
31#BASE_DIR="../share/taskscheduler/"
32GLADE_FILE=BASE_DIR+"rsrc/taskScheduler.ui"
33REMOVE_ICON=BASE_DIR+"rsrc/trash.svg"
34EDIT_ICON=BASE_DIR+"rsrc/edit.svg"
35NO_EDIT_ICON=BASE_DIR+"rsrc/no_edit.svg"
36LOCK_PATH="/var/run/taskScheduler.lock"
37WIDGET_MARGIN=6
38DBG=1
39
40class TaskScheduler:
41        def __init__(self):
42                self.is_scheduler_running()
43                try:
44                        self.flavour=subprocess.getoutput("lliurex-version -f")
45                except:
46                        self.flavour="client"
47                self.last_task_type='remote'
48                self.ldm_helper='/usr/sbin/sched-ldm.sh'
49                self.i18n={}
50                       
51        #def __init__           
52
53        def _debug(self,msg):
54                if DBG:
55                        print("taskScheduler: %s"%msg)
56        #def _debug
57
58        def is_scheduler_running(self):
59                if os.path.exists(LOCK_PATH):
60                        dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.ERROR, Gtk.ButtonsType.CANCEL, "Task Scheduler")
61                        dialog.format_secondary_text(_("There's another instance of Task Scheduler running."))
62                        dialog.run()
63                        sys.exit(1)
64        #def is_scheduler_running
65
66        def start_gui(self):
67                self.scheduler=scheduler()
68                builder=Gtk.Builder()
69                builder.set_translation_domain('taskscheduler')
70
71                self.stack = Gtk.Stack()
72                self.stack.set_transition_duration(1000)
73                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
74
75                glade_path=GLADE_FILE
76                builder.add_from_file(glade_path)
77
78                self.window=builder.get_object("main_window")
79                self.main_box=builder.get_object("main_box")
80                self.login=N4dGtkLogin()
81                self.login.set_allowed_groups(['adm','teachers'])
82                desc=_("Welcome to the Task Scheduler for Lliurex.\nFrom here you can:\n<sub>* Schedule tasks in the local pc\n* Distribute tasks among all the pcs in the network\n*Show scheduled tasks</sub>")
83                self.login.set_info_text("<span foreground='black'>Task Scheduler</span>",_("Task Scheduler"),"<span foreground='black'>"+desc+"</span>\n")
84                self.login.set_info_background(image='taskscheduler',cover=True)
85                self.login.after_validation_goto(self._signin)
86                self.login.hide_server_entry()
87                self.inf_message=Gtk.InfoBar()
88                self.inf_message.set_show_close_button(True)
89                self.lbl_message=Gtk.Label("")
90                self.inf_message.get_action_area().add(self.lbl_message)
91                self.inf_message.set_halign(Gtk.Align.CENTER)
92                self.inf_message.set_valign(Gtk.Align.CENTER)
93                def hide(widget,response):
94                        self.inf_message.hide()
95                self.inf_message.connect('response',hide)
96#               self.inf_message.props.no_show_all=True
97
98                self.inf_question=Gtk.InfoBar() 
99                self.lbl_question=Gtk.Label("")
100                self.inf_question.get_action_area().add(self.lbl_question)
101                self.inf_question.add_button(Gtk.STOCK_CANCEL,Gtk.ResponseType.CANCEL)
102                self.inf_question.add_button(Gtk.STOCK_OK,Gtk.ResponseType.OK)
103                self.inf_question.set_halign(Gtk.Align.CENTER)
104                self.inf_question.set_valign(Gtk.Align.CENTER)
105#               self.inf_question.props.no_show_all=True
106                self.main_box.pack_start(self.inf_question,False,False,0)
107                self.main_box.pack_start(self.inf_message,False,False,0)
108                self.view_tasks_button_box=builder.get_object("view_tasks_button_box")
109                self.view_tasks_eb=builder.get_object("view_tasks_eventbox")
110                self.btn_signal_id=None
111                #Toolbar
112                self.toolbar=builder.get_object("toolbar")
113                self.toolbar.set_visible(False)
114                self.btn_add_task=builder.get_object("btn_add_task")
115                self.btn_add_task.connect("button-release-event", self.add_task_clicked)
116                self.btn_refresh_tasks=builder.get_object("btn_refresh_tasks")
117                self.btn_refresh_tasks.connect("button-release-event", self._reload_grid)
118                self.btn_manage_tasks=builder.get_object("btn_manage_tasks")
119                self.btn_manage_tasks.connect("button-release-event", self._manage_tasks)
120                self.txt_search=builder.get_object("txt_search")
121                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 <--
158                #tasks list
159                self._load_task_list_gui(builder)
160                #Manage tasks
161                self._load_manage_tasks(builder)
162                #Icons
163                image=Gtk.Image()
164                image.set_from_file(REMOVE_ICON)               
165                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()
170
171                self.stack.add_titled(self.tasks_box, "tasks", "Tasks")
172                self.stack.add_titled(self.manage_box, "manage", "Manage")
173                self.stack.add_titled(self.add_task_box, "add", "Add Task")
174                self.stack.add_titled(self.login, "login", "Login")
175                #Packing
176                self.main_box.pack_start(self.stack,True,False,5)
177
178                self.toolbar.props.no_show_all=True
179                self.nav_box.props.no_show_all=True
180                self.window.connect("destroy",self.quit)
181                self.window.set_resizable(False)
182                self.window.show_all()
183                self.inf_message.hide()
184                self.inf_question.hide()
185                self.set_css_info()
186                #Load stack
187                self.stack.set_transition_type(Gtk.StackTransitionType.NONE)
188                self.stack.set_visible_child_name("login")
189                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
190
191                Gtk.main()
192
193        #def start_gui
194
195        def _load_task_list_gui(self,builder):
196                self.tasks_box=builder.get_object("tasks_box")
197                self.tasks_label=builder.get_object("tasks_label")
198                self.tasks_tv=builder.get_object("tasks_treeview")
199                self.tasks_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf,GdkPixbuf.Pixbuf,str,str,str,str)
200                self.tasks_store_filter=self.tasks_store.filter_new()
201                self.tasks_store_filter.set_visible_func(self.filter_tasklist)
202                self.tasks_tv.set_model(self.tasks_store_filter)
203                self.tasks_tv.connect("button-release-event",self.task_clicked)
204                self.tasks_tv.connect("cursor-changed",self.task_clicked)
205
206                column=Gtk.TreeViewColumn(_("Task"))
207                cell=Gtk.CellRendererText()
208                column.pack_start(cell,True)
209                column.add_attribute(cell,"markup",0)
210                column.add_attribute(cell,"cell_background",7)
211                column.add_attribute(cell,"foreground",8)
212                column.set_expand(True)
213                self.tasks_tv.append_column(column)
214               
215                column=Gtk.TreeViewColumn(_("Serial"))
216                cell=Gtk.CellRendererText()
217                column.pack_start(cell,True)
218                column.add_attribute(cell,"markup",1)
219                column.add_attribute(cell,"cell_background",7)
220                column.add_attribute(cell,"foreground",8)
221                column.set_expand(True)
222                column.set_visible(False)
223                self.tasks_tv.append_column(column)
224               
225                column=Gtk.TreeViewColumn(_("When"))
226                cell=Gtk.CellRendererText()
227                cell.set_property("alignment",Pango.Alignment.CENTER)
228                column.pack_start(cell,False)
229                column.add_attribute(cell,"markup",2)
230                column.add_attribute(cell,"cell_background",7)
231                column.add_attribute(cell,"foreground",8)
232                column.set_expand(True)
233                self.tasks_tv.append_column(column)             
234
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               
244                column=Gtk.TreeViewColumn(_("Remove"))
245                cell=Gtk.CellRendererPixbuf()
246                column.pack_start(cell,True)
247                column.add_attribute(cell,"pixbuf",4)
248                column.add_attribute(cell,"cell_background",7)
249                self.col_remove=column
250                self.tasks_tv.append_column(column)
251
252                column=Gtk.TreeViewColumn(_("Command"))
253                cell=Gtk.CellRendererText()
254                column.pack_start(cell,True)
255                column.add_attribute(cell,"markup",5)
256                column.set_expand(True)
257                column.set_visible(False)
258                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)
267
268                self.tasks_tv.set_search_column(2)
269                self.tasks_tv.set_search_entry(self.txt_search)
270
271                #Add tasks
272                self.add_task_box=builder.get_object("add_task_box")
273                self.add_task_grid=detailDateBox(self.scheduler)
274                at_grid=self.add_task_grid.render_form(builder.get_object("add_task_grid"))
275                at_grid=builder.get_object("add_task_grid")
276                self.cmb_task_names=builder.get_object("cmb_task_names")
277                self.cmb_task_cmds=builder.get_object("cmb_task_cmds")
278                builder.get_object("btn_back_add").connect("clicked", self.cancel_add_clicked)
279                builder.get_object("btn_cancel_add").connect("clicked", self.cancel_add_clicked)
280                self.btn_confirm_add=builder.get_object("btn_confirm_add")
281                self.btn_confirm_add.connect("clicked", self.save_task_details)
282        #def _load_task_list_gui
283
284        def _load_manage_tasks(self,builder):
285                self.manage_box=builder.get_object("manage_box")
286                custom_grid=builder.get_object("custom_grid")
287                custom_grid.set_margin_left(12)
288                custom_grid.set_margin_top(12)
289                txt_taskname=Gtk.Entry()
290                txt_taskname.set_tooltip_text(_("A descriptive name for the command"))
291                txt_taskname.set_placeholder_text(_("Task name"))
292                lbl_name=Gtk.Label(_("Task name"))
293                lbl_name.set_halign(Gtk.Align.END)
294                custom_grid.attach(lbl_name,0,0,1,1)
295                custom_grid.attach(txt_taskname,1,0,1,1)
296                cmb_cmds=Gtk.ComboBoxText()
297                cmds=self.scheduler.get_commands()
298                i18n_cmd={}
299                for cmd in cmds.keys():
300                        i18n_cmd[_(cmd)]=cmd
301                        cmb_cmds.append_text(_(cmd))
302
303                lbl_cmd=Gtk.Label(_("Command"))
304                lbl_cmd.set_halign(Gtk.Align.END)
305                custom_grid.attach(lbl_cmd,0,1,1,1)
306                custom_grid.attach(cmb_cmds,1,1,1,1)
307                chk_parm_is_file=Gtk.CheckButton(_("Needs a file"))
308                chk_parm_is_file.set_tooltip_text(_("Mark if the command will launch a file"))
309                btn_file=Gtk.FileChooserButton()
310                chk_parm_is_file.set_tooltip_text(_("Select the file that will be launched"))
311                chk_parm_is_file.connect('toggled',self._enable_filechooser,btn_file)
312                txt_params=Gtk.Entry()
313                txt_params.set_placeholder_text(_("Needed arguments"))
314                txt_params.set_tooltip_text(_("Put here the arguments for the command (if any)"))
315                lbl_arg=Gtk.Label(_("Arguments"))
316                lbl_arg.set_halign(Gtk.Align.END)
317                custom_grid.attach(lbl_arg,2,1,1,1)
318                custom_grid.attach(txt_params,3,1,1,1)
319                custom_grid.attach(chk_parm_is_file,2,0,1,1)
320                custom_grid.attach(btn_file,3,0,1,1)
321                btn_file.set_sensitive(False)
322                self.btn_apply_manage=builder.get_object("btn_apply_manage")
323                self.btn_apply_manage.connect("clicked",self._add_custom_task,txt_taskname,cmb_cmds,txt_params,chk_parm_is_file,btn_file,i18n_cmd)
324                self.btn_back_manage=builder.get_object("btn_back_manage")
325                self.btn_back_manage.connect("clicked",self._cancel_manage_clicked)
326                self.btn_cancel_manage=builder.get_object("btn_cancel_manage")
327                self.btn_cancel_manage.connect("clicked",self._cancel_manage_clicked)
328        #def _load_manage_tasks
329       
330        def _enable_filechooser(self,widget,filechooser):
331                if widget.get_active():
332                        filechooser.set_sensitive(True)
333                else:
334                        filechooser.set_sensitive(False)
335        #def _enable_filechooser
336
337        def _add_custom_task(self,widget,w_name,w_cmd,w_parms,w_chk,w_file,i18n_cmd):
338                name=w_name.get_text()
339                cmd=w_cmd.get_active_text()
340                cmd_desc=i18n_cmd[cmd]
341                parms=w_parms.get_text()
342                cmd=self.scheduler.get_command_cmd(cmd_desc)
343                if w_chk.get_active():
344                        parms=parms+' '+w_file.get_uri().replace('file://','')
345                if self.scheduler.write_custom_task(name,cmd,parms):
346                        self._show_info(_("Task saved"))
347                else:
348                        self._show_info(_("Permission denied"))
349        #def _add_custom_task
350
351        def _signin(self,user=None,pwd=None,server=None,data=None):
352                self.scheduler.set_credentials(user,pwd,server)
353                self.stack.set_visible_child_name("tasks")
354                self.populate_tasks_tv()
355                self.toolbar.show()
356                self.nav_box.show()
357        #def _signin
358
359        def populate_tasks_tv(self,sw_remote=False):
360                self._debug("Populating task list")
361                self.scheduled_tasks={}
362                tasks=[]
363                sw_tasks=False
364                tasks=self.scheduler.get_scheduled_tasks(sw_remote)
365                self.tasks_store.clear()
366                if type(tasks)==type({}):       
367                        parser=cronParser()
368                        self.i18n['cmd']={}
369                        self.i18n['name']={}
370                        for task_name in tasks.keys():
371                                for serial in tasks[task_name].keys():
372                                        task=tasks[task_name][serial]
373                                        task['sw_remote']=''
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]
387                                        else:
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
395                                        self.scheduled_tasks[task_name]=tasks[task_name]
396                                        sw_tasks=True
397                                        parsed_calendar=''
398                                        parsed_calendar=parser.parse_taskData(task)
399                                        task['cmd']=task['cmd'].replace(self.ldm_helper+' ','')
400                                        task['action']=self.scheduler.get_task_description(task['cmd'])
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"+\
412                                                                "<span font='Roboto' size='small'><i>"+\
413                                                                _(task_name)+"</i></span>",serial,"<span font='Roboto' size='small'>"+\
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))
415        #def populate_tasks_tv
416       
417        def filter_tasklist(self,model,iterr,data):
418                sw_match=True
419                match=self.txt_search.get_text().lower()
420                task_data=model.get_value(iterr,0).split('\n')
421                task_sched_data=model.get_value(iterr,2).split('\n')
422                task_cmd=task_data[0][task_data[0].find("<b>")+3:task_data[0].find("</b>")]
423                task_name=task_data[1][task_data[1].find("<i>")+3:task_data[1].find("</i>")]
424                task_sched=task_sched_data[0][task_sched_data[0].find("ll'>")+4:task_sched_data[0].find("</span>")]
425
426                task_text=task_cmd+' '+task_name+' '+task_sched
427                if match and match not in task_text.lower():
428                        sw_match=False
429                return sw_match
430        #def filter_tasklist
431
432        def match_tasks(self,widget):
433                self.tasks_store_filter.refilter()
434                GObject.timeout_add(100,self.tasks_tv.set_cursor,0)
435        #def match_tasks
436
437        def _process_model(self,model,data):
438                task={}
439                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
444                task['serial']=model[data][1].split('\n')[0]
445                cmd=task['data'][0][task['data'][0].find("<b>")+3:task['data'][0].find("</b>")]
446                if cmd in self.i18n['cmd'].keys():
447                        task['cmd']=self.i18n['cmd'][cmd]
448                else:
449                        task['cmd']=cmd
450
451                name=task['data'][1][task['data'][1].find("<i>")+3:task['data'][1].find("</i>")]
452                if name in self.i18n['name'].keys():
453                        task['name']=self.i18n['name'][name]
454                else:
455                        task['name']=name
456
457                task['serial']=model[data][1]
458                return(task)
459
460        def _click_on_list(self,event):
461                action=''
462                try:
463                        row=self.tasks_tv.get_path_at_pos(int(event.x),int(event.y))
464                except Exception as e:
465                        self._debug(e)
466                if row:
467                        if row[1]==self.col_remove:
468                                action='remove'
469                        elif row[1]==self.col_edit:
470                                action='edit'
471                self._debug(action)
472                return action
473
474        def task_clicked(self,treeview,event=None):
475                self._debug("task clicked %s"%event)
476                selection=self.tasks_tv.get_selection()
477                model,data=selection.get_selected()
478                if not data:
479                        return
480                task={}
481                action=''
482                if event!=None:
483                        action=self._click_on_list(event)
484                task=self._process_model(model,data)
485                if action=='remove':
486                        self.lbl_question.set_text(_("Are you sure to delete this task?"))
487                        for widget in self.main_box.get_children():
488                                widget.set_sensitive(False)
489                        self.inf_question.set_sensitive(True)
490                        self.inf_question.show_all()
491                        try:
492                                self.inf_question.disconnect_by_func(self.manage_remove_responses)
493                        except:
494                                pass
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")
514        #def task_clicked                       
515
516        def save_task_details(self,widget):
517                task={}
518                name=self.cmb_task_names.get_active_text()
519                task['name']=self.i18n['name'][name]
520                action=self.cmb_task_cmds.get_active_text()
521                i18n_action=self.i18n['cmd'][action]
522                tasks=self.scheduler.get_available_tasks()
523                task['cmd']=tasks[task['name']][i18n_action]
524                task=self.add_task_grid.get_task_details()
525
526                self._debug("Writing task info...%s"%task)
527                status=self.scheduler.write_tasks(task,'local')
528                if status:
529                        self._show_info(_("Task saved"))
530                else:
531                        self._show_info(_("Permission denied"))
532                return()
533        #def save_task_details
534
535        def view_tasks_clicked(self,widget,sw_remote):
536                if widget:
537                        if not widget.get_active():
538                                return True
539                self._debug("loading tasks (remote: %s)" % sw_remote)
540                if sw_remote:
541                        self.last_task_type='remote'
542                else:
543                        self.last_task_type='local'
544                self._debug("Task clicked")
545                self.populate_tasks_tv()
546                self.tasks_tv.set_model(self.tasks_store_filter)
547                self.tasks_tv.set_cursor(0)
548                if self.stack.get_visible_child_name!='tasks':
549                        self.stack.set_visible_child_name("tasks")
550        #def view_tasks_clicked
551
552        def load_add_task_details(self):
553                tasks=[]
554                names=[]
555                self.cmb_task_names.remove_all()
556                tasks=self.scheduler.get_available_tasks()
557                for name in tasks.keys():
558                        if name not in names:
559                                names.append(name)
560                                self.i18n['name'].update({_(name):name})
561                                self.cmb_task_names.append_text(_(name))
562               
563                self.cmb_task_names.connect('changed',self.load_add_task_details_cmds,tasks)
564                self.cmb_task_names.set_active(0)
565        #def load_add_task_details
566
567        def load_add_task_details_cmds(self,widget,tasks):
568                actions=[]
569                self.i18n['cmd']={}
570                self.cmb_task_cmds.remove_all()
571                task_name=self.cmb_task_names.get_active_text()
572                if task_name:
573                        orig_name=self.i18n['name'][task_name]
574                        for action in tasks[orig_name].keys():
575                                if action not in actions:
576                                        self.i18n['cmd'].update({_(action):action})
577                                        actions.append(action)
578                                        self.cmb_task_cmds.append_text(_(action))
579                self.cmb_task_cmds.set_active(0)
580        #def load_add_task_details_cmds
581       
582        def update_task(self,widget,data=None):
583                self._debug("Updating task")
584                if self.task_details_grid.update_task_details():
585                        self._show_info(_('Task updated'))
586                        self._reload_grid()
587                else:
588                        self._show_info(_('Permission denied'))
589               
590        #def update_task
591
592        def add_task_clicked(self,widget,event):
593                self._debug("Loading new task form")
594                self.add_task_grid.clear_screen()
595                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
596                self.stack.set_visible_child_name("add")
597                self.load_add_task_details()
598        #def add_task_clicked   
599
600        def cancel_add_clicked(self,widget,event=None):
601                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
602                self.stack.set_visible_child_name("tasks")     
603                self._debug("Cancel add clicked")
604                self._reload_grid()
605        #def cancel_add_clicked
606
607        def _reload_grid(self,widget=None,data=None):
608                cursor=self.tasks_tv.get_cursor()[0]
609                self._debug("CURSOR %s"%widget)
610                self._debug("Reload grid")
611                self.populate_tasks_tv()
612                if cursor:
613                        self._debug("Restoring cursor")
614                        self.tasks_tv.set_cursor(cursor)
615
616                if type(widget)==type(Gtk.CheckButton()):
617                        self.task_details_grid.chk_node.connect("toggled",self._reload_grid)
618        #def _reload_grid
619
620        def manage_remove_responses(self,widget,response,model,task):
621                self.inf_question.hide()
622                if response==Gtk.ResponseType.OK:
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()
630                                self.tasks_tv.set_cursor(0)
631                        else:
632                                self._show_info(_("Permission denied"))
633                for widget in self.main_box.get_children():
634                        widget.set_sensitive(True)
635        #def manage_remove_responses
636
637        def _show_info(self,msg):
638                self.lbl_message.set_text(_(msg))
639                self.inf_message.show_all()
640                GObject.timeout_add(5000,self.inf_message.hide)
641        #def _show_info
642       
643        def _manage_tasks(self,widget,event):
644                self._debug("Loading manage tasks form")
645                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
646                self.stack.set_visible_child_name("manage")
647        #def _manage_tasks     
648
649        def _cancel_manage_clicked(self,widget):
650                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
651                self.stack.set_visible_child_name("tasks")     
652       
653        def set_css_info(self):
654       
655                css = b"""
656                #WHITE_BACKGROUND {
657                        background-image:-gtk-gradient (linear, left top, left bottom, from (#ffffff),  to (#ffffff));;
658               
659                }
660
661                #BLUE_FONT {
662                        color: #3366cc;
663                        font: Roboto Bold 11;
664                       
665                }       
666               
667
668                #TASKGRID_FONT {
669                        color: #3366cc;
670                        font: Roboto 11;
671                       
672                }
673
674                #LABEL_OPTION{
675               
676                        color: #808080;
677                        font: Roboto 11;
678                }
679
680                #ERROR_FONT {
681                        color: #CC0000;
682                        font: Roboto Bold 11;
683                }
684                """
685                self.style_provider=Gtk.CssProvider()
686                self.style_provider.load_from_data(css)
687                Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),self.style_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
688               
689                self.window.set_name("WHITE_BACKGROUND")
690                self.tasks_box.set_name("WHITE_BACKGROUND")
691        #def set_css_info       
692
693        def quit(self,widget,event=None):
694                Gtk.main_quit() 
695        #def quit       
696
697#class TaskScheduler
698
699GObject.threads_init()
700t=TaskScheduler()
701t.start_gui()           
Note: See TracBrowser for help on using the repository browser.