Changeset 6552


Ignore:
Timestamp:
Jan 2, 2018, 10:55:49 AM (22 months ago)
Author:
Juanma
Message:

fix utf8 bug in n4d client

Location:
taskscheduler/trunk/fuentes
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • taskscheduler/trunk/fuentes/debian/changelog

    r6394 r6552  
     1taskscheduler (0.3.4.3) xenial; urgency=medium
     2
     3  * Fix utf8 bug in n4d client
     4
     5 -- lliurex <lliurex@localhost.localdomain>  Tue, 02 Jan 2018 10:54:38 +0100
     6
    17taskscheduler (0.3.4.2) xenial; urgency=medium
    28
  • taskscheduler/trunk/fuentes/scheduler-gui.install/usr/share/taskscheduler/bin/taskScheduler.py

    r6392 r6552  
    1919from taskscheduler.taskscheduler import TaskScheduler as scheduler
    2020from taskscheduler.cronParser import cronParser
     21from DetailBox import DetailBox as TaskDetails
    2122from edupals.ui.n4dgtklogin import *
    2223import signal
     
    3435WIDGET_MARGIN=6
    3536DBG=1
    36 class TaskDetails:
    37        
    38         def __init__(self,scheduler):
    39                 self.scheduler_client=scheduler
    40                 self.parser=cronParser()
    41                 self.task_serial="0"
    42                 self.task_type="remote"
    43                 self.btn_apply=Gtk.Button(stock=Gtk.STOCK_APPLY)
    44                 try:
    45                         self.flavour=subprocess.getoutput("lliurex-version -f")
    46                 except:
    47                         self.flavour="client"
    48                 self.ldm_helper='/usr/sbin/sched-ldm.sh'
    49 
    50         def _debug(self,msg):
    51                 if DBG:
    52                         print("taskDetails: %s"%msg)
    53         #def _debug
    54 
    55         def _format_widget_for_grid(self,widget):
    56                 #common
    57                 widget.set_hexpand(False)
    58                 widget.set_halign(Gtk.Align.CENTER)
    59                 widget.set_valign(Gtk.Align.CENTER)
    60                 if 'Gtk.Button' in str(type(widget)):
    61                         pass
    62                 elif 'Gtk.Entry' in str(type(widget)):
    63                         widget.set_alignment(xalign=0.5)
    64                         widget.set_max_length(2)
    65                         widget.set_width_chars(2)
    66                         widget.set_max_width_chars(3)
    67         #def _format_widget_for_grid
    68 
    69         def _load_interval_data(self,widget=None,handler=None):
    70                 if handler:
    71                         self.cmb_interval.handler_block(handler)
    72                 position=self.cmb_interval.get_active()
    73                 self.cmb_interval.remove_all()
    74                 date=self.cmb_dates.get_active_text()
    75                 total=24
    76                 if date==_("day(s)"):
    77                         total=7
    78                 elif date==_("hour(s)"):
    79                         total=24
    80                 elif date==_("week(s)"):
    81                         total=4
    82                 elif date==_("month(s)"):
    83                         total=12
    84                 for i in range(total):
    85                         self.cmb_interval.append_text(str(i+1))
    86 
    87                 #Set sensitive status
    88                 self._changed_interval()
    89                 #If user changes selection try to activate same value on new interval data or max
    90                 if position>=total:
    91                         position=total-1
    92                 elif position<0:
    93                         position=0
    94                 self.cmb_interval.set_active(position)
    95                 if handler:
    96                         self.cmb_interval.handler_unblock(handler)
    97                         self._parse_scheduled(True)
    98         #def _load_interval_data
    99        
    100         def _load_date_data(self):
    101                 date=[_("hour(s)"),_("day(s)"),_("week(s)"),_("month(s)")]
    102                 for i in date:
    103                         self.cmb_dates.append_text(i)
    104                 self.cmb_dates.set_active(0)
    105         #def _load_date_data
    106        
    107         def _load_special_date_data(self):
    108                 date=[_("Last month day"),_("First month day")]
    109                 for i in date:
    110                         self.cmb_special_dates.append_text(i)
    111                 self.cmb_special_dates.set_active(0)
    112         #def _load_special_date_data
    113 
    114         def _load_date_time_data(self,date_type):
    115                 inc=0
    116                 jump=0
    117                 time_units=0
    118                 if date_type=='hour':
    119                         time_units=24
    120                         widget=self.cmb_hours
    121                 elif date_type=='minute':
    122                         time_units=60
    123                         jump=5
    124                         widget=self.cmb_minutes
    125                 elif date_type=='month':
    126                         widget=self.cmb_months
    127                         widget.append_text(_("Every month"))
    128                         inc=1
    129                         time_units=12
    130                 elif date_type=='day':
    131                         widget=self.cmb_days
    132                         widget.append_text(_("Every day"))
    133                         inc=1
    134                         time_units=31
    135 
    136                 for i in range(time_units):
    137                         if jump:
    138                                 if (not i%jump):
    139                                         widget.append_text(str(i+inc))
    140                         else:
    141                                 widget.append_text(str(i+inc))
    142                 widget.set_active(0)
    143         #def _load_date_time_data
    144 
    145         def render_form(self,gtkGrid,btn_apply=True):
    146                 self.chk_monday=Gtk.ToggleButton(_("Monday"))
    147                 self.chk_thursday=Gtk.ToggleButton(_("Tuesday"))
    148                 self.chk_wednesday=Gtk.ToggleButton(_("Wednesday"))
    149                 self.chk_tuesday=Gtk.ToggleButton(_("Thursday"))
    150                 self.chk_friday=Gtk.ToggleButton(_("Friday"))
    151                 self.chk_saturday=Gtk.ToggleButton(_("Saturday"))
    152                 self.chk_sunday=Gtk.ToggleButton(_("Sunday"))
    153                 self.chk_daily=Gtk.CheckButton(_("Daily"))
    154                 self.chk_hourly=Gtk.CheckButton(_("Hourly"))
    155                 self.chk_weekly=Gtk.CheckButton(_("Weekly"))
    156                 self.chk_interval=Gtk.CheckButton(_("Interval"))
    157                 self.cmb_interval=Gtk.ComboBoxText()
    158                 self.cmb_dates=Gtk.ComboBoxText()
    159                 self.chk_special_dates=Gtk.CheckButton(_("Last month day"))
    160                 self.day_box=Gtk.Box()
    161                 self.day_box.set_homogeneous(True)
    162                 self.cmb_days=Gtk.ComboBoxText()
    163                 self.day_box.add(Gtk.Label(_("Day")))
    164                 self.day_box.add(self.cmb_days)
    165                 self.month_box=Gtk.Box()
    166                 self.month_box.set_homogeneous(True)
    167                 self.cmb_months=Gtk.ComboBoxText()
    168                 self.month_box.add(Gtk.Label(_("Month")))
    169                 self.month_box.add(self.cmb_months)
    170                 self.hour_box=Gtk.Box()
    171                 self.hour_box.set_homogeneous(True)
    172                 self.cmb_hours=Gtk.ComboBoxText()
    173                 self.hour_box.add(Gtk.Label(_("Hour")))
    174                 self.hour_box.add(self.cmb_hours)
    175                 self.minute_box=Gtk.Box()
    176                 self.minute_box.set_homogeneous(True)
    177                 self.cmb_minutes=Gtk.ComboBoxText()
    178                 self.minute_box.add(Gtk.Label(_("Minutes")))
    179                 self.minute_box.add(self.cmb_minutes)
    180 
    181                 self._load_interval_data()
    182                 self._load_date_data()
    183 
    184                 self.lbl_info=Gtk.Label("")
    185                 self.lbl_info.set_opacity(0.6)
    186                 gtkGrid.attach(self.lbl_info,0,0,4,1)
    187                 self.lbl_info.set_margin_bottom(24)
    188                 dow_frame=Gtk.Frame()
    189                 dow_frame.set_shadow_type(Gtk.ShadowType.OUT)
    190                 frame_box=Gtk.Box(orientation=Gtk.Orientation.VERTICAL,spacing=6)
    191                 dow_frame.add(frame_box)
    192                 label=Gtk.Label(_("Days of week"))
    193                 frame_box.add(label)
    194                 frame_box.set_margin_bottom(6)
    195                 frame_box.set_margin_top(6)
    196                 frame_box.set_margin_left(6)
    197                 frame_box.set_margin_right(6)
    198                 dow_box=Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
    199                 work_days_box=Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
    200                 work_days_box.add(self.chk_monday)
    201                 work_days_box.add(self.chk_tuesday)
    202                 work_days_box.add(self.chk_wednesday)
    203                 work_days_box.add(self.chk_thursday)
    204                 work_days_box.add(self.chk_friday)
    205                 work_days_box.set_focus_chain([self.chk_monday,self.chk_tuesday,self.chk_wednesday,self.chk_thursday,\
    206                                                 self.chk_friday])
    207                 dow_box.add(work_days_box)
    208                 weekend_days_box=Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
    209                 dow_box.add(weekend_days_box)
    210                 weekend_days_box.add(self.chk_saturday)
    211                 weekend_days_box.add(self.chk_sunday)
    212                 weekend_days_box.set_focus_chain([self.chk_saturday,self.chk_sunday])
    213                 dow_box.set_focus_chain([work_days_box,weekend_days_box])
    214                 frame_box.add(dow_box)
    215                 gtkGrid.attach(dow_frame,0,1,1,6)
    216                 label=Gtk.Label(_("Time & date"))
    217                 label.set_margin_bottom(WIDGET_MARGIN)
    218                 gtkGrid.attach(label,1,1,1,1)
    219                 gtkGrid.attach_next_to(self.hour_box,label,Gtk.PositionType.BOTTOM,1,1)
    220                 gtkGrid.attach_next_to(self.minute_box,self.hour_box,Gtk.PositionType.BOTTOM,1,1)
    221                 gtkGrid.attach_next_to(self.month_box,self.minute_box,Gtk.PositionType.BOTTOM,1,1)
    222                 gtkGrid.attach_next_to(self.day_box,self.month_box,Gtk.PositionType.BOTTOM,1,1)
    223                 label=Gtk.Label(_("Time intervals"))
    224                 label.set_margin_bottom(WIDGET_MARGIN)
    225                 gtkGrid.attach(label,2,1,2,1)
    226                 gtkGrid.attach_next_to(self.chk_interval,label,Gtk.PositionType.BOTTOM,1,1)
    227                 self.interval_box=Gtk.Box()
    228                 self.interval_box.add(Gtk.Label(_("Each")))
    229                 self.interval_box.add(self.cmb_interval)
    230                 self.interval_box.add(self.cmb_dates)
    231                 gtkGrid.attach_next_to(self.interval_box,self.chk_interval,Gtk.PositionType.BOTTOM,1,1)
    232                 gtkGrid.attach_next_to(self.chk_special_dates,self.interval_box,Gtk.PositionType.BOTTOM,1,1)
    233                 if btn_apply:
    234                         self.btn_apply.set_halign(Gtk.Align.END)
    235                         self.btn_apply.set_valign(Gtk.Align.END)
    236                         gtkGrid.attach(self.btn_apply,4,6,2,1)
    237                 #Tab order chain
    238                 widget_array=[dow_frame,self.hour_box,self.minute_box,self.month_box,self.day_box,self.chk_interval,\
    239                                                 self.interval_box,self.chk_special_dates]
    240                 if btn_apply:
    241                         widget_array.append(self.btn_apply)
    242 
    243                 gtkGrid.set_focus_chain(widget_array)
    244                 #Add data to combos
    245                 self._load_date_time_data('minute')
    246                 self._load_date_time_data('hour')
    247                 self._load_date_time_data('day')
    248                 self._load_date_time_data('month')
    249                 #handled signals
    250                 interval_handler=self.cmb_interval.connect("changed",self._parse_scheduled)
    251                 #Signals
    252                 self.chk_monday.connect("toggled",self._enable_fixed_dates,interval_handler)
    253                 self.chk_thursday.connect("toggled",self._enable_fixed_dates,interval_handler)
    254                 self.chk_wednesday.connect("toggled",self._enable_fixed_dates,interval_handler)
    255                 self.chk_tuesday.connect("toggled",self._enable_fixed_dates,interval_handler)
    256                 self.chk_friday.connect("toggled",self._enable_fixed_dates,interval_handler)
    257                 self.chk_saturday.connect("toggled",self._enable_fixed_dates,interval_handler)
    258                 self.chk_sunday.connect("toggled",self._enable_fixed_dates,interval_handler)
    259                 self.chk_interval.connect("toggled",self._chk_interval_status)
    260                 self.chk_special_dates.connect("toggled",self._chk_special_dates_status)
    261                 self.cmb_dates.connect("changed",self._load_interval_data,interval_handler)
    262                 self.cmb_handler={}
    263                 self.cmb_handler[self.cmb_months]=self.cmb_months.connect("changed",self._parse_scheduled)
    264                 self.cmb_handler[self.cmb_days]=self.cmb_days.connect("changed",self._parse_scheduled)
    265                 self.cmb_handler[self.cmb_hours]=self.cmb_hours.connect("changed",self._parse_scheduled)
    266                 self.cmb_handler[self.cmb_minutes]=self.cmb_minutes.connect("changed",self._parse_scheduled)
    267                 gtkGrid.connect("event",self._parse_scheduled)
    268 
    269                 #Initial control status
    270                 self.interval_box.set_sensitive(False)
    271                 #signals
    272                 return (gtkGrid)
    273         #def render_form
    274 
    275         def load_task_details(self,task_name,task_serial,task_data,task_type):
    276                 self.clear_screen()
    277                 for widget,handler in self.cmb_handler.items():
    278                         widget.handler_block(handler)
    279                 self.task_name=task_name
    280                 self.task_serial=task_serial
    281                 self.task_cmd=task_data['cmd']
    282                 self.task_type=task_type
    283                 self.lbl_info.set_text('')
    284                 if task_data['m'].isdigit():
    285                         cursor=0
    286                         for minute in range(0,60,5):
    287                                 if minute>int(task_data['m']):
    288                                         break
    289                                 cursor+=1
    290                         self.cmb_minutes.set_active(cursor-1)
    291                 else:
    292                         self.cmb_minutes.set_active(0)
    293 
    294                 self._parse_date_details(task_data['h'],self.cmb_hours,'hour')
    295                 self._parse_date_details(task_data['dom'],self.cmb_days,'dom')
    296                 self._parse_date_details(task_data['mon'],self.cmb_months,'mon')
    297                 widget_dict={'0':self.chk_sunday,'1':self.chk_monday,'2':self.chk_tuesday,\
    298                                         '3':self.chk_wednesday,'4':self.chk_thursday,'5':self.chk_friday,\
    299                                         '6':self.chk_saturday,'7':self.chk_sunday}
    300                 self._parse_date_details(task_data['dow'],None,'dow',widget_dict)
    301                 if 'lmd' in task_data.keys():
    302                         self.chk_special_dates.set_active(True)
    303                 for widget,handler in self.cmb_handler.items():
    304                         widget.handler_unblock(handler)
    305         #def load_task_details
    306 
    307         def _parse_date_details(self,date,widget=None,date_type=None,widget_dict=None):
    308                 if date.isdigit() and widget:
    309                         widget.set_active(int(date))
    310                 elif '/' in date:
    311                         pos=date.split('/')
    312                         self.chk_interval.set_active(True)
    313                         self.cmb_interval.set_active(int(pos[1])-1)
    314                         if date_type=='hour':
    315                                 self.cmb_dates.set_active(0)
    316                                 self.hour_box.set_sensitive(False)
    317                         elif date_type=='dom':
    318                                 self.cmb_dates.set_active(1)
    319                                 self.day_box.set_sensitive(False)
    320                                 self.hour_box.set_sensitive(True)
    321                         elif date_type=='mon':
    322                                 self.cmb_interval.set_active(int(pos[1])-1)
    323                                 self.cmb_dates.set_active(3)
    324                                 self.month_box.set_sensitive(False)
    325                                 self.hour_box.set_sensitive(True)
    326                 elif widget_dict:
    327                         array_date=[]
    328                         if ',' in date:
    329                                 array_date=date.split(',')
    330                         else:
    331                                 array_date.append(date)
    332 
    333                         for selected_date in array_date:
    334                                 if selected_date.isdigit():
    335                                         widget_dict[selected_date].set_active(True)
    336         #def _parse_date_details
    337 
    338         def clear_screen(self):
    339                 widgets=[self.chk_monday,self.chk_thursday,self.chk_wednesday,self.chk_tuesday,\
    340                                 self.chk_friday,self.chk_saturday,self.chk_sunday]
    341                 for widget in widgets:
    342                         widget.set_active(False)
    343                 self.cmb_hours.set_active(0)
    344                 self.cmb_minutes.set_active(0)
    345                 self.cmb_days.set_active(0)
    346                 self.cmb_months.set_active(0)
    347                 self.cmb_interval.set_active(0)
    348                 self.cmb_dates.set_active(0)
    349                 self.chk_special_dates.set_active(False)
    350                 self.chk_interval.set_active(False)
    351         #def clear_screen
    352        
    353         def _set_sensitive_widget(self,widget_dic):
    354                 for widget,status in widget_dic.items():
    355                         widget.set_sensitive(status)
    356         #def _set_sensitive_widget
    357        
    358         def _changed_interval(self):
    359                 if self.chk_interval.get_active():
    360                         interval=self.cmb_dates.get_active_text()
    361                         if interval==_('hour(s)'):
    362                                 self._set_sensitive_widget({self.day_box:not self._get_days_active(),\
    363                                                 self.month_box:True,self.hour_box:False})
    364                                 self._set_days_sensitive(True)
    365                         elif interval==_('day(s)') or interval==_('week(s)'):
    366                                 self._set_sensitive_widget({self.day_box:False,self.month_box:True,self.hour_box:True})
    367                                 self._set_days_sensitive(False)
    368                         elif interval==_('month(s)'):
    369                                 self._set_sensitive_widget({self.day_box:not self._get_days_active(),\
    370                                                 self.month_box:False,self.hour_box:True})
    371                                 self._set_days_sensitive(True)
    372                 self._chk_special_dates_status()
    373         #def _changed_interval
    374 
    375 
    376         def _chk_interval_status(self,widget):
    377                 if self.chk_interval.get_active():
    378                         self._set_sensitive_widget({self.interval_box:True,\
    379                                 self.hour_box:False,self.month_box:True,self.day_box:not self._get_days_active()})
    380                         self._changed_interval()
    381                 else:
    382                         self._set_sensitive_widget({self.interval_box:False,\
    383                                 self.hour_box:True,self.month_box:True,self.day_box:not self._get_days_active()})
    384                 self._chk_special_dates_status()
    385         #def _chk_interval_status
    386                        
    387         def _chk_special_dates_status(self,widget=None):
    388                 if self.chk_special_dates.get_active():
    389                         self._set_sensitive_widget({self.hour_box:True,self.month_box:True,self.day_box:False})
    390                         self._set_days_sensitive(False)
    391                 else:
    392                         self._set_sensitive_widget({self.day_box:not self._get_days_active()})
    393                         self._set_days_sensitive(True)
    394         #def _chk_special_dates_status
    395 
    396         def _get_days_active(self):
    397                 sw_active=False
    398                 widgets=[self.chk_monday,
    399                                 self.chk_thursday,
    400                                 self.chk_wednesday,
    401                                 self.chk_tuesday,
    402                                 self.chk_friday,
    403                                 self.chk_saturday,
    404                                 self.chk_sunday]
    405                 for widget in widgets:
    406                         if widget.get_active():
    407                                 sw_active=True
    408                                 break
    409                 return sw_active
    410         #def _get_days_active
    411 
    412         def _enable_fixed_dates(self,widget,handler=None):
    413                 sw_enable=True
    414                 sw_enable=self._get_days_active()
    415                 if sw_enable:
    416                         if self.chk_interval.get_active():
    417                                 self._load_interval_data(True,handler)
    418                                 self.day_box.set_sensitive(False)
    419                         else:
    420                                 self.month_box.set_sensitive(True)
    421                                 self.day_box.set_sensitive(False)
    422                 else:
    423                         if self.chk_interval.get_active():
    424                                 self._load_interval_data(True,handler)
    425                         else:
    426                                 self.day_box.set_sensitive(True)
    427                                 self.month_box.set_sensitive(True)
    428         #def _enable_fixed_dates
    429 
    430         def _set_days_sensitive(self,state):
    431                 if self.chk_special_dates.get_active():
    432                         state=False
    433                 widgets=[self.chk_monday,
    434                                 self.chk_thursday,
    435                                 self.chk_wednesday,
    436                                 self.chk_tuesday,
    437                                 self.chk_friday,
    438                                 self.chk_saturday,
    439                                 self.chk_sunday]
    440                 for widget in widgets:
    441                         widget.set_sensitive(state)
    442         #def _set_days_sensitive
    443 
    444         def _parse_screen(self):
    445                 details={}
    446                 dow=''
    447                 widgets=[self.chk_monday,self.chk_thursday,     self.chk_wednesday,     self.chk_tuesday,\
    448                                 self.chk_friday,self.chk_saturday,self.chk_sunday]
    449                 cont=1
    450                 for widget in widgets:
    451                         if widget.get_active() and widget.get_sensitive():
    452                                 dow+=str(cont)+','
    453                         cont+=1
    454                 if dow!='':
    455                         dow=dow.rstrip(',')
    456                 else:
    457                         dow='*'
    458                 details['dow']=dow
    459                 #Init date data
    460                 for i in ["h","m","mon","dom"]:
    461                         details[i]="*"
    462                 #load data
    463                 if self.cmb_hours.is_sensitive():
    464                         details["h"]=self.cmb_hours.get_active_text()
    465                 if self.cmb_minutes.is_sensitive():
    466                         details["m"]=self.cmb_minutes.get_active_text()
    467                 if self.cmb_months.is_sensitive():
    468                         if self.cmb_months.get_active_text().isdigit():
    469                                 details["mon"]=self.cmb_months.get_active_text()
    470                 if self.cmb_days.is_sensitive():
    471                         if self.cmb_days.get_active_text().isdigit():
    472                                 details["dom"]=self.cmb_days.get_active_text()
    473 
    474                 if self.cmb_dates.is_sensitive():
    475                         if self.cmb_dates.get_active_text()==_('hour(s)'):
    476                                 details['h']="0/"+self.cmb_interval.get_active_text()
    477                         if self.cmb_dates.get_active_text()==_('day(s)'):
    478                                 details['dom']="1/"+self.cmb_interval.get_active_text()
    479                         if self.cmb_dates.get_active_text()==_('week(s)'):
    480                                 week=int(self.cmb_interval.get_active_text())*7
    481                                 details['dom']="1/"+str(week)
    482                         if self.cmb_dates.get_active_text()==_('month(s)'):
    483                                 details['mon']="1/"+self.cmb_interval.get_active_text()
    484                 details['hidden']=0
    485                 if self.chk_special_dates.get_active():
    486                         details['lmd']=1
    487                         details['dom']='*'
    488                         details['dow']='*'
    489                 return details
    490         #def _parse_screen
    491 
    492         def _parse_scheduled(self,container=None,widget=None):
    493                 details=self._parse_screen()
    494                 self.lbl_info.set_text("Task schedule: "+(self.parser.parse_taskData(details)))
    495         #def _parse_scheduled
    496 
    497         def update_task_details(self,widget=None):
    498                 if self.task_name and self.task_serial:
    499                         task_data=self.get_task_details()
    500                         return self.scheduler_client.write_tasks(task_data,self.task_type)
    501         #def update_task_details
    502 
    503         def get_task_details(self,widget=None,task_name=None,task_serial=None,task_cmd=None,task_type=None):
    504                 if task_name:
    505                         self.task_name=task_name
    506                 if task_serial:
    507                         self.task_serial=task_serial
    508                 if task_cmd:
    509                         self.task_cmd=task_cmd
    510                 if task_type:
    511                         self.task_type=task_type
    512                 details=self._parse_screen()
    513                 details['cmd']=self.scheduler_client.get_task_command(self.task_cmd)
    514                 if 'lmd' in details.keys():
    515                         details['cmd']=self.ldm_helper+' '+details['cmd']
    516                 task={}
    517                 task[self.task_name]={self.task_serial:details}
    518                 self._debug("Saving %s"%task)
    519                 return task
    520         #def get_task_details
    52137
    52238class TaskScheduler:
     
    643159                self.tasks_tv=builder.get_object("tasks_treeview")
    644160                self.task_details_grid=TaskDetails(self.scheduler_client)
     161#               self.task_details_grid=DetailBox.DetailBox(self.scheduler_client)
    645162                td_grid=self.task_details_grid.render_form(builder.get_object("task_details_grid"))
    646163                self.task_details_grid.btn_apply.set_sensitive(True)
     
    698215                self.add_task_box=builder.get_object("add_task_box")
    699216                self.add_task_grid=TaskDetails(self.scheduler_client)
     217#               self.add_task_grid=DetailBox(self.scheduler_client)
    700218                at_grid=self.add_task_grid.render_form(builder.get_object("add_task_grid"),False)
    701219                self.cmb_task_names=builder.get_object("cmb_task_names")
Note: See TracChangeset for help on using the changeset viewer.