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

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

WIP in basic mode

  • Property svn:executable set to *
File size: 22.8 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.task_details_grid.chk_node.connect("toggled",self._reload_grid)
167                self.tasks_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf,str)
168                self.tasks_store_filter=self.tasks_store.filter_new()
169                self.tasks_store_filter.set_visible_func(self.filter_tasklist)
170                self.tasks_tv.set_model(self.tasks_store_filter)
171                self.tasks_tv.connect("button-release-event",self.task_clicked)
172                self.tasks_tv.connect("cursor-changed",self.task_clicked)
173
174                column=Gtk.TreeViewColumn(_("Task"))
175                cell=Gtk.CellRendererText()
176                column.pack_start(cell,True)
177                column.add_attribute(cell,"markup",0)
178                column.set_expand(True)
179                self.tasks_tv.append_column(column)
180               
181                column=Gtk.TreeViewColumn(_("Serial"))
182                cell=Gtk.CellRendererText()
183                column.pack_start(cell,True)
184                column.add_attribute(cell,"markup",1)
185                column.set_expand(True)
186                column.set_visible(False)
187                self.tasks_tv.append_column(column)
188               
189                column=Gtk.TreeViewColumn(_("When"))
190                cell=Gtk.CellRendererText()
191                cell.set_property("alignment",Pango.Alignment.CENTER)
192                column.pack_start(cell,False)
193                column.add_attribute(cell,"markup",2)
194                column.set_expand(True)
195                self.tasks_tv.append_column(column)             
196
197                column=Gtk.TreeViewColumn(_("Remove"))
198                cell=Gtk.CellRendererPixbuf()
199                cell.set_property('cell_background','red')
200                column.pack_start(cell,True)
201                column.add_attribute(cell,"pixbuf",3)
202                self.col_remove=column
203                self.tasks_tv.append_column(column)
204               
205                column=Gtk.TreeViewColumn(_("Command"))
206                cell=Gtk.CellRendererText()
207                column.pack_start(cell,True)
208                column.add_attribute(cell,"markup",4)
209                column.set_expand(True)
210                column.set_visible(False)
211                self.tasks_tv.append_column(column)
212
213                self.tasks_tv.set_search_column(2)
214                self.tasks_tv.set_search_entry(self.txt_search)
215
216                #Add tasks
217                self.add_task_box=builder.get_object("add_task_box")
218                self.add_task_grid=TaskDetails(self.scheduler_client)
219#               self.add_task_grid=DetailBox(self.scheduler_client)
220                at_grid=self.add_task_grid.render_form(builder.get_object("add_task_grid"),False)
221                self.cmb_task_names=builder.get_object("cmb_task_names")
222                self.cmb_task_cmds=builder.get_object("cmb_task_cmds")
223                builder.get_object("btn_back_add").connect("clicked", self.cancel_add_clicked)
224                builder.get_object("btn_cancel_add").connect("clicked", self.cancel_add_clicked)
225                builder.get_object("btn_confirm_add").connect("clicked", self.save_task_details)
226                self.chk_remote=builder.get_object("swt_remote")
227                self.chk_local=builder.get_object("swt_local")
228        #def _load_task_list_gui
229
230        def _load_manage_tasks(self,builder):
231                self.manage_box=builder.get_object("manage_box")
232                custom_grid=builder.get_object("custom_grid")
233                custom_grid.set_margin_left(12)
234                custom_grid.set_margin_top(12)
235                txt_taskname=Gtk.Entry()
236                txt_taskname.set_tooltip_text(_("A descriptive name for the command"))
237                txt_taskname.set_placeholder_text(_("Task name"))
238                lbl_name=Gtk.Label(_("Task name"))
239                lbl_name.set_halign(Gtk.Align.END)
240                custom_grid.attach(lbl_name,0,0,1,1)
241                custom_grid.attach(txt_taskname,1,0,1,1)
242                cmb_cmds=Gtk.ComboBoxText()
243                cmds=self.scheduler_client.get_commands()
244                orig_cmd={}
245                for cmd in cmds.keys():
246                        orig_cmd[_(cmd)]=cmd
247                        cmb_cmds.append_text(_(cmd))
248
249                lbl_cmd=Gtk.Label(_("Command"))
250                lbl_cmd.set_halign(Gtk.Align.END)
251                custom_grid.attach(lbl_cmd,0,1,1,1)
252                custom_grid.attach(cmb_cmds,1,1,1,1)
253                chk_parm_is_file=Gtk.CheckButton(_("Needs a file"))
254                chk_parm_is_file.set_tooltip_text(_("Mark if the command will launch a file"))
255                btn_file=Gtk.FileChooserButton()
256                chk_parm_is_file.set_tooltip_text(_("Select the file that will be launched"))
257                chk_parm_is_file.connect('toggled',self._enable_filechooser,btn_file)
258                txt_params=Gtk.Entry()
259                txt_params.set_placeholder_text(_("Needed arguments"))
260                txt_params.set_tooltip_text(_("Put here the arguments for the command (if any)"))
261                lbl_arg=Gtk.Label(_("Arguments"))
262                lbl_arg.set_halign(Gtk.Align.END)
263                custom_grid.attach(lbl_arg,2,1,1,1)
264                custom_grid.attach(txt_params,3,1,1,1)
265                custom_grid.attach(chk_parm_is_file,2,0,1,1)
266                custom_grid.attach(btn_file,3,0,1,1)
267                btn_file.set_sensitive(False)
268                self.btn_apply_manage=builder.get_object("btn_apply_manage")
269                self.btn_apply_manage.connect("clicked",self._add_custom_task,txt_taskname,cmb_cmds,txt_params,chk_parm_is_file,btn_file,orig_cmd)
270                self.btn_back_manage=builder.get_object("btn_back_manage")
271                self.btn_back_manage.connect("clicked",self._cancel_manage_clicked)
272                self.btn_cancel_manage=builder.get_object("btn_cancel_manage")
273                self.btn_cancel_manage.connect("clicked",self._cancel_manage_clicked)
274        #def _load_manage_tasks
275       
276        def _enable_filechooser(self,widget,filechooser):
277                if widget.get_active():
278                        filechooser.set_sensitive(True)
279                else:
280                        filechooser.set_sensitive(False)
281        #def _enable_filechooser
282
283        def _add_custom_task(self,widget,w_name,w_cmd,w_parms,w_chk,w_file,orig_cmd):
284                name=w_name.get_text()
285                cmd=w_cmd.get_active_text()
286                cmd_desc=orig_cmd[cmd]
287                parms=w_parms.get_text()
288                cmd=self.scheduler_client.get_command_cmd(cmd_desc)
289                if w_chk.get_active():
290                        parms=parms+' '+w_file.get_uri().replace('file://','')
291                if self.scheduler_client.write_custom_task(name,cmd,parms):
292                        self._show_info(_("Task saved"))
293                else:
294                        self._show_info(_("Permission denied"))
295        #def _add_custom_task
296
297        def _signin(self,user=None,pwd=None,server=None,data=None):
298                self.scheduler_client.set_credentials(user,pwd,server)
299                if server=='localhost':
300                        self.btn_local_tasks.set_active(True)
301                        self.btn_remote_tasks.set_visible(False)
302                        self.btn_local_tasks.set_visible(False)
303                else:
304                        self.btn_remote_tasks.set_active(True)
305                self.toolbar.show()
306        #def _signin
307
308        def populate_tasks_tv(self,task_type):
309                self._debug("Populating task list")
310                self.task_details_grid.btn_apply.set_sensitive(False)
311                self.scheduled_tasks={}
312                tasks=[]
313                sw_tasks=False
314                tasks=self.scheduler_client.get_scheduled_tasks(task_type)
315                self.tasks_store.clear()
316                if type(tasks)==type([]):       
317                        for task in tasks:
318                                for task_name,task_serial in task.items():
319                                        self.scheduled_tasks[task_name]=task_serial
320                                        for serial,task in task_serial.items():
321                                                sw_tasks=True
322                                                parser=cronParser()
323                                                parsed_calendar=''
324                                                parsed_calendar=parser.parse_taskData(task)
325                                                task['cmd']=task['cmd'].replace(self.ldm_helper+' ','')
326                                                task['action']=self.scheduler_client.get_task_description(task['cmd'])
327                                                self.orig_cmd[_(task['action'])]=task['action']
328                                                self.orig_tasks[_(task_name)]=task_name
329                                                self.tasks_store.append(("<span font='Roboto'><b>"+_(task['action'])+"</b></span>\n"+\
330                                                                        "<span font='Roboto' size='small'><i>"+\
331                                                                        _(task_name)+"</i></span>",serial,"<span font='Roboto' size='small'>"+\
332                                                                        parsed_calendar+"</span>",self.remove_icon,'oooo'))
333                if sw_tasks:
334                        self.task_details_grid.btn_apply.set_sensitive(True)
335        #def populate_tasks_tv
336       
337        def filter_tasklist(self,model,iterr,data):
338                sw_match=True
339                match=self.txt_search.get_text().lower()
340                task_data=model.get_value(iterr,0).split('\n')
341                task_sched_data=model.get_value(iterr,2).split('\n')
342                task_cmd=task_data[0][task_data[0].find("<b>")+3:task_data[0].find("</b>")]
343                task_name=task_data[1][task_data[1].find("<i>")+3:task_data[1].find("</i>")]
344                task_sched=task_sched_data[0][task_sched_data[0].find("ll'>")+4:task_sched_data[0].find("</span>")]
345
346                task_text=task_cmd+' '+task_name+' '+task_sched
347                if match and match not in task_text.lower():
348                        sw_match=False
349                return sw_match
350        #def filter_tasklist
351
352        def match_tasks(self,widget):
353                self.tasks_store_filter.refilter()
354                GObject.timeout_add(100,self.tasks_tv.set_cursor,0)
355        #def match_tasks
356
357        def task_clicked(self,treeview,event=None):
358                self._debug("task clicked %s"%event)
359                self.task_details_grid.clear_screen()
360                sw_show=True
361                if event!=None:
362                        try:
363                                row=self.tasks_tv.get_path_at_pos(int(event.x),int(event.y))
364                                print(row)
365                        except:
366                                return
367                        if not row:
368                                return
369                        col=row[1]
370                        if col==self.col_remove:
371                                sw_show=False
372                selection=self.tasks_tv.get_selection()
373                model,data=selection.get_selected()
374                if not data:
375                        return
376                task_data=model[data][0].split('\n')
377                task_serial=model[data][1].split('\n')[0]
378                cmd=task_data[0][task_data[0].find("<b>")+3:task_data[0].find("</b>")]
379                if cmd in self.orig_cmd.keys():
380                        task_cmd=self.orig_cmd[cmd]
381
382                name=task_data[1][task_data[1].find("<i>")+3:task_data[1].find("</i>")]
383                if name in self.orig_tasks.keys():
384                        task_name=self.orig_tasks[name]
385
386                task_serial=model[data][1]
387                if self.btn_remote_tasks.get_active():
388                        task_type='remote'
389                else:
390                        task_type='local'
391                if sw_show:
392                        if task_name in self.scheduled_tasks.keys():
393                                if task_serial in self.scheduled_tasks[task_name].keys():
394                                        task_data=self.scheduled_tasks[task_name][task_serial]
395                                        self._debug("Loading details of %s task %s of group %s"% (task_type,task_serial,task_name))
396                                        self.task_details_grid.load_task_details(task_name,task_serial,task_data,task_type)
397                else:
398                        self.lbl_question.set_text(_("Are you sure to delete this task?"))
399                        for widget in self.main_box.get_children():
400                                widget.set_sensitive(False)
401                        self.inf_question.set_sensitive(True)
402                        self.inf_question.show_all()
403                        try:
404                                self.inf_question.disconnect_by_func(self.manage_remove_responses)
405                        except:
406                                pass
407                        self.inf_question.connect('response',self.manage_remove_responses,model,task_name,task_serial,task_cmd,task_type,data)
408        #def task_clicked                       
409
410        def save_task_details(self,widget):
411                name=self.cmb_task_names.get_active_text()
412                task_name=self.orig_tasks[name]
413                action=self.cmb_task_cmds.get_active_text()
414                task_action=self.orig_cmd[action]
415                tasks=self.scheduler_client.get_available_tasks()
416                task_cmd=tasks[task_name][task_action]
417                task_type='local'
418                if self.btn_remote_tasks.get_active():
419                        task_type='remote'
420                task=self.add_task_grid.get_task_details(self.inf_message,task_name,None,task_cmd,task_type)
421
422                taskFilter='local'
423                self._debug("Writing task info...")
424                if self.chk_remote.get_active():
425                        status=self.scheduler_client.write_tasks(task,'remote')
426                if self.chk_local.get_active():
427                        status=self.scheduler_client.write_tasks(task,'local')
428                if status:
429                        self._show_info(_("Task saved"))
430                else:
431                        self._show_info(_("Permission denied"))
432                return()
433        #def save_task_details
434
435        def view_tasks_clicked(self,widget,task_type):
436                if widget:
437                        if not widget.get_active():
438                                if task_type=='remote':
439                                        self._block_widget_state(True,widget,self.handler_remote)
440                                else:                                   
441                                        self._block_widget_state(True,widget,self.handler_local)
442                                return True
443                self._debug("loading %s tasks" % task_type)
444                if task_type=='remote':
445                        self.btn_local_tasks.set_active(False)
446                        self.btn_local_tasks.props.active=False
447                        self.last_task_type='remote'
448                else:
449                        self.btn_remote_tasks.set_active(False)
450                        self.btn_remote_tasks.props.active=False
451                        self.last_task_type='local'
452                self._debug("Task clicked")
453                self.populate_tasks_tv(task_type)
454                self.tasks_tv.set_model(self.tasks_store_filter)
455                self.tasks_tv.set_cursor(0)
456                if self.stack.get_visible_child_name!='tasks':
457                        self.stack.set_visible_child_name("tasks")
458        #def view_tasks_clicked
459
460        def load_add_task_details(self):
461                if not self.btn_remote_tasks.get_visible():
462                        self.chk_remote.set_visible(False)
463                        self.chk_local.set_active(1)
464                        self.chk_remote.set_active(0)
465                        self.chk_local.set_sensitive(False)
466                else:
467                        if self.btn_remote_tasks.get_active():
468                                self.chk_remote.set_active(1)
469                                self.chk_local.set_active(0)
470                        else:
471                                self.chk_local.set_active(1)
472                                self.chk_remote.set_active(0)
473
474                self._block_widget_state(False,self.btn_remote_tasks,self.handler_remote)
475                self._block_widget_state(False,self.btn_local_tasks,self.handler_local)
476                tasks=[]
477                names=[]
478                self.orig_tasks={}
479                self.cmb_task_names.remove_all()
480                tasks=self.scheduler_client.get_available_tasks()
481                for name in tasks.keys():
482                        if name not in names:
483                                names.append(name)
484                                self.orig_tasks[_(name)]=name
485                                print("PROCESS %s"%name)
486                                self.cmb_task_names.append_text(_(name))
487               
488                self.cmb_task_names.connect('changed',self.load_add_task_details_cmds,tasks)
489                self.cmb_task_names.set_active(0)
490        #def load_add_task_details
491
492        def load_add_task_details_cmds(self,widget,tasks):
493                actions=[]
494                self.orig_cmd={}
495                self.cmb_task_cmds.remove_all()
496                task_name=self.cmb_task_names.get_active_text()
497                if task_name:
498                        orig_name=self.orig_tasks[task_name]
499                        print(tasks)
500                        for action in tasks[orig_name].keys():
501                                if action not in actions:
502                                        self.orig_cmd[_(action)]=action
503                                        actions.append(action)
504                                        self.cmb_task_cmds.append_text(_(action))
505                self.cmb_task_cmds.set_active(0)
506        #def load_add_task_details_cmds
507       
508        def update_task(self,widget,data=None):
509                self._debug("Updating task")
510                if self.task_details_grid.update_task_details():
511                        self._show_info(_('Task updated'))
512                        self._reload_grid()
513                else:
514                        self._show_info(_('Permission denied'))
515               
516        #def update_task
517
518        def add_task_clicked(self,widget,event):
519                self._debug("Loading new task form")
520                self.add_task_grid.clear_screen()
521                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
522                self.stack.set_visible_child_name("add")
523                if self.btn_remote_tasks.get_active():
524                        self.last_task_type='remote'
525                else:
526                        self.last_task_type='local'
527                self.load_add_task_details()
528        #def add_task_clicked   
529
530        def cancel_add_clicked(self,widget,event=None):
531                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
532                self.stack.set_visible_child_name("tasks")     
533                if self.last_task_type=='remote':
534                        self._block_widget_state(True,self.btn_remote_tasks,self.handler_remote)
535                else:
536                        self._block_widget_state(True,self.btn_local_tasks,self.handler_local)
537                self._debug("Cancel add clicked")
538                self._reload_grid()
539        #def cancel_add_clicked
540
541        def _reload_grid(self,widget=None,data=None):
542                cursor=self.tasks_tv.get_cursor()[0]
543                self._debug("CURSOR %s"%widget)
544                if self.btn_remote_tasks.get_active():
545                        task_type='remote'
546                else:
547                        task_type='local'
548                self._debug("Reload grid")
549                self.populate_tasks_tv(task_type)
550                if cursor:
551                        self._debug("Restoring cursor")
552                        self.tasks_tv.set_cursor(cursor)
553
554                if type(widget)==type(Gtk.CheckButton()):
555                        self.task_details_grid.chk_node.connect("toggled",self._reload_grid)
556        #def _reload_grid
557
558        def manage_remove_responses(self,widget,response,model,task_name,task_serial,task_cmd,task_type,data):
559                self._debug("Removing task %s - %s - %s"%(task_name,task_serial,task_cmd))
560                if response==Gtk.ResponseType.OK:
561                        self.inf_question.hide()
562                        if task_name in self.orig_tasks.keys():
563                                name=self.orig_tasks[task_name]
564                        else:
565                                name=task_name
566                        if task_cmd in self.orig_cmd.keys():
567                                cmd=self.orig_cmd[task_cmd]
568                        else:
569                                cmd=task_cmd
570                        if self.scheduler_client.remove_task(name,task_serial,cmd,task_type):
571                                self.populate_tasks_tv(task_type)
572                                self.tasks_tv.set_cursor(0)
573                        else:
574                                self._show_info(_("Permission denied"))
575                for widget in self.main_box.get_children():
576                        widget.set_sensitive(True)
577        #def manage_remove_responses
578
579        def _show_info(self,msg):
580                self.lbl_message.set_text(_(msg))
581                self.inf_message.show_all()
582                GObject.timeout_add(5000,self.inf_message.hide)
583        #def _show_info
584       
585        def _manage_tasks(self,widget,event):
586                self._debug("Loading manage tasks form")
587                if self.btn_remote_tasks.get_active():
588                        self.last_task_type='remote'
589                else:
590                        self.last_task_type='local'
591                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
592                self.stack.set_visible_child_name("manage")
593                self._block_widget_state(False,self.btn_remote_tasks,self.handler_remote)
594                self._block_widget_state(False,self.btn_local_tasks,self.handler_local)
595        #def _manage_tasks     
596
597        def _cancel_manage_clicked(self,widget):
598                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
599                self.stack.set_visible_child_name("tasks")     
600                if self.last_task_type=='remote':
601                        self._block_widget_state(True,self.btn_remote_tasks,self.handler_remote)
602                else:
603                        self._block_widget_state(True,self.btn_local_tasks,self.handler_local)
604
605        ###
606        #Changes the state of a widget blocking the signals
607        ###
608        def _block_widget_state(self,state,widget,handler):
609                widget.handler_block(handler)
610                widget.set_active(state)
611                GObject.timeout_add(100,widget.handler_unblock,handler)
612        #def _block_widget_state
613       
614        def set_css_info(self):
615       
616                css = b"""
617                #WHITE_BACKGROUND {
618                        background-image:-gtk-gradient (linear, left top, left bottom, from (#ffffff),  to (#ffffff));;
619               
620                }
621
622                #BLUE_FONT {
623                        color: #3366cc;
624                        font: Roboto Bold 11;
625                       
626                }       
627               
628
629                #TASKGRID_FONT {
630                        color: #3366cc;
631                        font: Roboto 11;
632                       
633                }
634
635                #LABEL_OPTION{
636               
637                        color: #808080;
638                        font: Roboto 11;
639                }
640
641                #ERROR_FONT {
642                        color: #CC0000;
643                        font: Roboto Bold 11;
644                }
645                """
646                self.style_provider=Gtk.CssProvider()
647                self.style_provider.load_from_data(css)
648                Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),self.style_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
649               
650                self.window.set_name("WHITE_BACKGROUND")
651                self.tasks_box.set_name("WHITE_BACKGROUND")
652        #def set_css_info       
653
654        def quit(self,widget,event=None):
655                Gtk.main_quit() 
656        #def quit       
657
658#class TaskScheduler
659
660GObject.threads_init()
661t=TaskScheduler()
662t.start_gui()           
Note: See TracBrowser for help on using the repository browser.