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

Last change on this file since 6718 was 6718, checked in by Juanma, 3 years ago

WIP on basic mode

  • Property svn:executable set to *
File size: 22.5 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 DetailBox import DetailBox as TaskDetails
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"
34LOCK_PATH="/var/run/taskScheduler.lock"
35WIDGET_MARGIN=6
36DBG=1
37
38class TaskScheduler:
39        def __init__(self):
40                self.is_scheduler_running()
41                try:
42                        self.flavour=subprocess.getoutput("lliurex-version -f")
43                except:
44                        self.flavour="client"
45                self.last_task_type='remote'
46                self.ldm_helper='/usr/sbin/sched-ldm.sh'
47                self.orig_tasks={}
48                self.orig_cmd={}
49                       
50        #def __init__           
51
52        def _debug(self,msg):
53                if DBG:
54                        print("taskScheduler: %s"%msg)
55        #def _debug
56
57        def is_scheduler_running(self):
58                if os.path.exists(LOCK_PATH):
59                        dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.ERROR, Gtk.ButtonsType.CANCEL, "Task Scheduler")
60                        dialog.format_secondary_text(_("There's another instance of Task Scheduler running."))
61                        dialog.run()
62                        sys.exit(1)
63        #def is_scheduler_running
64
65        def start_gui(self):
66                self.scheduler_client=scheduler()
67                builder=Gtk.Builder()
68                builder.set_translation_domain('taskscheduler')
69
70                self.stack = Gtk.Stack()
71                self.stack.set_transition_duration(1000)
72                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
73
74                glade_path=GLADE_FILE
75                builder.add_from_file(glade_path)
76
77                self.window=builder.get_object("main_window")
78                self.main_box=builder.get_object("main_box")
79                self.login=N4dGtkLogin()
80                self.login.set_allowed_groups(['adm','teachers'])
81                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>")
82                self.login.set_info_text("<span foreground='black'>Task Scheduler</span>",_("Task Scheduler"),"<span foreground='black'>"+desc+"</span>\n")
83                self.login.set_info_background(image='taskscheduler',cover=True)
84                self.login.after_validation_goto(self._signin)
85                self.login.hide_server_entry()
86                self.inf_message=Gtk.InfoBar()
87                self.inf_message.set_show_close_button(True)
88                self.lbl_message=Gtk.Label("")
89                self.inf_message.get_action_area().add(self.lbl_message)
90                self.inf_message.set_halign(Gtk.Align.CENTER)
91                self.inf_message.set_valign(Gtk.Align.CENTER)
92                def hide(widget,response):
93                        self.inf_message.hide()
94                self.inf_message.connect('response',hide)
95#               self.inf_message.props.no_show_all=True
96
97                self.inf_question=Gtk.InfoBar() 
98                self.lbl_question=Gtk.Label("")
99                self.inf_question.get_action_area().add(self.lbl_question)
100                self.inf_question.add_button(Gtk.STOCK_CANCEL,Gtk.ResponseType.CANCEL)
101                self.inf_question.add_button(Gtk.STOCK_OK,Gtk.ResponseType.OK)
102                self.inf_question.set_halign(Gtk.Align.CENTER)
103                self.inf_question.set_valign(Gtk.Align.CENTER)
104#               self.inf_question.props.no_show_all=True
105                self.main_box.pack_start(self.inf_question,False,False,0)
106                self.main_box.pack_start(self.inf_message,False,False,0)
107                self.view_tasks_button_box=builder.get_object("view_tasks_button_box")
108                self.view_tasks_eb=builder.get_object("view_tasks_eventbox")
109                self.btn_signal_id=None
110                #Toolbar
111                self.toolbar=builder.get_object("toolbar")
112                self.toolbar.set_visible(False)
113                self.btn_add_task=builder.get_object("btn_add_task")
114                self.btn_add_task.connect("button-release-event", self.add_task_clicked)
115                self.btn_refresh_tasks=builder.get_object("btn_refresh_tasks")
116                self.btn_refresh_tasks.connect("button-release-event", self._reload_grid)
117                self.btn_manage_tasks=builder.get_object("btn_manage_tasks")
118                self.btn_manage_tasks.connect("button-release-event", self._manage_tasks)
119                self.btn_remote_tasks=builder.get_object("btn_remote_tasks")
120                self.btn_local_tasks=builder.get_object("btn_local_tasks")
121                self.handler_remote=self.btn_remote_tasks.connect("clicked",self.view_tasks_clicked,'remote')
122                self.handler_local=self.btn_local_tasks.connect("clicked",self.view_tasks_clicked,'local')
123                self.txt_search=builder.get_object("txt_search")
124                self.txt_search.connect('changed',self.match_tasks)
125                #tasks list
126                self._load_task_list_gui(builder)
127                #Manage tasks
128                self._load_manage_tasks(builder)
129                #Icons
130                image=Gtk.Image()
131                image.set_from_file(REMOVE_ICON)               
132                self.remove_icon=image.get_pixbuf()
133
134                self.stack.add_titled(self.tasks_box, "tasks", "Tasks")
135                self.stack.add_titled(self.manage_box, "manage", "Manage")
136                self.stack.add_titled(self.add_task_box, "add", "Add Task")
137#               self.stack.add_titled(self.loginBox, "login", "Login")
138                self.stack.add_titled(self.login, "login", "Login")
139                #Packing
140                self.main_box.pack_start(self.stack,True,False,5)
141                self.toolbar.props.no_show_all=True
142                self.window.connect("destroy",self.quit)
143                self.window.set_resizable(False)
144                self.window.show_all()
145                self.inf_message.hide()
146                self.inf_question.hide()
147                self.set_css_info()
148                #Load stack
149                self.stack.set_transition_type(Gtk.StackTransitionType.NONE)
150                self.stack.set_visible_child_name("login")
151                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
152
153                Gtk.main()
154
155        #def start_gui
156
157        def _load_task_list_gui(self,builder):
158                self.tasks_box=builder.get_object("tasks_box")
159                self.tasks_label=builder.get_object("tasks_label")
160                self.tasks_tv=builder.get_object("tasks_treeview")
161                self.task_details_grid=TaskDetails(self.scheduler_client)
162#               self.task_details_grid=DetailBox.DetailBox(self.scheduler_client)
163                td_grid=self.task_details_grid.render_form(builder.get_object("task_details_grid"))
164                self.task_details_grid.btn_apply.set_sensitive(True)
165                self.task_details_grid.btn_apply.connect("clicked",self.update_task)
166                self.tasks_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf,str)
167                self.tasks_store_filter=self.tasks_store.filter_new()
168                self.tasks_store_filter.set_visible_func(self.filter_tasklist)
169                self.tasks_tv.set_model(self.tasks_store_filter)
170                self.tasks_tv.connect("button-release-event",self.task_clicked)
171                self.tasks_tv.connect("cursor-changed",self.task_clicked)
172
173                column=Gtk.TreeViewColumn(_("Task"))
174                cell=Gtk.CellRendererText()
175                column.pack_start(cell,True)
176                column.add_attribute(cell,"markup",0)
177                column.set_expand(True)
178                self.tasks_tv.append_column(column)
179               
180                column=Gtk.TreeViewColumn(_("Serial"))
181                cell=Gtk.CellRendererText()
182                column.pack_start(cell,True)
183                column.add_attribute(cell,"markup",1)
184                column.set_expand(True)
185                column.set_visible(False)
186                self.tasks_tv.append_column(column)
187               
188                column=Gtk.TreeViewColumn(_("When"))
189                cell=Gtk.CellRendererText()
190                cell.set_property("alignment",Pango.Alignment.CENTER)
191                column.pack_start(cell,False)
192                column.add_attribute(cell,"markup",2)
193                column.set_expand(True)
194                self.tasks_tv.append_column(column)             
195
196                column=Gtk.TreeViewColumn(_("Remove"))
197                cell=Gtk.CellRendererPixbuf()
198                cell.set_property('cell_background','red')
199                column.pack_start(cell,True)
200                column.add_attribute(cell,"pixbuf",3)
201                self.col_remove=column
202                self.tasks_tv.append_column(column)
203               
204                column=Gtk.TreeViewColumn(_("Command"))
205                cell=Gtk.CellRendererText()
206                column.pack_start(cell,True)
207                column.add_attribute(cell,"markup",4)
208                column.set_expand(True)
209                column.set_visible(False)
210                self.tasks_tv.append_column(column)
211
212                self.tasks_tv.set_search_column(2)
213                self.tasks_tv.set_search_entry(self.txt_search)
214
215                #Add tasks
216                self.add_task_box=builder.get_object("add_task_box")
217                self.add_task_grid=TaskDetails(self.scheduler_client)
218#               self.add_task_grid=DetailBox(self.scheduler_client)
219                at_grid=self.add_task_grid.render_form(builder.get_object("add_task_grid"),False)
220                self.cmb_task_names=builder.get_object("cmb_task_names")
221                self.cmb_task_cmds=builder.get_object("cmb_task_cmds")
222                builder.get_object("btn_back_add").connect("clicked", self.cancel_add_clicked)
223                builder.get_object("btn_cancel_add").connect("clicked", self.cancel_add_clicked)
224                builder.get_object("btn_confirm_add").connect("clicked", self.save_task_details)
225                self.chk_remote=builder.get_object("swt_remote")
226                self.chk_local=builder.get_object("swt_local")
227        #def _load_task_list_gui
228
229        def _load_manage_tasks(self,builder):
230                self.manage_box=builder.get_object("manage_box")
231                custom_grid=builder.get_object("custom_grid")
232                custom_grid.set_margin_left(12)
233                custom_grid.set_margin_top(12)
234                txt_taskname=Gtk.Entry()
235                txt_taskname.set_tooltip_text(_("A descriptive name for the command"))
236                txt_taskname.set_placeholder_text(_("Task name"))
237                lbl_name=Gtk.Label(_("Task name"))
238                lbl_name.set_halign(Gtk.Align.END)
239                custom_grid.attach(lbl_name,0,0,1,1)
240                custom_grid.attach(txt_taskname,1,0,1,1)
241                cmb_cmds=Gtk.ComboBoxText()
242                cmds=self.scheduler_client.get_commands()
243                orig_cmd={}
244                for cmd in cmds.keys():
245                        orig_cmd[_(cmd)]=cmd
246                        cmb_cmds.append_text(_(cmd))
247
248                lbl_cmd=Gtk.Label(_("Command"))
249                lbl_cmd.set_halign(Gtk.Align.END)
250                custom_grid.attach(lbl_cmd,0,1,1,1)
251                custom_grid.attach(cmb_cmds,1,1,1,1)
252                chk_parm_is_file=Gtk.CheckButton(_("Needs a file"))
253                chk_parm_is_file.set_tooltip_text(_("Mark if the command will launch a file"))
254                btn_file=Gtk.FileChooserButton()
255                chk_parm_is_file.set_tooltip_text(_("Select the file that will be launched"))
256                chk_parm_is_file.connect('toggled',self._enable_filechooser,btn_file)
257                txt_params=Gtk.Entry()
258                txt_params.set_placeholder_text(_("Needed arguments"))
259                txt_params.set_tooltip_text(_("Put here the arguments for the command (if any)"))
260                lbl_arg=Gtk.Label(_("Arguments"))
261                lbl_arg.set_halign(Gtk.Align.END)
262                custom_grid.attach(lbl_arg,2,1,1,1)
263                custom_grid.attach(txt_params,3,1,1,1)
264                custom_grid.attach(chk_parm_is_file,2,0,1,1)
265                custom_grid.attach(btn_file,3,0,1,1)
266                btn_file.set_sensitive(False)
267                self.btn_apply_manage=builder.get_object("btn_apply_manage")
268                self.btn_apply_manage.connect("clicked",self._add_custom_task,txt_taskname,cmb_cmds,txt_params,chk_parm_is_file,btn_file,orig_cmd)
269                self.btn_back_manage=builder.get_object("btn_back_manage")
270                self.btn_back_manage.connect("clicked",self._cancel_manage_clicked)
271                self.btn_cancel_manage=builder.get_object("btn_cancel_manage")
272                self.btn_cancel_manage.connect("clicked",self._cancel_manage_clicked)
273        #def _load_manage_tasks
274       
275        def _enable_filechooser(self,widget,filechooser):
276                if widget.get_active():
277                        filechooser.set_sensitive(True)
278                else:
279                        filechooser.set_sensitive(False)
280        #def _enable_filechooser
281
282        def _add_custom_task(self,widget,w_name,w_cmd,w_parms,w_chk,w_file,orig_cmd):
283                name=w_name.get_text()
284                cmd=w_cmd.get_active_text()
285                cmd_desc=orig_cmd[cmd]
286                parms=w_parms.get_text()
287                cmd=self.scheduler_client.get_command_cmd(cmd_desc)
288                if w_chk.get_active():
289                        parms=parms+' '+w_file.get_uri().replace('file://','')
290                if self.scheduler_client.write_custom_task(name,cmd,parms):
291                        self._show_info(_("Task saved"))
292                else:
293                        self._show_info(_("Permission denied"))
294        #def _add_custom_task
295
296        def _signin(self,user=None,pwd=None,server=None,data=None):
297                self.scheduler_client.set_credentials(user,pwd,server)
298                if server=='localhost':
299                        self.btn_local_tasks.set_active(True)
300                        self.btn_remote_tasks.set_visible(False)
301                        self.btn_local_tasks.set_visible(False)
302                else:
303                        self.btn_remote_tasks.set_active(True)
304                self.toolbar.show()
305        #def _signin
306
307        def populate_tasks_tv(self,task_type):
308                self._debug("Populating task list")
309                self.task_details_grid.btn_apply.set_sensitive(False)
310                self.scheduled_tasks={}
311                tasks=[]
312                sw_tasks=False
313                tasks=self.scheduler_client.get_scheduled_tasks(task_type)
314                self.tasks_store.clear()
315                if type(tasks)==type([]):       
316                        for task in tasks:
317                                for task_name,task_serial in task.items():
318                                        self.scheduled_tasks[task_name]=task_serial
319                                        for serial,task in task_serial.items():
320                                                sw_tasks=True
321                                                parser=cronParser()
322                                                parsed_calendar=''
323                                                parsed_calendar=parser.parse_taskData(task)
324                                                task['cmd']=task['cmd'].replace(self.ldm_helper+' ','')
325                                                task['action']=self.scheduler_client.get_task_description(task['cmd'])
326                                                self.orig_cmd[_(task['action'])]=task['action']
327                                                self.orig_tasks[_(task_name)]=task_name
328                                                self.tasks_store.append(("<span font='Roboto'><b>"+_(task['action'])+"</b></span>\n"+\
329                                                                        "<span font='Roboto' size='small'><i>"+\
330                                                                        _(task_name)+"</i></span>",serial,"<span font='Roboto' size='small'>"+\
331                                                                        parsed_calendar+"</span>",self.remove_icon,'oooo'))
332                if sw_tasks:
333                        self.task_details_grid.btn_apply.set_sensitive(True)
334        #def populate_tasks_tv
335       
336        def filter_tasklist(self,model,iterr,data):
337                sw_match=True
338                match=self.txt_search.get_text().lower()
339                task_data=model.get_value(iterr,0).split('\n')
340                task_sched_data=model.get_value(iterr,2).split('\n')
341                task_cmd=task_data[0][task_data[0].find("<b>")+3:task_data[0].find("</b>")]
342                task_name=task_data[1][task_data[1].find("<i>")+3:task_data[1].find("</i>")]
343                task_sched=task_sched_data[0][task_sched_data[0].find("ll'>")+4:task_sched_data[0].find("</span>")]
344
345                task_text=task_cmd+' '+task_name+' '+task_sched
346                if match and match not in task_text.lower():
347                        sw_match=False
348                return sw_match
349        #def filter_tasklist
350
351        def match_tasks(self,widget):
352                self.tasks_store_filter.refilter()
353                GObject.timeout_add(100,self.tasks_tv.set_cursor,0)
354        #def match_tasks
355
356        def task_clicked(self,treeview,event=None):
357                self._debug("task clicked %s"%event)
358                self.task_details_grid.clear_screen()
359                sw_show=True
360                if event!=None:
361                        try:
362                                row=self.tasks_tv.get_path_at_pos(int(event.x),int(event.y))
363                                print(row)
364                        except:
365                                return
366                        if not row:
367                                return
368                        col=row[1]
369                        if col==self.col_remove:
370                                sw_show=False
371                selection=self.tasks_tv.get_selection()
372                model,data=selection.get_selected()
373                if not data:
374                        return
375                task_data=model[data][0].split('\n')
376                task_serial=model[data][1].split('\n')[0]
377                cmd=task_data[0][task_data[0].find("<b>")+3:task_data[0].find("</b>")]
378                if cmd in self.orig_cmd.keys():
379                        task_cmd=self.orig_cmd[cmd]
380
381                name=task_data[1][task_data[1].find("<i>")+3:task_data[1].find("</i>")]
382                if name in self.orig_tasks.keys():
383                        task_name=self.orig_tasks[name]
384
385                task_serial=model[data][1]
386                if self.btn_remote_tasks.get_active():
387                        task_type='remote'
388                else:
389                        task_type='local'
390                if sw_show:
391                        if task_name in self.scheduled_tasks.keys():
392                                if task_serial in self.scheduled_tasks[task_name].keys():
393                                        task_data=self.scheduled_tasks[task_name][task_serial]
394                                        self._debug("Loading details of %s task %s of group %s"% (task_type,task_serial,task_name))
395                                        self.task_details_grid.load_task_details(task_name,task_serial,task_data,task_type)
396                else:
397                        self.lbl_question.set_text(_("Are you sure to delete this task?"))
398                        for widget in self.main_box.get_children():
399                                widget.set_sensitive(False)
400                        self.inf_question.set_sensitive(True)
401                        self.inf_question.show_all()
402                        try:
403                                self.inf_question.disconnect_by_func(self.manage_remove_responses)
404                        except:
405                                pass
406                        self.inf_question.connect('response',self.manage_remove_responses,model,task_name,task_serial,task_cmd,task_type,data)
407        #def task_clicked                       
408
409        def save_task_details(self,widget):
410                name=self.cmb_task_names.get_active_text()
411                task_name=self.orig_tasks[name]
412                action=self.cmb_task_cmds.get_active_text()
413                task_action=self.orig_cmd[action]
414                tasks=self.scheduler_client.get_available_tasks()
415                task_cmd=tasks[task_name][task_action]
416                task_type='local'
417                if self.btn_remote_tasks.get_active():
418                        task_type='remote'
419                task=self.add_task_grid.get_task_details(self.inf_message,task_name,None,task_cmd,task_type)
420
421                taskFilter='local'
422                self._debug("Writing task info...")
423                if self.chk_remote.get_active():
424                        status=self.scheduler_client.write_tasks(task,'remote')
425                if self.chk_local.get_active():
426                        status=self.scheduler_client.write_tasks(task,'local')
427                if status:
428                        self._show_info(_("Task saved"))
429                else:
430                        self._show_info(_("Permission denied"))
431                return()
432        #def save_task_details
433
434        def view_tasks_clicked(self,widget,task_type):
435                if widget:
436                        if not widget.get_active():
437                                if task_type=='remote':
438                                        self._block_widget_state(True,widget,self.handler_remote)
439                                else:                                   
440                                        self._block_widget_state(True,widget,self.handler_local)
441                                return True
442                self._debug("loading %s tasks" % task_type)
443                if task_type=='remote':
444                        self.btn_local_tasks.set_active(False)
445                        self.btn_local_tasks.props.active=False
446                        self.last_task_type='remote'
447                else:
448                        self.btn_remote_tasks.set_active(False)
449                        self.btn_remote_tasks.props.active=False
450                        self.last_task_type='local'
451                self._debug("Task clicked")
452                self.populate_tasks_tv(task_type)
453                self.tasks_tv.set_model(self.tasks_store_filter)
454                self.tasks_tv.set_cursor(0)
455                if self.stack.get_visible_child_name!='tasks':
456                        self.stack.set_visible_child_name("tasks")
457        #def view_tasks_clicked
458
459        def load_add_task_details(self):
460                if not self.btn_remote_tasks.get_visible():
461                        self.chk_remote.set_visible(False)
462                        self.chk_local.set_active(1)
463                        self.chk_remote.set_active(0)
464                        self.chk_local.set_sensitive(False)
465                else:
466                        if self.btn_remote_tasks.get_active():
467                                self.chk_remote.set_active(1)
468                                self.chk_local.set_active(0)
469                        else:
470                                self.chk_local.set_active(1)
471                                self.chk_remote.set_active(0)
472
473                self._block_widget_state(False,self.btn_remote_tasks,self.handler_remote)
474                self._block_widget_state(False,self.btn_local_tasks,self.handler_local)
475                tasks=[]
476                names=[]
477                self.orig_tasks={}
478                self.cmb_task_names.remove_all()
479                tasks=self.scheduler_client.get_available_tasks()
480                for name in tasks.keys():
481                        if name not in names:
482                                names.append(name)
483                                self.orig_tasks[_(name)]=name
484                                print("PROCESS %s"%name)
485                                self.cmb_task_names.append_text(_(name))
486               
487                self.cmb_task_names.connect('changed',self.load_add_task_details_cmds,tasks)
488                self.cmb_task_names.set_active(0)
489        #def load_add_task_details
490
491        def load_add_task_details_cmds(self,widget,tasks):
492                actions=[]
493                self.orig_cmd={}
494                self.cmb_task_cmds.remove_all()
495                task_name=self.cmb_task_names.get_active_text()
496                if task_name:
497                        orig_name=self.orig_tasks[task_name]
498                        print(tasks)
499                        for action in tasks[orig_name].keys():
500                                if action not in actions:
501                                        self.orig_cmd[_(action)]=action
502                                        actions.append(action)
503                                        self.cmb_task_cmds.append_text(_(action))
504                self.cmb_task_cmds.set_active(0)
505        #def load_add_task_details_cmds
506       
507        def update_task(self,widget,data=None):
508                self._debug("Updating task")
509                if self.task_details_grid.update_task_details():
510                        self._show_info(_('Task updated'))
511                        self._reload_grid()
512                else:
513                        self._show_info(_('Permission denied'))
514               
515        #def update_task
516
517        def add_task_clicked(self,widget,event):
518                self._debug("Loading new task form")
519                self.add_task_grid.clear_screen()
520                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
521                self.stack.set_visible_child_name("add")
522                if self.btn_remote_tasks.get_active():
523                        self.last_task_type='remote'
524                else:
525                        self.last_task_type='local'
526                self.load_add_task_details()
527        #def add_task_clicked   
528
529        def cancel_add_clicked(self,widget,event=None):
530                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
531                self.stack.set_visible_child_name("tasks")     
532                if self.last_task_type=='remote':
533                        self._block_widget_state(True,self.btn_remote_tasks,self.handler_remote)
534                else:
535                        self._block_widget_state(True,self.btn_local_tasks,self.handler_local)
536                self._debug("Cancel add clicked")
537                self._reload_grid()
538        #def cancel_add_clicked
539
540        def _reload_grid(self,widget=None,data=None):
541                cursor=self.tasks_tv.get_cursor()[0]
542                if self.btn_remote_tasks.get_active():
543                        task_type='remote'
544                else:
545                        task_type='local'
546                self._debug("Reload grid")
547                self.populate_tasks_tv(task_type)
548                if cursor:
549                        self.tasks_tv.set_cursor(cursor)
550        #def _reload_grid
551
552        def manage_remove_responses(self,widget,response,model,task_name,task_serial,task_cmd,task_type,data):
553                self._debug("Removing task %s - %s - %s"%(task_name,task_serial,task_cmd))
554                if response==Gtk.ResponseType.OK:
555                        self.inf_question.hide()
556                        if task_name in self.orig_tasks.keys():
557                                name=self.orig_tasks[task_name]
558                        else:
559                                name=task_name
560                        if task_cmd in self.orig_cmd.keys():
561                                cmd=self.orig_cmd[task_cmd]
562                        else:
563                                cmd=task_cmd
564                        if self.scheduler_client.remove_task(name,task_serial,cmd,task_type):
565                                self.populate_tasks_tv(task_type)
566                                self.tasks_tv.set_cursor(0)
567                        else:
568                                self._show_info(_("Permission denied"))
569                for widget in self.main_box.get_children():
570                        widget.set_sensitive(True)
571        #def manage_remove_responses
572
573        def _show_info(self,msg):
574                self.lbl_message.set_text(_(msg))
575                self.inf_message.show_all()
576                GObject.timeout_add(5000,self.inf_message.hide)
577        #def _show_info
578       
579        def _manage_tasks(self,widget,event):
580                self._debug("Loading manage tasks form")
581                if self.btn_remote_tasks.get_active():
582                        self.last_task_type='remote'
583                else:
584                        self.last_task_type='local'
585                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
586                self.stack.set_visible_child_name("manage")
587                self._block_widget_state(False,self.btn_remote_tasks,self.handler_remote)
588                self._block_widget_state(False,self.btn_local_tasks,self.handler_local)
589        #def _manage_tasks     
590
591        def _cancel_manage_clicked(self,widget):
592                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
593                self.stack.set_visible_child_name("tasks")     
594                if self.last_task_type=='remote':
595                        self._block_widget_state(True,self.btn_remote_tasks,self.handler_remote)
596                else:
597                        self._block_widget_state(True,self.btn_local_tasks,self.handler_local)
598
599        ###
600        #Changes the state of a widget blocking the signals
601        ###
602        def _block_widget_state(self,state,widget,handler):
603                widget.handler_block(handler)
604                widget.set_active(state)
605                GObject.timeout_add(100,widget.handler_unblock,handler)
606        #def _block_widget_state
607       
608        def set_css_info(self):
609       
610                css = b"""
611                #WHITE_BACKGROUND {
612                        background-image:-gtk-gradient (linear, left top, left bottom, from (#ffffff),  to (#ffffff));;
613               
614                }
615
616                #BLUE_FONT {
617                        color: #3366cc;
618                        font: Roboto Bold 11;
619                       
620                }       
621               
622
623                #TASKGRID_FONT {
624                        color: #3366cc;
625                        font: Roboto 11;
626                       
627                }
628
629                #LABEL_OPTION{
630               
631                        color: #808080;
632                        font: Roboto 11;
633                }
634
635                #ERROR_FONT {
636                        color: #CC0000;
637                        font: Roboto Bold 11;
638                }
639                """
640                self.style_provider=Gtk.CssProvider()
641                self.style_provider.load_from_data(css)
642                Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),self.style_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
643               
644                self.window.set_name("WHITE_BACKGROUND")
645                self.tasks_box.set_name("WHITE_BACKGROUND")
646        #def set_css_info       
647
648        def quit(self,widget,event=None):
649                Gtk.main_quit() 
650        #def quit       
651
652#class TaskScheduler
653
654GObject.threads_init()
655t=TaskScheduler()
656t.start_gui()           
Note: See TracBrowser for help on using the repository browser.