source: lliurex-gdrive/trunk/fuentes/lliurex-gdrive-gui.install/usr/share/lliurex-gdrive/ProfileBox.py @ 5661

Last change on this file since 5661 was 5661, checked in by jrpelegrina, 3 years ago

Wip in check empty folder when profile is created or updated

File size: 21.4 KB
Line 
1#!/usr/bin/env python
2
3
4import gi
5gi.require_version('Gtk', '3.0')
6from gi.repository import Gtk, Pango, GdkPixbuf, Gdk, Gio, GObject,GLib
7
8import copy
9import gettext
10import Core
11
12import Dialog
13import time
14import threading
15import multiprocessing
16import sys
17import os
18import psutil
19
20import gettext
21gettext.textdomain('lliurex-gdrive')
22_ = gettext.gettext
23
24
25
26RSRC="/usr/share/lliurex-gdrive/"
27CSS_FILE="/usr/share/lliurex-gdrive/lliurex-gdrive.css"
28PROFILE_IMAGE=RSRC+"rsrc/profile.svg"
29FOLDER_IMAGE=RSRC+"rsrc/folder.svg"
30MOUNT_ON_IMAGE=RSRC+"rsrc/mount_on.svg"
31MOUNT_OFF_IMAGE=RSRC+"rsrc/mount_off.svg"
32EDIT_IMAGE=RSRC+"rsrc/edit.svg"
33DELETE_IMAGE=RSRC+"rsrc/trash.svg"
34MAX_RETRY_INTENTS=1200
35
36
37class ProfileBox(Gtk.VBox):
38       
39        def __init__(self):
40               
41                Gtk.VBox.__init__(self)
42               
43                self.core=Core.Core.get_core()
44               
45                builder=Gtk.Builder()
46                builder.set_translation_domain('lliurex-gdrive')
47                ui_path=RSRC + "/rsrc/lliurex-gdrive.ui"
48                builder.add_from_file(ui_path)
49
50                self.main_box=builder.get_object("profile_data_box")
51                self.profiles_list_label=builder.get_object("profiles_list_label")
52                self.profile_list_box=builder.get_object("profile_list_box")
53                self.profile_list_vp=builder.get_object("profile_list_viewport")
54                self.msg_label=builder.get_object("msg_label")
55
56                image = Gtk.Image()
57                image.set_from_stock(Gtk.STOCK_ADD,Gtk.IconSize.MENU)
58               
59                self.add_new_profile_button=builder.get_object("add_new_profile_button")
60                self.add_new_profile_button.set_image(image)
61                self.new_profile_window=builder.get_object("new_profile_window")
62                self.profile_label=builder.get_object("profile_label")
63                self.profile_entry=builder.get_object("profile_entry")
64                self.email_label=builder.get_object("email_label")
65                self.email_entry=builder.get_object("email_entry")
66                self.mountpoint_label=builder.get_object("mountpoint_label")
67                self.mountpoint_entry=builder.get_object("mountpoint_entry")
68                self.automount_label=builder.get_object("automount_label")
69                self.automount_entry=builder.get_object("automount_entry")
70                self.profile_msg=builder.get_object("profile_msg")
71                self.profile_pbar=builder.get_object("profile_pbar")
72                self.accept_add_profile_button=builder.get_object("accept_add_profile_button")
73                self.cancel_add_profile_button=builder.get_object("cancel_add_profile_button")
74               
75                               
76                self.pack_start(self.main_box,True,True,0)
77                self.connect_signals()
78                self.set_css_info()
79
80                self.current_status={}
81                self.edition=False
82                self.profile_pbar.hide()
83
84                self.init_threads()
85                self.check_initial_connection()
86
87                               
88        #def __init__
89
90        def init_threads(self):
91
92                self.create_profile_t=multiprocessing.Process(target=self.create_profile)
93                self.create_mountpoint_t=threading.Thread(target=self.create_mountpoint)
94                self.edit_profile_t=threading.Thread(target=self.edit_profile)
95                self.check_connection_t=threading.Thread(target=self.check_connection)
96               
97               
98                self.create_profile_t.daemon=True
99                self.create_mountpoint_t.daemon=True
100                self.edit_profile_t.daemon=True
101                self.check_connection_t.daemon=True
102
103                self.create_mountpoint_t.done=False
104                self.edit_profile_t.done=False
105
106                self.create_profile_t.launched=False
107                self.create_mountpoint_t.launched=False
108                self.edit_profile_t.launched=False
109               
110                GObject.threads_init()
111
112        #def init_threads       
113
114        def set_css_info(self):
115               
116                self.style_provider=Gtk.CssProvider()
117
118                f=Gio.File.new_for_path(CSS_FILE)
119                self.style_provider.load_from_file(f)
120
121                Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),self.style_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
122                self.profiles_list_label.set_name("OPTION_LABEL")
123                self.profile_label.set_name("OPTION_LABEL")
124                self.email_label.set_name("OPTION_LABEL")
125                self.mountpoint_label.set_name("OPTION_LABEL")
126                self.automount_label.set_name("OPTION_LABEL")
127                self.msg_label.set_name("MSG_LABEL")
128                self.profile_msg.set_name("MSG_LABEL")
129               
130                       
131        #def set-css_info
132       
133               
134        def connect_signals(self):
135
136                self.add_new_profile_button.connect("clicked",self.add_new_profile_button_clicked)
137                self.accept_add_profile_button.connect("clicked",self.accept_add_profile_clicked)
138                self.cancel_add_profile_button.connect("clicked",self.cancel_add_profile_clicked)
139                self.new_profile_window.connect("delete_event",self.hide_window)
140
141
142        #def connect_signals
143
144
145        def check_initial_connection(self):
146               
147                self.initial_connection=self.core.LliurexGoogleDriveManager.check_google_connection()
148                return
149       
150        def load_info(self,info):
151               
152                self.profiles_info=info
153                print self.profiles_info
154                for item in self.profiles_info:
155                        profile=item
156                        email=self.profiles_info[item]["email"]
157                        mountpoint=self.profiles_info[item]["mountpoint"]
158                        self.new_profile_button(profile,email,mountpoint)
159                       
160       
161        #def load_info()               
162
163        def hide_window(self,widget,event):
164               
165                widget.hide()
166                return True
167
168        #def hide_window       
169
170        def init_profile_dialog_button(self):
171
172                self.accept_add_profile_button.show()
173                image = Gtk.Image()
174                image.set_from_stock(Gtk.STOCK_CANCEL,Gtk.IconSize.MENU)
175                self.cancel_add_profile_button.set_image(image)
176                self.cancel_add_profile_button.set_label(_("Cancel"))
177                self.cancel_add_profile_button.show()
178
179        #def init_profile_dialog_button
180
181        def disable_entry_profile_dialog(self):
182
183                self.profile_entry.set_sensitive(False)
184                self.email_entry.set_sensitive(False)
185                self.mountpoint_entry.set_sensitive(False)
186                self.automount_entry.set_sensitive(False)
187
188        #def disable_entry_profile_dialog
189       
190        def enable_entry_profile_dialog(self):
191
192                if not self.edition:
193                       
194                        self.new_profile_window.set_title(_("Create new profile"))
195                        self.profile_entry.set_sensitive(True)
196                        self.profile_entry.grab_focus()
197                        self.email_entry.set_sensitive(True)
198
199                else:
200                        self.new_profile_window.set_title(_("Edit profile"))
201                        self.profile_entry.set_sensitive(False)
202                        self.email_entry.set_sensitive(False)
203
204                self.mountpoint_entry.set_sensitive(True)
205                self.automount_entry.set_sensitive(True)       
206
207        #def enable_entry_profile_dialog       
208
209        def change_cancel_button(self):
210               
211                image = Gtk.Image()
212                image.set_from_stock(Gtk.STOCK_CLOSE,Gtk.IconSize.MENU)
213                self.cancel_add_profile_button.set_image(image)
214                self.cancel_add_profile_button.set_label(_("Close"))   
215                self.cancel_add_profile_button.show()   
216
217        #def change_cancel_button       
218
219        def add_new_profile_button_clicked(self,widget):
220
221                self.edition=False
222                self.core.lgd.check_plabel.set_text(_("Checking connection to google..."))
223                self.core.lgd.check_window.show()
224                self.init_threads()
225                self.check_connection_t.start()
226                GLib.timeout_add(100,self.pulsate_add_connection)
227       
228        def pulsate_add_connection(self):
229               
230                if self.check_connection_t.is_alive():
231                                self.core.lgd.check_pbar.pulse()
232                                return True
233
234                else:
235                        self.core.lgd.check_window.hide()
236                        self.enable_entry_profile_dialog()
237                        #ENCODING TO UNICODE
238                        if self.connection:
239                                self.profile_entry.set_text("")
240                                self.email_entry.set_text("")
241                                self.mountpoint_entry.set_filename(os.environ["HOME"])
242                                self.automount_entry.set_active(False)
243                                self.profile_msg.set_text("")
244               
245
246                                self.init_threads()
247                               
248                                self.msg_label.set_text("")
249                                self.profile_msg.hide()
250                                self.profile_pbar.hide()
251                                self.init_profile_dialog_button()
252                                self.new_profile_window.show()
253                               
254                        else:           
255                                msg_error=self.get_msg(8)
256                                self.msg_label.set_name("MSG_ERROR_LABEL")
257                                self.msg_label.set_text(msg_error)             
258               
259                return False   
260               
261
262        #def add_new_profile_button_clicked     
263
264        def delete_profile_clicked(self,button,hbox):
265
266                dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO, "Lliurex GDrive")
267                dialog.format_secondary_text(_("Do you want delete the profile?"))
268                response=dialog.run()
269                dialog.destroy()
270               
271
272                if response==Gtk.ResponseType.YES:
273                        profile=hbox.get_children()[1].get_text().split("\n")[0]
274                        #ENCODING TO UNICODE                   
275                        profile=profile.decode("utf-8")
276                        self.delete_profile_t=threading.Thread(target=self.delete_profile,args=(profile,))
277                        self.delete_profile_t.daemon=True
278                        GObject.threads_init()
279
280                        self.msg_label.set_text("")
281                       
282                        self.profiles_info.pop(profile)
283                        self.delete_profile_t.start()
284                        self.delete_profile_t.launched=True
285                        self.core.lgd.check_plabel.set_text(_("Applying changes..."))
286                        self.core.lgd.check_window.show()
287                        GLib.timeout_add(100,self.pulsate_delete_profile,profile,hbox)
288
289        # def delete_profile_clicked
290               
291        def pulsate_delete_profile(self,profile,hbox):
292
293                        if self.delete_profile_t.is_alive():
294                                self.core.lgd.check_pbar.pulse()
295                                return True
296
297                        else:
298                                self.msg_label.show()
299                                self.core.lgd.check_window.hide()
300                                if self.delete["result"]:
301                                        self.msg_label.set_name("MSG_LABEL")
302                                        self.profile_list_box.remove(hbox)
303                                else:
304                                        self.msg_label.set_name("MSG_ERROR_LABEL")
305                               
306                                msg_text=self.get_msg(self.delete["code"])
307                                self.msg_label.set_text(msg_text)
308                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()
309                               
310                        return False   
311
312       
313        def delete_profile(self,profile):
314
315                self.delete=self.core.LliurexGoogleDriveManager.delete_profile(self.profiles_info,profile)
316
317        def sync_profile_clicked(self,button,hbox):
318
319                self.msg_label.set_text("")
320                self.sync_profile_t=threading.Thread(target=self.sync_profile,args=(hbox,))
321                self.sync_profile_t.daemon=True
322                GObject.threads_init()
323               
324                self.sync_profile_t.start()
325                self.core.lgd.check_plabel.set_text(_("Applying changes..."))
326                self.core.lgd.check_window.show()
327                GLib.timeout_add(100,self.pulsate_sync_profile,button,hbox)
328
329       
330        #def sync_profile_cicked
331
332        def pulsate_sync_profile(self,button,hbox):
333
334                if self.sync_profile_t.is_alive():
335                        self.core.lgd.check_pbar.pulse()
336                        return True
337
338                else:
339                        self.core.lgd.check_window.hide()
340                        if self.status_mod["result"]:
341                                msg_text=self.get_msg(self.status_mod["code"])
342                                self.msg_label.set_name("MSG_LABEL")
343                                self.msg_label.set_text(msg_text)
344                               
345                        else:
346                                msg_text=self.get_msg(self.status_mod["code"])
347                                self.msg_label.set_name("MSG_ERROR_LABEL")
348                                self.msg_label.set_text(msg_text)       
349                       
350
351                        info=self.item_status_info(self.status_info['status'])
352                        profile=hbox.get_children()[1].get_text().split("\n")[0]
353                        self.current_status[profile.decode("utf-8")]=self.status_info["status"]
354                        button.set_tooltip_text(info["tooltip"])
355                        button.set_name(info["css"])           
356                        hbox.get_children()[4].set_image(info["img"])   
357
358                return False                                   
359
360
361        def sync_profile(self,hbox):
362       
363                profile=hbox.get_children()[1].get_text().split("\n")[0]
364                mountpoint=hbox.get_children()[3].get_text()
365                # ENCODING TO UNICODE           
366                profile=profile.decode("utf-8")
367                mountpoint=mountpoint.decode("utf-8")
368                connect=True
369                current_status=self.current_status[profile]
370                self.status_mod,self.status_info=self.core.LliurexGoogleDriveManager.sync_profile(profile,mountpoint,current_status)
371               
372
373        def edit_profile_clicked(self,button,hbox):
374
375                self.edition=True
376                self.core.lgd.check_plabel.set_text(_("Checking connection to google..."))
377                self.core.lgd.check_window.show()
378                self.init_threads()
379                self.check_connection_t.start()
380                GLib.timeout_add(100,self.pulsate_edit_connection,hbox)
381
382               
383        #def edit_profile_clicked
384
385        def pulsate_edit_connection(self,hbox):
386
387                if self.check_connection_t.is_alive():
388                                self.core.lgd.check_pbar.pulse()
389                                return True
390
391                else:
392                        self.core.lgd.check_window.hide()
393                        self.enable_entry_profile_dialog()
394                        #ENCODING TO UNICODE
395                        if self.connection:
396                                self.profile_to_edit=hbox               
397                                profile=self.profile_to_edit.get_children()[1].get_text().split("\n")[0]
398                                self.profile_entry.set_text(profile)
399                                email=self.profile_to_edit.get_children()[1].get_text().split("\n")[1]
400                                self.email_entry.set_text(email)
401                                mountpoint=self.profile_to_edit.get_children()[3].get_text()
402                                self.mountpoint_entry.set_filename(mountpoint)
403                                automount=self.profiles_info[profile.decode("utf-8")]["automount"]
404                                self.automount_entry.set_active(automount)
405                               
406
407                                self.init_threads()
408
409                                self.profile_msg.hide()
410                                self.profile_pbar.hide()
411                                self.msg_label.set_text("")
412                                self.init_profile_dialog_button()
413                                self.new_profile_window.show()
414
415                        else:           
416                                msg_text=self.get_msg(8)
417                                self.msg_label.set_name("MSG_ERROR_LABEL")
418                                self.msg_label.set_text(msg_text)               
419                return False
420
421
422
423
424        def check_connection(self):
425                self.connection=self.core.LliurexGoogleDriveManager.check_google_connection()
426
427
428        def new_profile_button(self,profile_name,email,mountpoint):
429               
430                hbox=Gtk.HBox()
431                profile_image=Gtk.Image.new_from_file(PROFILE_IMAGE)
432                profile_image.set_margin_left(10)
433                profile_image.set_halign(Gtk.Align.CENTER)
434                profile_image.set_valign(Gtk.Align.CENTER)
435                profile_info="<span font='Roboto'><b>"+profile_name+"</b></span>\n"+"<span font='Roboto'>"+email+"</span>"
436                profile=Gtk.Label()
437                profile.set_markup(profile_info)
438                profile.set_margin_left(10)
439                profile.set_margin_right(15)
440                profile.set_margin_top(21)
441                profile.set_margin_bottom(21)
442                profile.set_width_chars(25)
443                profile.set_max_width_chars(25)
444                profile.set_xalign(-1)
445                profile.set_ellipsize(Pango.EllipsizeMode.END)
446                folder_image=Gtk.Image.new_from_file(FOLDER_IMAGE)
447                folder_image.set_margin_left(20)
448                folder_image.set_halign(Gtk.Align.CENTER)
449                folder_image.set_valign(Gtk.Align.CENTER)
450                folder=Gtk.Label()
451                folder.set_text(mountpoint)
452                folder.set_margin_left(10)
453                delete=Gtk.Button()
454                delete_image=Gtk.Image.new_from_file(DELETE_IMAGE)
455                delete.add(delete_image)
456                delete.set_halign(Gtk.Align.CENTER)
457                delete.set_valign(Gtk.Align.CENTER)
458                delete.set_name("DELETE_ITEM_BUTTON")
459                delete.connect("clicked",self.delete_profile_clicked,hbox)
460                delete.set_tooltip_text(_("Delete profile"))
461                edit=Gtk.Button()
462                edit_image=Gtk.Image.new_from_file(EDIT_IMAGE)
463                edit.add(edit_image)
464                edit.set_halign(Gtk.Align.CENTER)
465                edit.set_valign(Gtk.Align.CENTER)
466                edit.set_name("EDIT_ITEM_BUTTON")
467                edit.connect("clicked",self.edit_profile_clicked,hbox)
468                edit.set_tooltip_text(_("Edit profile"))
469                mount=Gtk.Button()
470               
471                if self.initial_connection:
472                        status_info=self.core.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
473                        self.current_status[profile_name]=status_info["status"]
474                        info=self.item_status_info(status_info["status"])
475                else:
476                        info=self.item_status_info(None)
477                        self.current_status[profile_name]=None
478                       
479               
480                mount_image=info["img"]
481                mount.set_tooltip_text(info["tooltip"])
482                mount.set_name(info["css"])
483                mount.add(mount_image)
484                mount.set_halign(Gtk.Align.CENTER)
485                mount.set_valign(Gtk.Align.CENTER)
486                mount.connect("clicked",self.sync_profile_clicked,hbox)
487               
488                hbox.pack_start(profile_image,False,False,0)
489                hbox.pack_start(profile,False,False,0)
490                hbox.pack_start(folder_image,False,False,0)
491                hbox.pack_start(folder,False,False,0)
492                hbox.pack_end(delete,False,False,10)
493                hbox.pack_end(edit,False,False,10)
494                hbox.pack_end(mount,False,False,10)
495                hbox.show_all()
496                hbox.set_name("PROFILE_BOX")
497                self.profile_list_box.pack_start(hbox,False,False,5)
498                self.profile_list_box.queue_draw()
499                hbox.queue_draw()
500               
501        #def new_profile_button
502
503        def item_status_info(self,status_info):
504       
505               
506
507                if status_info==None:
508                        print "SIN ESTADO"
509                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
510                        css="WARNING_ITEM_BUTTON"
511                        tooltip=_("Without connection. Clicked to update")
512                        css="WARNING_ITEM_BUTTON"                       
513                elif status_info:
514                        print "CON ESTADO"
515                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
516                        tooltip=_("Mounted. Clicked to dismount now")
517                        css="MOUNT_ITEM_BUTTON"
518                else:
519                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
520                        tooltip=_("Dismounted. Clicked to mount now")
521                        css="DELETE_ITEM_BUTTON"       
522
523                return {"img":img ,"tooltip":tooltip, "css":css}       
524
525        #def item_status_info                   
526
527        def accept_add_profile_clicked(self,widget):
528
529                self.disable_entry_profile_dialog()
530                #ENCODING TO UNICODE
531                profile=self.profile_entry.get_text()
532
533                self.new_profile=profile.strip().decode("utf-8")
534                email=self.email_entry.get_text()
535                self.new_email=email.strip()
536                self.new_mountpoint=self.mountpoint_entry.get_filename().decode("utf-8")
537                self.new_automount=self.automount_entry.get_state()
538
539                check_form=self.check_profile_info()
540                self.profile_msg.show()
541
542                if check_form["result"]:
543                        self.profiles_info[self.new_profile]={}
544                        self.profiles_info[self.new_profile]["email"]=self.new_email
545                        self.profiles_info[self.new_profile]["mountpoint"]=self.new_mountpoint
546                        self.profiles_info[self.new_profile]["automount"]=self.new_automount
547                        self.profile_msg.set_name("MSG_LABEL")
548                        if not self.edition:
549                                if not self.create_profile_t.launched:
550                                        self.profile_msg.set_text(_("Connecting with google to get account access..."))
551                                        self.profile_pbar.show()
552                                        self.retry=0
553                                        GLib.timeout_add(100,self.pulsate_add_profile)
554                               
555               
556                        else:
557                                if not self.edit_profile_t.launched:
558                                        self.profile_msg.set_text(_("Applying changes..."))
559                                        self.profile_pbar.show()
560                                        GLib.timeout_add(100,self.pulsate_edit_profile) 
561                else:
562                        self.profile_msg.set_name("MSG_ERROR_LABEL")
563                        self.profile_msg.set_text(check_form["msg"])
564                        self.enable_entry_profile_dialog()
565                               
566                               
567               
568       
569        #def accept_add_profile_clicked
570
571        def check_profile_info(self):
572
573                msg_check=""
574
575                check_form=self.core.LliurexGoogleDriveManager.check_profile_info(self.new_profile,self.new_mountpoint,self.edition)
576
577               
578                if not check_form["result"]:
579                        if check_form["code"]==1:
580                                msg_check=_("You must indicate a profile")
581
582                        elif check_form["code"]==2:
583                                msg_check=_("Profile can not contain blanks")
584
585                        elif check_form["code"]==3 :
586                                msg_check=_("Profile already exists")
587                       
588                        elif check_form["code"]==4:
589                                msg_check=_("Mount point already used by another profile")     
590
591                        elif check_form["code"]==5:
592                                msg_check=_("The mount point must be an empty folder") 
593
594                        elif check_form["code"]==6:
595                                msg_check=_("Mount point is not owned by user") 
596
597
598                return {"result":check_form["result"],"msg":msg_check}
599
600        #def check_profile_info
601
602        def pulsate_add_profile(self):
603
604                self.retry=self.retry+1
605                self.profile_pbar.pulse()
606               
607                if not self.create_profile_t.launched:
608                        self.accept_add_profile_button.hide()
609                        self.cancel_add_profile_button.hide()
610               
611                        self.create_profile_t.start()
612                        self.create_profile_t.launched=True
613
614                if not self.create_profile_t.is_alive():
615                        if not self.create_mountpoint_t.launched:
616                                self.profile_msg.set_name("MSG_LABEL")
617                                self.profile_msg.set_text(_("Creating profile... "))
618                                self.create_mountpoint_t.start()
619                                self.create_mountpoint_t.launched=True
620
621                        if self.create_mountpoint_t.done:
622                                self.profile_pbar.hide()
623                                if self.create_result["result"]:
624                                                self.initial_connection=True
625                                                self.new_profile_button(self.new_profile,self.new_email,self.new_mountpoint)
626                                                self.profile_msg.set_text(_("Profile created successfully"))
627                                                self.change_cancel_button()
628                                               
629                                else:
630                                        msg_text=self.get_msg(self.create_result["code"])
631                                        self.profile_msg.set_name("MSG_ERROR_LABEL")
632                                        self.profile_msg.set_text(msg_text)
633                                        self.cancel_add_profile_button.show()
634                                       
635                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
636                                return False   
637                                               
638                if self.create_profile_t.launched:
639                        if self.create_profile_t.is_alive():
640                                self.kill_create_profile()
641                                return True     
642                               
643
644                if self.create_mountpoint_t.launched:
645                        if not self.create_mountpoint_t.done:
646                                return True             
647
648        #def_pulsate_add_profile       
649
650
651        def get_msg(self,code):
652
653                if      code==0:
654                        msg_text=_("Changes applied successfully")
655               
656                elif    code==1:
657                        msg_text=_("Error: Unable to create mount point")
658
659                elif code==2:
660                        msg_text=_("Error: unable to mount mount point")
661
662                elif code==3:
663                        msg_text=_("Error: Mount point is not owned by user")   
664
665                elif code==4:
666                        msg_text=_("Error: No mount point indicated")
667
668                elif code==5:
669                        msg_text=_("Error: Profile is not authorized to Google Drive")
670
671                elif code==6:
672                        msg_text=_("Error: Unknow profile")
673
674                elif code==7:
675                        msg_text=_("Error: Unable to dismount mount point")
676
677                elif code==8:
678                        msg_text=_("Error: Unable to connect with google")     
679                       
680                elif code==9:
681                        msg_text=_("Status updated. Now you can change it")
682                return msg_text
683
684        #def get_msg                                                   
685
686        def kill_create_profile(self):
687       
688                if self.retry>MAX_RETRY_INTENTS:
689                        parent=psutil.Process(self.create_profile_t.pid)
690                        for child in parent.children(recursive=True):
691                                child.kill()
692                                self.create_profile_t.terminate()
693                                self.profile_msg.set_name("MSG_ERROR_LABEL")
694                                self.profile_msg.set_text(_("Error getting authorization"))
695
696                return True     
697
698        #def kill_create_profile       
699
700        def create_profile(self):
701
702                result=self.core.LliurexGoogleDriveManager.create_profile(self.new_profile)
703
704        #def create_profile     
705
706        def create_mountpoint(self):
707
708                self.create_result=self.core.LliurexGoogleDriveManager.create_mountpoint(self.profiles_info,self.new_profile)
709                self.create_mountpoint_t.done=True
710               
711        #def create_mountpoint 
712
713        def pulsate_edit_profile(self):
714
715                self.profile_pbar.pulse()
716                if not self.edit_profile_t.launched:
717                        self.edit_profile_t.start()
718                        self.edit_profile_t.launched=True
719                        self.accept_add_profile_button.hide()
720                        self.cancel_add_profile_button.hide()
721
722                if self.edit_profile_t.done:
723                        self.profile_pbar.hide()
724                        if self.edit_result["result"]:
725                                self.profile_msg.set_name("MSG_LABEL")
726                                self.profile_to_edit.get_children()[3].set_text(self.new_mountpoint)
727                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
728                                self.change_cancel_button()
729                       
730                        else:
731                               
732                                self.profile_msg.set_name("MSG_ERROR_LABEL")
733                                self.cancel_add_profile_button.show()
734
735                        msg_text=self.get_msg(self.edit_result["code"])
736                        self.profile_msg.set_text(msg_text)
737
738                        return False
739                       
740
741                if self.edit_profile_t.launched:
742                        if not self.edit_profile_t.done:
743                                return True
744
745        #def pulsate_edit_profile                       
746
747        def edit_profile(self):
748
749                self.edit_result=self.core.LliurexGoogleDriveManager.edit_profile(self.profiles_info,self.new_profile)
750                self.edit_profile_t.done=True
751
752        #def edit_profile       
753
754        def cancel_add_profile_clicked(self,widget):
755               
756                self.new_profile_window.hide()
757
758       
759        #def cancel_add_profile_clicked
760               
761#class profilebox
Note: See TracBrowser for help on using the repository browser.