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

Last change on this file since 4031 was 4031, checked in by jrpelegrina, 4 years ago

WIP in check connection. Edit and Sync Profile gui

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