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

Last change on this file since 5685 was 5685, checked in by jrpelegrina, 2 years ago

Updated changelog. Improved mount point verification

File size: 23.0 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                self.mountpoint_entry.connect("file-set",self.check_mountpoint_folder)
141
142
143        #def connect_signals
144
145
146        def check_initial_connection(self):
147               
148                self.initial_connection=self.core.LliurexGoogleDriveManager.check_google_connection()
149                return
150
151        #def check_initial_connection   
152       
153        def load_info(self,info):
154               
155                self.profiles_info=info
156                print self.profiles_info
157                for item in self.profiles_info:
158                        profile=item
159                        email=self.profiles_info[item]["email"]
160                        mountpoint=self.profiles_info[item]["mountpoint"]
161                        self.new_profile_button(profile,email,mountpoint)
162                       
163       
164        #def load_info()               
165
166        def hide_window(self,widget,event):
167               
168                widget.hide()
169                return True
170
171        #def hide_window       
172
173        def init_profile_dialog_button(self):
174
175                self.accept_add_profile_button.show()
176                image = Gtk.Image()
177                image.set_from_stock(Gtk.STOCK_CANCEL,Gtk.IconSize.MENU)
178                self.cancel_add_profile_button.set_image(image)
179                self.cancel_add_profile_button.set_label(_("Cancel"))
180                self.cancel_add_profile_button.show()
181
182        #def init_profile_dialog_button
183
184        def disable_entry_profile_dialog(self):
185
186                self.profile_entry.set_sensitive(False)
187                self.email_entry.set_sensitive(False)
188                self.mountpoint_entry.set_sensitive(False)
189                self.automount_entry.set_sensitive(False)
190
191        #def disable_entry_profile_dialog
192       
193        def enable_entry_profile_dialog(self):
194
195                if not self.edition:
196                       
197                        self.new_profile_window.set_title(_("Create new profile"))
198                        self.profile_entry.set_sensitive(True)
199                        self.profile_entry.grab_focus()
200                        self.email_entry.set_sensitive(True)
201
202                else:
203                        self.new_profile_window.set_title(_("Edit profile"))
204                        self.profile_entry.set_sensitive(False)
205                        self.email_entry.set_sensitive(False)
206
207                self.mountpoint_entry.set_sensitive(True)
208                self.automount_entry.set_sensitive(True)       
209
210        #def enable_entry_profile_dialog       
211
212        def change_cancel_button(self):
213               
214                image = Gtk.Image()
215                image.set_from_stock(Gtk.STOCK_CLOSE,Gtk.IconSize.MENU)
216                self.cancel_add_profile_button.set_image(image)
217                self.cancel_add_profile_button.set_label(_("Close"))   
218                self.cancel_add_profile_button.show()   
219
220        #def change_cancel_button       
221
222        def add_new_profile_button_clicked(self,widget):
223
224                self.edition=False
225                self.core.lgd.check_plabel.set_text(_("Checking connection to google..."))
226                self.core.lgd.check_window.show()
227                self.init_threads()
228                self.check_connection_t.start()
229                GLib.timeout_add(100,self.pulsate_add_connection)
230
231        #def add_new_profile_button_clicked     
232       
233        def pulsate_add_connection(self):
234               
235                if self.check_connection_t.is_alive():
236                                self.core.lgd.check_pbar.pulse()
237                                return True
238
239                else:
240                        self.core.lgd.check_window.hide()
241                        self.enable_entry_profile_dialog()
242                        #ENCODING TO UNICODE
243                        if self.connection:
244                                self.profile_entry.set_text("")
245                                self.email_entry.set_text("")
246                                self.mountpoint_entry.set_filename(os.environ["HOME"])
247                                self.automount_entry.set_active(False)
248                                self.profile_msg.set_text("")
249               
250
251                                self.init_threads()
252                               
253                                self.msg_label.set_text("")
254                                self.profile_msg.hide()
255                                self.profile_pbar.hide()
256                                self.init_profile_dialog_button()
257                                self.new_profile_window.show()
258                               
259                        else:           
260                                msg_error=self.get_msg(8)
261                                self.msg_label.set_name("MSG_ERROR_LABEL")
262                                self.msg_label.set_text(msg_error)             
263               
264                return False   
265               
266
267        #def add_new_profile_button_clicked     
268
269        def delete_profile_clicked(self,button,hbox):
270
271                dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO, "Lliurex GDrive")
272                dialog.format_secondary_text(_("Do you want delete the profile?"))
273                response=dialog.run()
274                dialog.destroy()
275               
276
277                if response==Gtk.ResponseType.YES:
278                        profile=hbox.get_children()[1].get_text().split("\n")[0]
279                        #ENCODING TO UNICODE                   
280                        profile=profile.decode("utf-8")
281                        self.delete_profile_t=threading.Thread(target=self.delete_profile,args=(profile,))
282                        self.delete_profile_t.daemon=True
283                        GObject.threads_init()
284
285                        self.msg_label.set_text("")
286                       
287                        self.profiles_info.pop(profile)
288                        self.delete_profile_t.start()
289                        self.delete_profile_t.launched=True
290                        self.core.lgd.check_plabel.set_text(_("Applying changes..."))
291                        self.core.lgd.check_window.show()
292                        GLib.timeout_add(100,self.pulsate_delete_profile,profile,hbox)
293
294        # def delete_profile_clicked
295               
296        def pulsate_delete_profile(self,profile,hbox):
297
298                        if self.delete_profile_t.is_alive():
299                                self.core.lgd.check_pbar.pulse()
300                                return True
301
302                        else:
303                                self.msg_label.show()
304                                self.core.lgd.check_window.hide()
305                                if self.delete["result"]:
306                                        self.msg_label.set_name("MSG_LABEL")
307                                        self.profile_list_box.remove(hbox)
308                                else:
309                                        self.msg_label.set_name("MSG_ERROR_LABEL")
310                               
311                                msg_text=self.get_msg(self.delete["code"])
312                                self.msg_label.set_text(msg_text)
313                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()
314                               
315                        return False   
316
317        #def pulsate_delete_profile             
318
319       
320        def delete_profile(self,profile):
321
322                self.delete=self.core.LliurexGoogleDriveManager.delete_profile(self.profiles_info,profile)
323
324        #def delete_profile     
325
326        def sync_profile_clicked(self,button,hbox):
327
328                self.msg_label.set_text("")
329                self.sync_profile_t=threading.Thread(target=self.sync_profile,args=(hbox,))
330                self.sync_profile_t.daemon=True
331                GObject.threads_init()
332               
333                self.sync_profile_t.start()
334                self.core.lgd.check_plabel.set_text(_("Applying changes..."))
335                self.core.lgd.check_window.show()
336                GLib.timeout_add(100,self.pulsate_sync_profile,button,hbox)
337
338       
339        #def sync_profile_cicked
340
341        def pulsate_sync_profile(self,button,hbox):
342
343                if self.sync_profile_t.is_alive():
344                        self.core.lgd.check_pbar.pulse()
345                        return True
346
347                else:
348                        self.core.lgd.check_window.hide()
349                        if self.status_mod["result"]:
350                                msg_text=self.get_msg(self.status_mod["code"])
351                                self.msg_label.set_name("MSG_LABEL")
352                                self.msg_label.set_text(msg_text)
353                               
354                        else:
355                                msg_text=self.get_msg(self.status_mod["code"])
356                                self.msg_label.set_name("MSG_ERROR_LABEL")
357                                self.msg_label.set_text(msg_text)       
358                       
359
360                        info=self.item_status_info(self.status_info['status'])
361                        profile=hbox.get_children()[1].get_text().split("\n")[0]
362                        self.current_status[profile.decode("utf-8")]=self.status_info["status"]
363                        button.set_tooltip_text(info["tooltip"])
364                        button.set_name(info["css"])           
365                        hbox.get_children()[4].set_image(info["img"])   
366
367                return False                                   
368
369        #def pulsate_sync_profile       
370
371        def sync_profile(self,hbox):
372       
373                profile=hbox.get_children()[1].get_text().split("\n")[0]
374                mountpoint=hbox.get_children()[3].get_text()
375                # ENCODING TO UNICODE           
376                profile=profile.decode("utf-8")
377                mountpoint=mountpoint.decode("utf-8")
378                connect=True
379                current_status=self.current_status[profile]
380                self.status_mod,self.status_info=self.core.LliurexGoogleDriveManager.sync_profile(profile,mountpoint,current_status)
381               
382        #def sync_profile       
383
384        def edit_profile_clicked(self,button,hbox):
385
386                self.edition=True
387                self.core.lgd.check_plabel.set_text(_("Checking connection to google..."))
388                self.core.lgd.check_window.show()
389                self.init_threads()
390                self.check_connection_t.start()
391                GLib.timeout_add(100,self.pulsate_edit_connection,hbox)
392
393               
394        #def edit_profile_clicked
395
396        def pulsate_edit_connection(self,hbox):
397
398                if self.check_connection_t.is_alive():
399                                self.core.lgd.check_pbar.pulse()
400                                return True
401
402                else:
403                        self.core.lgd.check_window.hide()
404                        self.enable_entry_profile_dialog()
405                        #ENCODING TO UNICODE
406                        if self.connection:
407                                self.profile_to_edit=hbox               
408                                profile=self.profile_to_edit.get_children()[1].get_text().split("\n")[0]
409                                self.profile_entry.set_text(profile)
410                                email=self.profile_to_edit.get_children()[1].get_text().split("\n")[1]
411                                self.email_entry.set_text(email)
412                                mountpoint=self.profile_to_edit.get_children()[3].get_text()
413                                self.mountpoint_entry.set_filename(mountpoint)
414                                automount=self.profiles_info[profile.decode("utf-8")]["automount"]
415                                self.automount_entry.set_active(automount)
416                               
417
418                                self.init_threads()
419
420                                self.profile_msg.hide()
421                                self.profile_pbar.hide()
422                                self.msg_label.set_text("")
423                                self.init_profile_dialog_button()
424                                self.new_profile_window.show()
425
426                        else:           
427                                msg_text=self.get_msg(8)
428                                self.msg_label.set_name("MSG_ERROR_LABEL")
429                                self.msg_label.set_text(msg_text)               
430                return False
431
432        #def pulsate_edit_connection   
433
434
435        def check_connection(self):
436                self.connection=self.core.LliurexGoogleDriveManager.check_google_connection()
437
438        #def check_connection   
439
440        def new_profile_button(self,profile_name,email,mountpoint):
441               
442                hbox=Gtk.HBox()
443                profile_image=Gtk.Image.new_from_file(PROFILE_IMAGE)
444                profile_image.set_margin_left(10)
445                profile_image.set_halign(Gtk.Align.CENTER)
446                profile_image.set_valign(Gtk.Align.CENTER)
447                profile_info="<span font='Roboto'><b>"+profile_name+"</b></span>\n"+"<span font='Roboto'>"+email+"</span>"
448                profile=Gtk.Label()
449                profile.set_markup(profile_info)
450                profile.set_margin_left(10)
451                profile.set_margin_right(15)
452                profile.set_margin_top(21)
453                profile.set_margin_bottom(21)
454                profile.set_width_chars(25)
455                profile.set_max_width_chars(25)
456                profile.set_xalign(-1)
457                profile.set_ellipsize(Pango.EllipsizeMode.END)
458                folder_image=Gtk.Image.new_from_file(FOLDER_IMAGE)
459                folder_image.set_margin_left(20)
460                folder_image.set_halign(Gtk.Align.CENTER)
461                folder_image.set_valign(Gtk.Align.CENTER)
462                folder=Gtk.Label()
463                folder.set_text(mountpoint)
464                folder.set_margin_left(10)
465                delete=Gtk.Button()
466                delete_image=Gtk.Image.new_from_file(DELETE_IMAGE)
467                delete.add(delete_image)
468                delete.set_halign(Gtk.Align.CENTER)
469                delete.set_valign(Gtk.Align.CENTER)
470                delete.set_name("DELETE_ITEM_BUTTON")
471                delete.connect("clicked",self.delete_profile_clicked,hbox)
472                delete.set_tooltip_text(_("Delete profile"))
473                edit=Gtk.Button()
474                edit_image=Gtk.Image.new_from_file(EDIT_IMAGE)
475                edit.add(edit_image)
476                edit.set_halign(Gtk.Align.CENTER)
477                edit.set_valign(Gtk.Align.CENTER)
478                edit.set_name("EDIT_ITEM_BUTTON")
479                edit.connect("clicked",self.edit_profile_clicked,hbox)
480                edit.set_tooltip_text(_("Edit profile"))
481                mount=Gtk.Button()
482               
483                if self.initial_connection:
484                        status_info=self.core.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
485                        self.current_status[profile_name]=status_info["status"]
486                        info=self.item_status_info(status_info["status"])
487                else:
488                        info=self.item_status_info(None)
489                        self.current_status[profile_name]=None
490                       
491               
492                mount_image=info["img"]
493                mount.set_tooltip_text(info["tooltip"])
494                mount.set_name(info["css"])
495                mount.add(mount_image)
496                mount.set_halign(Gtk.Align.CENTER)
497                mount.set_valign(Gtk.Align.CENTER)
498                mount.connect("clicked",self.sync_profile_clicked,hbox)
499               
500                hbox.pack_start(profile_image,False,False,0)
501                hbox.pack_start(profile,False,False,0)
502                hbox.pack_start(folder_image,False,False,0)
503                hbox.pack_start(folder,False,False,0)
504                hbox.pack_end(delete,False,False,10)
505                hbox.pack_end(edit,False,False,10)
506                hbox.pack_end(mount,False,False,10)
507                hbox.show_all()
508                hbox.set_name("PROFILE_BOX")
509                self.profile_list_box.pack_start(hbox,False,False,5)
510                self.profile_list_box.queue_draw()
511                hbox.queue_draw()
512               
513        #def new_profile_button
514
515        def item_status_info(self,status_info):
516       
517               
518
519                if status_info==None:
520                        print "SIN ESTADO"
521                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
522                        css="WARNING_ITEM_BUTTON"
523                        tooltip=_("Without connection. Clicked to update")
524                        css="WARNING_ITEM_BUTTON"                       
525                elif status_info:
526                        print "CON ESTADO"
527                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
528                        tooltip=_("Mounted. Clicked to dismount now")
529                        css="MOUNT_ITEM_BUTTON"
530                else:
531                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
532                        tooltip=_("Dismounted. Clicked to mount now")
533                        css="DELETE_ITEM_BUTTON"       
534
535                return {"img":img ,"tooltip":tooltip, "css":css}       
536
537        #def item_status_info                   
538
539        def accept_add_profile_clicked(self,widget):
540
541                self.disable_entry_profile_dialog()
542                #ENCODING TO UNICODE
543                profile=self.profile_entry.get_text()
544
545                self.new_profile=profile.strip().decode("utf-8")
546                email=self.email_entry.get_text()
547                self.new_email=email.strip()
548                self.new_mountpoint=self.mountpoint_entry.get_filename().decode("utf-8")
549                self.new_automount=self.automount_entry.get_state()
550
551                #check_form=self.check_profile_info()
552                check_form=self.core.LliurexGoogleDriveManager.check_profile_info(self.new_profile,self.new_mountpoint,self.edition)
553
554                self.profile_msg.show()
555
556                if check_form["result"]:
557                        self.profiles_info[self.new_profile]={}
558                        self.profiles_info[self.new_profile]["email"]=self.new_email
559                        self.profiles_info[self.new_profile]["mountpoint"]=self.new_mountpoint
560                        self.profiles_info[self.new_profile]["automount"]=self.new_automount
561                        self.profile_msg.set_name("MSG_LABEL")
562                        if not self.edition:
563                                if not self.create_profile_t.launched:
564                                        self.profile_msg.set_text(_("Connecting with google to get account access..."))
565                                        self.profile_pbar.show()
566                                        self.retry=0
567                                        GLib.timeout_add(100,self.pulsate_add_profile)
568                               
569               
570                        else:
571                                if not self.edit_profile_t.launched:
572                                        self.profile_msg.set_text(_("Applying changes..."))
573                                        self.profile_pbar.show()
574                                        GLib.timeout_add(100,self.pulsate_edit_profile) 
575                else:
576                        self.profile_msg.set_name("MSG_ERROR_LABEL")
577                        #self.profile_msg.set_text(check_form["msg"])
578                        self.profile_msg.set_text(self.get_msg(check_form["code"]))
579                        self.enable_entry_profile_dialog()
580
581       
582        #def accept_add_profile_clicked
583
584        def check_mountpoint_folder(self,widget):
585
586       
587                self.disable_entry_profile_dialog()
588                #ENCODING TO UNICODE
589                profile=self.profile_entry.get_text()
590
591                new_profile=profile.strip().decode("utf-8")
592                new_mountpoint=self.mountpoint_entry.get_filename().decode("utf-8")
593                               
594                check_form=self.core.LliurexGoogleDriveManager.check_mountpoint_folder(new_profile,new_mountpoint,self.edition)
595               
596                if not check_form["result"]:
597                        self.profile_msg.show()
598                        self.profile_msg.set_name("MSG_ERROR_LABEL")
599                        self.profile_msg.set_text(self.get_msg(check_form["code"]))
600                       
601                else:
602                        self.profile_msg.hide() 
603
604                self.enable_entry_profile_dialog()     
605
606        #def check_mountpoint_folder   
607
608        '''     
609        def check_profile_info(self):
610
611                msg_check=""
612
613                check_form=self.core.LliurexGoogleDriveManager.check_profile_info(self.new_profile,self.new_mountpoint,self.edition)
614
615               
616                if not check_form["result"]:
617                        if check_form["code"]==1:
618                                msg_check=_("You must indicate a profile")
619
620                        elif check_form["code"]==2:
621                                msg_check=_("Profile can not contain blanks")
622
623                        elif check_form["code"]==3 :
624                                msg_check=_("Profile already exists")
625                       
626                        elif check_form["code"]==4:
627                                msg_check=_("Mount point already used by another profile")     
628
629                        elif check_form["code"]==5:
630                                msg_check=_("The mount point must be an empty folder") 
631
632                        elif check_form["code"]==6:
633                                msg_check=_("Mount point is not owned by user")
634
635
636                return {"result":check_form["result"],"msg":msg_check}
637
638        #def check_profile_info
639
640        '''     
641
642        def pulsate_add_profile(self):
643
644                self.retry=self.retry+1
645                self.profile_pbar.pulse()
646               
647                if not self.create_profile_t.launched:
648                        self.accept_add_profile_button.hide()
649                        self.cancel_add_profile_button.hide()
650               
651                        self.create_profile_t.start()
652                        self.create_profile_t.launched=True
653
654                if not self.create_profile_t.is_alive():
655                        if not self.create_mountpoint_t.launched:
656                                self.profile_msg.set_name("MSG_LABEL")
657                                self.profile_msg.set_text(_("Creating profile... "))
658                                self.create_mountpoint_t.start()
659                                self.create_mountpoint_t.launched=True
660
661                        if self.create_mountpoint_t.done:
662                                self.profile_pbar.hide()
663                                if self.create_result["result"]:
664                                                self.initial_connection=True
665                                                self.new_profile_button(self.new_profile,self.new_email,self.new_mountpoint)
666                                                self.profile_msg.set_text(_("Profile created successfully"))
667                                                self.change_cancel_button()
668                                               
669                                else:
670                                        msg_text=self.get_msg(self.create_result["code"])
671                                        self.profile_msg.set_name("MSG_ERROR_LABEL")
672                                        self.profile_msg.set_text(msg_text)
673                                        self.cancel_add_profile_button.show()
674                                       
675                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
676                                return False   
677                                               
678                if self.create_profile_t.launched:
679                        if self.create_profile_t.is_alive():
680                                self.kill_create_profile()
681                                return True     
682                               
683
684                if self.create_mountpoint_t.launched:
685                        if not self.create_mountpoint_t.done:
686                                return True             
687
688        #def_pulsate_add_profile       
689
690
691        def get_msg(self,code):
692
693                if      code==0:
694                        msg_text=_("Changes applied successfully")
695               
696                elif code==1:
697                        msg_text=_("Error: Unable to create mount point")
698
699                elif code==2:
700                        msg_text=_("Error: unable to mount mount point")
701
702                elif code==3:
703                        msg_text=_("Error: Mount point is not owned by user")   
704
705                elif code==4:
706                        msg_text=_("Error: No mount point indicated")
707
708                elif code==5:
709                        msg_text=_("Error: Profile is not authorized to Google Drive")
710
711                elif code==6:
712                        msg_text=_("Error: Unknow profile")
713
714                elif code==7:
715                        msg_text=_("Error: Unable to dismount mount point")
716
717                elif code==8:
718                        msg_text=_("Error: Unable to connect with google")     
719                       
720                elif code==9:
721                        msg_text=_("Status updated. Now you can change it")
722
723                elif code==10:
724                        msg_text=_("You must indicate a profile")
725
726                elif code==11:
727                        msg_text=_("Profile can not contain blanks")
728
729                elif code==12:
730                        msg_text=_("Profile already exists")
731                       
732                elif code==13:
733                        msg_text=_("Mount point already used by another profile")       
734
735                elif code==14:
736                        msg_text=_("The mount point must be an empty folder")   
737
738                elif code==15:
739                        msg_text=_("Mount point is not owned by user")         
740               
741                return msg_text         
742               
743
744        #def get_msg                                                   
745
746        def kill_create_profile(self):
747       
748                if self.retry>MAX_RETRY_INTENTS:
749                        parent=psutil.Process(self.create_profile_t.pid)
750                        for child in parent.children(recursive=True):
751                                child.kill()
752                                self.create_profile_t.terminate()
753                                self.profile_msg.set_name("MSG_ERROR_LABEL")
754                                self.profile_msg.set_text(_("Error getting authorization"))
755
756                return True     
757
758        #def kill_create_profile       
759
760        def create_profile(self):
761
762                result=self.core.LliurexGoogleDriveManager.create_profile(self.new_profile)
763
764        #def create_profile     
765
766        def create_mountpoint(self):
767
768                self.create_result=self.core.LliurexGoogleDriveManager.create_mountpoint(self.profiles_info,self.new_profile)
769                self.create_mountpoint_t.done=True
770               
771        #def create_mountpoint 
772
773        def pulsate_edit_profile(self):
774
775                self.profile_pbar.pulse()
776                if not self.edit_profile_t.launched:
777                        self.edit_profile_t.start()
778                        self.edit_profile_t.launched=True
779                        self.accept_add_profile_button.hide()
780                        self.cancel_add_profile_button.hide()
781
782                if self.edit_profile_t.done:
783                        self.profile_pbar.hide()
784                        if self.edit_result["result"]:
785                                self.profile_msg.set_name("MSG_LABEL")
786                                self.profile_to_edit.get_children()[3].set_text(self.new_mountpoint)
787                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
788                                self.change_cancel_button()
789                       
790                        else:
791                               
792                                self.profile_msg.set_name("MSG_ERROR_LABEL")
793                                self.cancel_add_profile_button.show()
794
795                        msg_text=self.get_msg(self.edit_result["code"])
796                        self.profile_msg.set_text(msg_text)
797
798                        return False
799                       
800
801                if self.edit_profile_t.launched:
802                        if not self.edit_profile_t.done:
803                                return True
804
805        #def pulsate_edit_profile                       
806
807        def edit_profile(self):
808
809                self.edit_result=self.core.LliurexGoogleDriveManager.edit_profile(self.profiles_info,self.new_profile)
810                self.edit_profile_t.done=True
811
812        #def edit_profile       
813
814        def cancel_add_profile_clicked(self,widget):
815               
816                self.new_profile_window.hide()
817
818       
819        #def cancel_add_profile_clicked
820               
821#class profilebox
Note: See TracBrowser for help on using the repository browser.