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

Last change on this file was 7325, checked in by jrpelegrina, 19 months ago

Rename function

File size: 33.7 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.stack = Gtk.Stack()
51                self.stack.set_transition_duration(1000)
52                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
53
54                self.main_box=builder.get_object("profile_data_box")
55                self.profiles_list_label=builder.get_object("profiles_list_label")
56                self.profile_list_box=builder.get_object("profile_list_box")
57                self.profile_list_vp=builder.get_object("profile_list_viewport")
58                self.msg_label=builder.get_object("msg_label")
59
60                image = Gtk.Image()
61                image.set_from_stock(Gtk.STOCK_ADD,Gtk.IconSize.MENU)
62               
63                self.add_new_profile_button=builder.get_object("add_new_profile_button")
64                self.add_new_profile_button.set_image(image)
65                self.new_profile_window=builder.get_object("new_profile_window")
66                self.data=builder.get_object("data")
67                self.edit_profile_box=builder.get_object("edit_profile_box")
68                self.profile_label=builder.get_object("profile_label")
69                self.profile_entry=builder.get_object("profile_entry")
70                self.email_label=builder.get_object("email_label")
71                self.email_entry=builder.get_object("email_entry")
72                self.mountpoint_label=builder.get_object("mountpoint_label")
73                self.mountpoint_entry=builder.get_object("mountpoint_entry")
74                self.automount_label=builder.get_object("automount_label")
75                self.automount_entry=builder.get_object("automount_entry")
76                self.root_folder_param_label=builder.get_object("root_folder_param_label")
77                self.root_folder_param_entry=builder.get_object("root_folder_param_entry")
78                self.gdrive_folder_label=builder.get_object("gdrive_folder_label")
79                self.gdrive_folder_entry=builder.get_object("gdrive_folder_entry")
80                self.gdrive_folder_entry.set_width_chars(30)
81                self.gdrive_folder_entry.set_max_width_chars(30)
82                self.gdrive_folder_entry.set_xalign(-1)
83                self.gdrive_folder_entry.set_ellipsize(Pango.EllipsizeMode.START)
84                self.edit_gdrive_folder_button=builder.get_object("edit_gdrive_folder_button")
85
86                self.profile_msg=builder.get_object("profile_msg")
87                self.profile_pbar=builder.get_object("profile_pbar")
88                self.accept_add_profile_button=builder.get_object("accept_add_profile_button")
89                self.cancel_add_profile_button=builder.get_object("cancel_add_profile_button")
90
91                self.gdrive_combobox_box=builder.get_object("gdrive_combobox_box")
92                self.gdrive_combobox_label=builder.get_object("gdrive_combobox_label")
93                self.gdrive_combobox=builder.get_object("gdrive_combobox")
94                self.return_combobox_button=builder.get_object("return_combobox_button")
95               
96                                       
97                self.syncfolders_model=Gtk.ListStore(str)
98                rende=Gtk.CellRendererText()
99                rende.set_property("ellipsize-set",True)
100                rende.set_property("ellipsize",Pango.EllipsizeMode.START)
101                rende.set_property("width-chars",65)
102                rende.set_property("max-width-chars",65)
103                self.gdrive_combobox.set_model(self.syncfolders_model)
104                self.gdrive_combobox.pack_start(rende,False)
105                self.gdrive_combobox.add_attribute(rende,"text",0)
106               
107                self.gdrive_combobox.set_active(0)
108                       
109                self.pack_start(self.main_box,True,True,0)
110                self.connect_signals()
111                self.set_css_info()
112                self.stack.show()
113                self.stack.add_titled(self.edit_profile_box,"edit","Edit")
114                self.stack.add_titled(self.gdrive_combobox_box,"folder", "Folder")
115                self.data.pack_start(self.stack,True,False,5)
116
117                self.data.pack_start(self.edit_profile_box,True,True,0)
118
119
120                self.current_status={}
121                self.edition=False
122                self.root_folder=False
123                self.read=False
124                self.profile_pbar.hide()
125
126                self.init_threads()
127                self.check_initial_connection()
128
129                               
130        #def __init__
131
132        def init_threads(self):
133
134                self.create_profile_t=multiprocessing.Process(target=self.create_profile)
135                self.create_mountpoint_t=threading.Thread(target=self.create_mountpoint)
136                self.edit_profile_t=threading.Thread(target=self.edit_profile)
137                self.check_connection_t=threading.Thread(target=self.check_connection)
138                self.read_mountpoint_t=threading.Thread(target=self.read_mountpoint)
139                self.check_form_t=threading.Thread(target=self.check_form)
140               
141               
142                self.create_profile_t.daemon=True
143                self.create_mountpoint_t.daemon=True
144                self.edit_profile_t.daemon=True
145                self.check_connection_t.daemon=True
146                self.read_mountpoint_t.daemon=True
147                self.check_form_t.daemon=True
148
149                self.create_mountpoint_t.done=False
150                self.edit_profile_t.done=False
151                self.read_mountpoint_t.done=False
152                self.check_form_t.done=False
153
154                self.create_profile_t.launched=False
155                self.create_mountpoint_t.launched=False
156                self.edit_profile_t.launched=False
157                self.read_mountpoint_t.launched=False
158                self.check_form_t.launched=False
159               
160               
161                GObject.threads_init()
162
163        #def init_threads       
164
165        def set_css_info(self):
166               
167                self.style_provider=Gtk.CssProvider()
168
169                f=Gio.File.new_for_path(CSS_FILE)
170                self.style_provider.load_from_file(f)
171
172                Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),self.style_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
173                self.profiles_list_label.set_name("OPTION_LABEL")
174                self.profile_label.set_name("OPTION_LABEL")
175                self.email_label.set_name("OPTION_LABEL")
176                self.mountpoint_label.set_name("OPTION_LABEL")
177                self.automount_label.set_name("OPTION_LABEL")
178                self.msg_label.set_name("MSG_LABEL")
179                self.profile_msg.set_name("MSG_LABEL")
180                self.root_folder_param_label.set_name("OPTION_LABEL")
181                self.gdrive_combobox_label.set_name("OPTION_LABEL")
182                self.gdrive_folder_label.set_name("OPTION_LABEL")
183                self.gdrive_folder_entry.set_name("GDRIVE_FOLDER")
184               
185                       
186        #def set-css_info
187       
188               
189        def connect_signals(self):
190
191                self.add_new_profile_button.connect("clicked",self.add_new_profile_button_clicked)
192                self.accept_add_profile_button.connect("clicked",self.accept_add_profile_clicked)
193                self.cancel_add_profile_button.connect("clicked",self.cancel_add_profile_clicked)
194                self.new_profile_window.connect("delete_event",self.hide_window)
195                self.mountpoint_entry.connect("file-set",self.check_mountpoint_folder)
196                self.gdrive_combobox.connect("changed",self.on_gdrive_combobox_changed)
197                self.root_folder_param_entry.connect("notify::active",self.root_folder_clicked)
198                self.return_combobox_button.connect("clicked",self.return_combobox_button_clicked)
199                self.edit_gdrive_folder_button.connect("clicked",self.edit_gdrive_folder_button_clicked)
200
201
202        #def connect_signals
203
204
205        def check_initial_connection(self):
206               
207                self.initial_connection=self.core.LliurexGoogleDriveManager.check_google_connection()
208               
209                return
210
211        #def check_initial_connection   
212       
213        def load_info(self,info):
214               
215                self.profiles_info=info
216                for item in self.profiles_info:
217                        profile=item
218                        email=self.profiles_info[item]["email"]
219                        mountpoint=self.profiles_info[item]["mountpoint"]
220                        self.new_profile_button(profile,email,mountpoint)
221                       
222       
223        #def load_info()               
224
225        def hide_window(self,widget,event):
226               
227                widget.hide()
228                return True
229
230        #def hide_window       
231
232        def init_profile_dialog_button(self):
233
234                self.accept_add_profile_button.show()
235                image = Gtk.Image()
236                image.set_from_stock(Gtk.STOCK_CANCEL,Gtk.IconSize.MENU)
237                self.cancel_add_profile_button.set_image(image)
238                self.cancel_add_profile_button.set_label(_("Cancel"))
239                self.cancel_add_profile_button.show()
240
241        #def init_profile_dialog_button
242
243        def disable_entry_profile_dialog(self):
244
245                self.profile_entry.set_sensitive(False)
246                self.email_entry.set_sensitive(False)
247                self.mountpoint_entry.set_sensitive(False)
248                self.automount_entry.set_sensitive(False)
249                self.root_folder_param_entry.set_sensitive(False)
250                self.edit_gdrive_folder_button.set_sensitive(False)
251
252        #def disable_entry_profile_dialog
253       
254        def enable_entry_profile_dialog(self):
255
256                if not self.edition:
257                       
258                        self.new_profile_window.set_title(_("Create new profile"))
259                        self.profile_entry.set_sensitive(True)
260                        self.profile_entry.grab_focus()
261                        self.email_entry.set_sensitive(True)
262                        self.root_folder_param_entry.hide()
263                        self.root_folder_param_label.hide()
264                        self.gdrive_folder_label.hide()
265                        self.gdrive_folder_entry.hide()
266                        self.edit_gdrive_folder_button.hide()   
267
268                else:
269                        self.new_profile_window .set_title(_("Edit profile"))
270                        self.profile_entry.set_sensitive(False)
271                        self.email_entry.set_sensitive(False)
272                        self.root_folder_param_label.show()
273                        self.root_folder_param_entry.show()
274                        self.root_folder_param_entry.set_sensitive(True)
275
276                        if self.root_folder:
277                                self.edit_gdrive_folder_button.show()
278                                self.edit_gdrive_folder_button.set_sensitive(True)
279                        else:
280                                if self.read:
281                                        self.edit_gdrive_folder_button.show()   
282                                        self.edit_gdrive_folder_button.set_sensitive(True)
283                       
284                self.mountpoint_entry.set_sensitive(True)
285                self.automount_entry.set_sensitive(True)       
286
287        #def enable_entry_profile_dialog       
288
289        def change_cancel_button(self):
290               
291                image = Gtk.Image()
292                image.set_from_stock(Gtk.STOCK_CLOSE,Gtk.IconSize.MENU)
293                self.cancel_add_profile_button.set_image(image)
294                self.cancel_add_profile_button.set_label(_("Close"))   
295                self.cancel_add_profile_button.show()   
296
297        #def change_cancel_button       
298
299        def add_new_profile_button_clicked(self,widget):
300
301                self.edition=False
302                self.msg_label.set_text("")
303                is_chromium_favourite=self.core.LliurexGoogleDriveManager.is_chromium_favourite_browser()
304                changed_browser=True
305
306                if is_chromium_favourite:
307                        can_change=self.core.LliurexGoogleDriveManager.can_change_browser()
308                        if can_change:
309                                dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO, "Lliurex GDrive")
310                                dialog.format_secondary_text(_("To add a profile it is necessary to change Chromium as default browser by another (Firefox or Chrome).\nThe change will be made automatically. Once the profile is added Chromium it will be the favorite browser again.\nDo you wish to continue?"))
311                                response=dialog.run()
312                                dialog.destroy()
313                                if response==Gtk.ResponseType.YES:
314                                        self.core.LliurexGoogleDriveManager.change_default_browser()
315                                else:
316                                        changed_browser=False
317                        else:
318                                changed_browser=False           
319
320                if changed_browser:                             
321                        self.core.lgd.check_plabel.set_text(_("Checking connection to google..."))
322                        self.core.lgd.check_window.show()
323                        self.init_threads()
324                        self.check_connection_t.start()
325                        GLib.timeout_add(100,self.pulsate_add_connection)
326
327                else:   
328                        msg_error=self.get_msg(21)
329                        self.msg_label.set_name("MSG_ERROR_LABEL")
330                        self.msg_label.set_text(msg_error)
331
332        #def add_new_profile_button_clicked     
333       
334        def pulsate_add_connection(self):
335               
336                if self.check_connection_t.is_alive():
337                                self.core.lgd.check_pbar.pulse()
338                                return True
339
340                else:
341                        self.core.lgd.check_window.hide()
342                        self.enable_entry_profile_dialog()
343                        #ENCODING TO UNICODE
344                        if self.connection:
345                                self.profile_entry.set_text("")
346                                self.email_entry.set_text("")
347                                self.mountpoint_entry.set_filename(os.environ["HOME"])
348                                self.automount_entry.set_active(False)
349                                self.profile_msg.set_text("")
350               
351
352                                self.init_threads()
353                               
354                                self.msg_label.set_text("")
355                                self.profile_msg.hide()
356                                self.profile_pbar.hide()
357                                self.init_profile_dialog_button()
358                                self.new_profile_window.show()
359                               
360                        else:
361                                self.core.LliurexGoogleDriveManager.remove_chromium_tmpbin()           
362                                msg_error=self.get_msg(8)
363                                self.msg_label.set_name("MSG_ERROR_LABEL")
364                                self.msg_label.set_text(msg_error)             
365               
366                return False   
367               
368
369        #def add_new_profile_button_clicked     
370
371        def delete_profile_clicked(self,button,hbox):
372
373                dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO, "Lliurex GDrive")
374                dialog.format_secondary_text(_("Do you want delete the profile?"))
375                response=dialog.run()
376                dialog.destroy()
377               
378
379                if response==Gtk.ResponseType.YES:
380                        profile=hbox.get_children()[1].get_text().split("\n")[0]
381                        #ENCODING TO UNICODE                   
382                        profile=profile.decode("utf-8")
383                        self.delete_profile_t=threading.Thread(target=self.delete_profile,args=(profile,))
384                        self.delete_profile_t.daemon=True
385                        GObject.threads_init()
386
387                        self.msg_label.set_text("")
388                       
389                        self.profiles_info.pop(profile)
390                        self.delete_profile_t.start()
391                        self.delete_profile_t.launched=True
392                        self.core.lgd.check_plabel.set_text(_("Applying changes..."))
393                        self.core.lgd.check_window.show()
394                        GLib.timeout_add(100,self.pulsate_delete_profile,profile,hbox)
395
396        # def delete_profile_clicked
397               
398        def pulsate_delete_profile(self,profile,hbox):
399
400                        if self.delete_profile_t.is_alive():
401                                self.core.lgd.check_pbar.pulse()
402                                return True
403
404                        else:
405                                self.msg_label.show()
406                                self.core.lgd.check_window.hide()
407                                if self.delete["result"]:
408                                        self.msg_label.set_name("MSG_LABEL")
409                                        self.profile_list_box.remove(hbox)
410                                else:
411                                        self.msg_label.set_name("MSG_ERROR_LABEL")
412                               
413                                msg_text=self.get_msg(self.delete["code"])
414                                self.msg_label.set_text(msg_text)
415                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()
416                               
417                        return False   
418
419        #def pulsate_delete_profile             
420
421       
422        def delete_profile(self,profile):
423
424                self.delete=self.core.LliurexGoogleDriveManager.delete_profile(self.profiles_info,profile)
425
426        #def delete_profile     
427
428        def sync_profile_clicked(self,button,hbox):
429
430                self.msg_label.set_text("")
431                self.sync_profile_t=threading.Thread(target=self.sync_profile,args=(hbox,))
432                self.sync_profile_t.daemon=True
433                GObject.threads_init()
434               
435                self.sync_profile_t.start()
436                self.core.lgd.check_plabel.set_text(_("Applying changes..."))
437                self.core.lgd.check_window.show()
438                GLib.timeout_add(100,self.pulsate_sync_profile,button,hbox)
439
440       
441        #def sync_profile_cicked
442
443        def pulsate_sync_profile(self,button,hbox):
444
445                if self.sync_profile_t.is_alive():
446                        self.core.lgd.check_pbar.pulse()
447                        return True
448
449                else:
450                        self.core.lgd.check_window.hide()
451                        if self.status_mod["result"]:
452                                msg_text=self.get_msg(self.status_mod["code"])
453                                self.msg_label.set_name("MSG_LABEL")
454                                self.msg_label.set_text(msg_text)
455                               
456                        else:
457                                msg_text=self.get_msg(self.status_mod["code"])
458                                self.msg_label.set_name("MSG_ERROR_LABEL")
459                                self.msg_label.set_text(msg_text)       
460                       
461
462                        info=self.item_status_info(self.status_info['status'])
463                        profile=hbox.get_children()[1].get_text().split("\n")[0]
464                        self.current_status[profile.decode("utf-8")]=self.status_info["status"]
465                        button.set_tooltip_text(info["tooltip"])
466                        button.set_name(info["css"])           
467                        hbox.get_children()[4].set_image(info["img"])   
468
469                return False                                   
470
471        #def pulsate_sync_profile       
472
473        def sync_profile(self,hbox):
474       
475                profile=hbox.get_children()[1].get_text().split("\n")[0]
476                mountpoint=hbox.get_children()[3].get_text()
477                # ENCODING TO UNICODE           
478                profile=profile.decode("utf-8")
479                mountpoint=mountpoint.decode("utf-8")
480                connect=True
481                current_status=self.current_status[profile]
482                self.status_mod,self.status_info=self.core.LliurexGoogleDriveManager.sync_profile(profile,mountpoint,current_status)
483               
484        #def sync_profile       
485
486        def edit_profile_clicked(self,button,hbox):
487
488                self.edition=True
489                self.read=False
490                self.core.lgd.check_plabel.set_text(_("Checking connection to google..."))
491                self.core.lgd.check_window.show()
492                self.init_threads()
493                self.check_connection_t.start()
494                GLib.timeout_add(100,self.pulsate_edit_connection,hbox)
495
496               
497        #def edit_profile_clicked
498
499        def pulsate_edit_connection(self,hbox):
500
501                if self.check_connection_t.is_alive():
502                                #self.disable_entry_profile_dialog()
503                                self.core.lgd.check_pbar.pulse()
504                                return True
505
506                else:
507                        self.core.lgd.check_window.hide()
508                        self.enable_entry_profile_dialog()
509                        #ENCODING TO UNICODE
510                        if self.connection:
511                                self.stack.set_visible_child_name("edit")
512
513                                self.profile_to_edit=hbox               
514                                self.profile=self.profile_to_edit.get_children()[1].get_text().split("\n")[0]
515                                self.profile_entry.set_text(self.profile)
516                                email=self.profile_to_edit.get_children()[1].get_text().split("\n")[1]
517                                self.email_entry.set_text(email)
518                                mountpoint=self.profile_to_edit.get_children()[3].get_text()
519                                self.mountpoint_entry.set_filename(mountpoint)
520                                automount=self.profiles_info[self.profile.decode("utf-8")]["automount"]
521                                self.automount_entry.set_active(automount)
522
523                                try:
524                                        self.root_folder=self.profiles_info[self.profile.decode("utf-8")]["root_folder"]
525                                except Exception as e:
526                                        self.root_folder=False
527
528                                if self.root_folder:
529                                        self.gdrive_folder_label.show()
530                                        self.gdrive_folder_entry.show()
531                                        self.gdrive_folder_entry.set_text(self.profiles_info[self.profile.decode("utf-8")]["gdrive_folder"])
532                                        #self.gdrive_folder=self.gdrive_folder_entry.get_text()
533                                        self.edit_gdrive_folder_button.show()
534                                        self.edit_gdrive_folder_button.set_sensitive(True)
535                                else:
536                                        self.gdrive_folder_label.hide()
537                                        self.gdrive_folder_entry.set_text("")
538                                        #self.gdrive_folder=self.gdrive_folder_entry.get_text()
539                                        self.gdrive_folder_entry.hide()
540                                        self.edit_gdrive_folder_button.hide()   
541
542                                self.root_folder_param_entry.set_active(self.root_folder)       
543
544                                self.init_threads()
545
546                                self.profile_msg.hide()
547                                self.profile_pbar.hide()
548                                self.msg_label.set_text("")
549                                self.init_profile_dialog_button()
550                                self.new_profile_window.show()
551
552                        else:           
553                                msg_text=self.get_msg(8)
554                                self.msg_label.set_name("MSG_ERROR_LABEL")
555                                self.msg_label.set_text(msg_text)               
556                return False
557
558        #def pulsate_edit_connection   
559
560
561        def check_connection(self):
562                self.connection=self.core.LliurexGoogleDriveManager.check_google_connection()
563
564        #def check_connection   
565
566        def new_profile_button(self,profile_name,email,mountpoint):
567               
568                hbox=Gtk.HBox()
569                profile_image=Gtk.Image.new_from_file(PROFILE_IMAGE)
570                profile_image.set_margin_left(10)
571                profile_image.set_halign(Gtk.Align.CENTER)
572                profile_image.set_valign(Gtk.Align.CENTER)
573                profile_info="<span font='Roboto'><b>"+profile_name+"</b></span>\n"+"<span font='Roboto'>"+email+"</span>"
574                profile=Gtk.Label()
575                profile.set_markup(profile_info)
576                profile.set_margin_left(10)
577                profile.set_margin_right(15)
578                profile.set_margin_top(21)
579                profile.set_margin_bottom(21)
580                profile.set_width_chars(25)
581                profile.set_max_width_chars(25)
582                profile.set_xalign(-1)
583                profile.set_ellipsize(Pango.EllipsizeMode.END)
584                folder_image=Gtk.Image.new_from_file(FOLDER_IMAGE)
585                folder_image.set_margin_left(20)
586                folder_image.set_halign(Gtk.Align.CENTER)
587                folder_image.set_valign(Gtk.Align.CENTER)
588                folder=Gtk.Label()
589                folder.set_text(mountpoint)
590                folder.set_margin_left(10)
591                delete=Gtk.Button()
592                delete_image=Gtk.Image.new_from_file(DELETE_IMAGE)
593                delete.add(delete_image)
594                delete.set_halign(Gtk.Align.CENTER)
595                delete.set_valign(Gtk.Align.CENTER)
596                delete.set_name("DELETE_ITEM_BUTTON")
597                delete.connect("clicked",self.delete_profile_clicked,hbox)
598                delete.set_tooltip_text(_("Delete profile"))
599                edit=Gtk.Button()
600                edit_image=Gtk.Image.new_from_file(EDIT_IMAGE)
601                edit.add(edit_image)
602                edit.set_halign(Gtk.Align.CENTER)
603                edit.set_valign(Gtk.Align.CENTER)
604                edit.set_name("EDIT_ITEM_BUTTON")
605                edit.connect("clicked",self.edit_profile_clicked,hbox)
606                edit.set_tooltip_text(_("Edit profile"))
607                mount=Gtk.Button()
608               
609                if self.initial_connection:
610                        status_info=self.core.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
611                        self.current_status[profile_name]=status_info["status"]
612                        info=self.item_status_info(status_info["status"])
613                else:
614                        info=self.item_status_info(None)
615                        self.current_status[profile_name]=None
616                       
617               
618                mount_image=info["img"]
619                mount.set_tooltip_text(info["tooltip"])
620                mount.set_name(info["css"])
621                mount.add(mount_image)
622                mount.set_halign(Gtk.Align.CENTER)
623                mount.set_valign(Gtk.Align.CENTER)
624                mount.connect("clicked",self.sync_profile_clicked,hbox)
625               
626                hbox.pack_start(profile_image,False,False,0)
627                hbox.pack_start(profile,False,False,0)
628                hbox.pack_start(folder_image,False,False,0)
629                hbox.pack_start(folder,False,False,0)
630                hbox.pack_end(delete,False,False,10)
631                hbox.pack_end(edit,False,False,10)
632                hbox.pack_end(mount,False,False,10)
633                hbox.show_all()
634                hbox.set_name("PROFILE_BOX")
635                self.profile_list_box.pack_start(hbox,False,False,5)
636                self.profile_list_box.queue_draw()
637                hbox.queue_draw()
638               
639        #def new_profile_button
640
641        def item_status_info(self,status_info):
642       
643               
644
645                if status_info==None:
646                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
647                        css="WARNING_ITEM_BUTTON"
648                        tooltip=_("Without connection. Clicked to update")
649                        css="WARNING_ITEM_BUTTON"                       
650                elif status_info:
651                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
652                        tooltip=_("Mounted. Clicked to dismount now")
653                        css="MOUNT_ITEM_BUTTON"
654                else:
655                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
656                        tooltip=_("Dismounted. Clicked to mount now")
657                        css="DELETE_ITEM_BUTTON"       
658
659                return {"img":img ,"tooltip":tooltip, "css":css}       
660
661        #def item_status_info                   
662
663        def accept_add_profile_clicked(self,widget):
664
665                self.disable_entry_profile_dialog()
666                self.accept_add_profile_button.hide()
667                self.cancel_add_profile_button.hide()
668                #ENCODING TO UNICODE
669                profile=self.profile_entry.get_text()
670
671                self.new_profile=profile.strip().decode("utf-8")
672                email=self.email_entry.get_text()
673                self.new_email=email.strip()
674                self.new_mountpoint=self.mountpoint_entry.get_filename().decode("utf-8")
675                self.new_automount=self.automount_entry.get_state()
676               
677
678                if not self.edition:
679                        self.new_root_folder=False
680                        self.new_gdrive_folder=""
681                else:
682                        self.new_root_folder=self.root_folder_param_entry.get_state()
683                        if self.new_root_folder:
684                                        try:
685                                                self.new_gdrive_folder=self.gdrive_folder_entry.get_text().decode("utf-8")
686                                        except Exception as e:
687                                                print str(e)
688                                                self.new_gdrive_folder=""       
689                        else:
690                                self.new_gdrive_folder=""       
691         
692                self.profile_msg.show()
693                self.profile_msg.set_name("MSG_LABEL")
694                self.profile_pbar.show()
695                self.init_threads()
696                if not self.check_form_t.launched:
697                        self.profile_msg.set_text(_("Validating entered data..."))
698                        GLib.timeout_add(100,self.pulsate_check_form)
699
700        #def accept_add_profile_clicked         
701
702
703        def pulsate_check_form(self):
704
705                self.profile_pbar.pulse()
706               
707                if not self.check_form_t.launched:
708                        self.check_form_t.start()
709                        self.check_form_t.launched=True
710
711
712                if self.check_form_t.done:
713
714                        if self.check_form_result['result']:
715                                self.profiles_info[self.new_profile]={}
716                                self.profiles_info[self.new_profile]["email"]=self.new_email
717                                self.profiles_info[self.new_profile]["mountpoint"]=self.new_mountpoint
718                                self.profiles_info[self.new_profile]["automount"]=self.new_automount
719                                self.profiles_info[self.new_profile]["root_folder"]=self.new_root_folder
720                                self.profiles_info[self.new_profile]["gdrive_folder"]=self.new_gdrive_folder
721                       
722                                self.profile_msg.set_name("MSG_LABEL")
723                                if not self.edition:
724                                        if not self.create_profile_t.launched:
725                                                self.profile_msg.set_text(_("Connecting with google to get account access..."))
726                                                self.profile_pbar.show()
727                                                self.retry=0
728                                                GLib.timeout_add(100,self.pulsate_add_profile)
729                                       
730                       
731                                else:
732                                                               
733                                        if not self.edit_profile_t.launched:
734                                                self.profile_msg.set_text(_("Applying changes..."))
735                                                self.profile_pbar.show()
736                                                GLib.timeout_add(100,self.pulsate_edit_profile) 
737                        else:
738                                self.profile_pbar.hide()
739                                self.profile_msg.set_name("MSG_ERROR_LABEL")
740                                #self.profile_msg.set_text(check_form["msg"])
741                                self.profile_msg.set_text(self.get_msg(self.check_form_result["code"]))
742                                self.enable_entry_profile_dialog()
743                                self.init_profile_dialog_button()
744                                return False
745
746                if self.check_form_t.launched:
747                        if not self.check_form_t.done:
748                                return True             
749
750        #def check_form                 
751
752        def check_form(self):                   
753
754                self.check_form_result=self.core.LliurexGoogleDriveManager.check_profile_info(self.new_profile,self.new_mountpoint,self.edition,self.new_root_folder,self.new_gdrive_folder)
755                self.check_form_t.done=True
756                #self.profile_msg.show()
757
758       
759        #def check_form
760
761        def check_mountpoint_folder(self,widget):
762
763       
764                self.disable_entry_profile_dialog()
765                #ENCODING TO UNICODE
766                profile=self.profile_entry.get_text()
767
768                new_profile=profile.strip().decode("utf-8")
769                new_mountpoint=self.mountpoint_entry.get_filename().decode("utf-8")
770                               
771                check_form=self.core.LliurexGoogleDriveManager.check_mountpoint_folder(new_profile,new_mountpoint,self.edition)
772               
773                if not check_form["result"]:
774                        self.profile_msg.show()
775                        self.profile_msg.set_name("MSG_ERROR_LABEL")
776                        self.profile_msg.set_text(self.get_msg(check_form["code"]))
777                       
778                else:
779                        self.profile_msg.hide() 
780
781                self.enable_entry_profile_dialog()     
782
783        #def check_mountpoint_folder   
784
785        '''     
786        def check_profile_info(self):
787
788                msg_check=""
789
790                check_form=self.core.LliurexGoogleDriveManager.check_profile_info(self.new_profile,self.new_mountpoint,self.edition)
791
792               
793                if not check_form["result"]:
794                        if check_form["code"]==1:
795                                msg_check=_("You must indicate a profile")
796
797                        elif check_form["code"]==2:
798                                msg_check=_("Profile can not contain blanks")
799
800                        elif check_form["code"]==3 :
801                                msg_check=_("Profile already exists")
802                       
803                        elif check_form["code"]==4:
804                                msg_check=_("Mount point already used by another profile")     
805
806                        elif check_form["code"]==5:
807                                msg_check=_("The mount point must be an empty folder") 
808
809                        elif check_form["code"]==6:
810                                msg_check=_("Mount point is not owned by user")
811
812
813                return {"result":check_form["result"],"msg":msg_check}
814
815        #def check_profile_info
816
817        '''     
818
819        def pulsate_add_profile(self):
820
821                self.retry=self.retry+1
822                self.profile_pbar.pulse()
823               
824                if not self.create_profile_t.launched:
825                        #self.accept_add_profile_button.hide()
826                        #self.cancel_add_profile_button.hide()
827               
828                        self.create_profile_t.start()
829                        self.create_profile_t.launched=True
830
831                if not self.create_profile_t.is_alive():
832                        if not self.create_mountpoint_t.launched:
833                                self.profile_msg.set_name("MSG_LABEL")
834                                self.profile_msg.set_text(_("Creating profile... "))
835                                self.create_mountpoint_t.start()
836                                self.create_mountpoint_t.launched=True
837
838                        if self.create_mountpoint_t.done:
839                                self.profile_pbar.hide()
840                                if self.create_result["result"]:
841                                                self.initial_connection=True
842                                                self.new_profile_button(self.new_profile,self.new_email,self.new_mountpoint)
843                                                self.profile_msg.set_text(_("Profile created successfully"))
844                                                self.change_cancel_button()
845                                               
846                                else:
847                                        msg_text=self.get_msg(self.create_result["code"])
848                                        self.profile_msg.set_name("MSG_ERROR_LABEL")
849                                        self.profile_msg.set_text(msg_text)
850                                        self.cancel_add_profile_button.show()
851                                       
852                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
853                                return False   
854                                               
855                if self.create_profile_t.launched:
856                        if self.create_profile_t.is_alive():
857                                self.kill_create_profile()
858                                return True     
859                               
860
861                if self.create_mountpoint_t.launched:
862                        if not self.create_mountpoint_t.done:
863                                return True             
864
865        #def_pulsate_add_profile       
866
867
868        def get_msg(self,code):
869
870                if      code==0:
871                        msg_text=_("Changes applied successfully")
872               
873                elif code==1:
874                        msg_text=_("Error: Unable to create mount point")
875
876                elif code==2:
877                        msg_text=_("Error: Unable to mount mount point")
878
879                elif code==3:
880                        msg_text=_("Error: Mount point is not owned by user")   
881
882                elif code==4:
883                        msg_text=_("Error: No mount point indicated")
884
885                elif code==5:
886                        msg_text=_("Error: Profile is not authorized to Google Drive")
887
888                elif code==6:
889                        msg_text=_("Error: Unknow profile")
890
891                elif code==7:
892                        msg_text=_("Error: Unable to dismount mount point")
893
894                elif code==8:
895                        msg_text=_("Error: Unable to connect with google")     
896                       
897                elif code==9:
898                        msg_text=_("Status updated. Now you can change it")
899
900                elif code==10:
901                        msg_text=_("You must indicate a profile")
902
903                elif code==11:
904                        msg_text=_("Profile can not contain blanks")
905
906                elif code==12:
907                        msg_text=_("Profile already exists")
908                       
909                elif code==13:
910                        msg_text=_("Mount point already used by another profile")       
911
912                elif code==14:
913                        msg_text=_("The mount point must be an empty folder")   
914
915                elif code==15:
916                        msg_text=_("Mount point is not owned by user")         
917
918                elif code==16:
919                        msg_text=_("Path of mount point can not contain blanks")
920                       
921                elif code==17:
922                        msg_text=_("Error: You must specify a GDrive folder or disable the option")     
923
924                elif code==18:
925                        msg_text=_("Error: Unable to mount mount point. The synced GDrive folder maybe not be correct") 
926
927                elif code==19:
928                        msg_text=_("Error: Synced Gdrive folder no longer exists")
929               
930                elif code==20:
931                        msg_text=_("Error: No folders found in Gdrive profile. You must disable the option")
932
933                elif code==21:
934                        msg_text=_("Error: To add a profile it is required that Chromium is not the default browser")           
935
936                               
937                return msg_text         
938               
939
940        #def get_msg                                                   
941
942        def kill_create_profile(self):
943       
944                if self.retry>MAX_RETRY_INTENTS:
945                        parent=psutil.Process(self.create_profile_t.pid)
946                        for child in parent.children(recursive=True):
947                                child.kill()
948                                self.create_profile_t.terminate()
949                                self.core.LliurexGoogleDriveManager.remove_chromium_tmpbin()           
950                                self.profile_msg.set_name("MSG_ERROR_LABEL")
951                                self.profile_msg.set_text(_("Error getting authorization"))
952
953                return True     
954
955        #def kill_create_profile       
956
957        def create_profile(self):
958
959                result=self.core.LliurexGoogleDriveManager.create_profile(self.new_profile)
960
961        #def create_profile     
962
963        def create_mountpoint(self):
964
965                self.create_result=self.core.LliurexGoogleDriveManager.create_mountpoint(self.profiles_info,self.new_profile)
966                self.create_mountpoint_t.done=True
967               
968        #def create_mountpoint 
969
970        def pulsate_edit_profile(self):
971
972                self.profile_pbar.pulse()
973
974                if not self.edit_profile_t.launched:
975                       
976                        #self.accept_add_profile_button.hide()
977                        #self.cancel_add_profile_button.hide()
978                        self.edit_profile_t.start()
979                        self.edit_profile_t.launched=True
980
981                if self.edit_profile_t.done:
982                        self.profile_pbar.hide()
983                        if self.edit_result["result"]:
984                                self.profile_msg.set_name("MSG_LABEL")
985                                self.profile_to_edit.get_children()[3].set_text(self.new_mountpoint)
986                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
987                                self.change_cancel_button()
988                       
989                        else:
990                               
991                                self.profile_msg.set_name("MSG_ERROR_LABEL")
992                                self.cancel_add_profile_button.show()
993
994                        msg_text=self.get_msg(self.edit_result["code"])
995                        self.profile_msg.set_text(msg_text)
996
997                        return False
998                       
999
1000                if self.edit_profile_t.launched:
1001                        if not self.edit_profile_t.done:
1002                                return True
1003
1004        #def pulsate_edit_profile                       
1005
1006        def edit_profile(self):
1007
1008                self.edit_result=self.core.LliurexGoogleDriveManager.edit_profile(self.profiles_info,self.new_profile)
1009                self.edit_profile_t.done=True
1010
1011        #def edit_profile       
1012
1013        def cancel_add_profile_clicked(self,widget):
1014               
1015                self.core.LliurexGoogleDriveManager.remove_chromium_tmpbin()           
1016                self.new_profile_window.hide()
1017       
1018        #def cancel_add_profile_clicked
1019
1020       
1021        def root_folder_clicked(self,widget,event):
1022
1023                if self.root_folder_param_entry.get_active():
1024                        if not self.root_folder:
1025       
1026                                self.init_read_mountpoint_dialog()     
1027                       
1028                else:
1029                        self.root_folder=False
1030                        self.gdrive_folder_label.hide()
1031                        self.gdrive_folder_entry.hide()
1032                        #self.gdrive_folder_entry.set_text("")
1033                        self.edit_gdrive_folder_button.hide()   
1034
1035        #def root_folder_clicked               
1036
1037
1038        def init_read_mountpoint_dialog(self):
1039
1040                if not self.read:
1041
1042                        if not self.read_mountpoint_t.launched:
1043                                self.disable_entry_profile_dialog()
1044                                self.profile_msg.set_name("MSG_LABEL")
1045                                self.profile_msg.show()
1046                                self.profile_msg.set_text(_("Getting folders from Google Drive profile ..."))
1047                                self.profile_pbar.show()
1048                                GLib.timeout_add(100,self.pulsate_read_mountpoint)     
1049
1050                else:
1051                        if len(self.syncfolders_model)>1:
1052                                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
1053                                self.stack.set_visible_child_name("folder")     
1054                                self.gdrive_combobox.set_active(0)
1055
1056        #def init_read_mountpoint_dialog               
1057
1058
1059        def pulsate_read_mountpoint(self):
1060
1061                self.profile_pbar.pulse()
1062
1063                if not self.read_mountpoint_t.launched:
1064                        self.read_mountpoint_t.start()
1065                        self.read_mountpoint_t.launched=True
1066                        self.accept_add_profile_button.hide()
1067                        self.cancel_add_profile_button.hide()
1068
1069                if self.read_mountpoint_t.done:
1070                        self.root_folder=False
1071                        self.enable_entry_profile_dialog()
1072                        self.profile_pbar.hide()
1073                        self.profile_msg.hide()
1074               
1075                        if len(self.syncfolders_model)>1:
1076                                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
1077
1078                                self.stack.set_visible_child_name("folder")
1079                                self.accept_add_profile_button.hide()
1080                                self.cancel_add_profile_button.hide()
1081                        else:
1082                                self.profile_msg.show()
1083                                self.profile_msg.set_name("MSG_ERROR_LABEL")
1084                                self.profile_msg.set_text(_("No folders detected on google drive profile"))     
1085                                self.accept_add_profile_button.show()
1086                                self.cancel_add_profile_button.show()
1087                       
1088                        return False
1089                       
1090
1091                if self.read_mountpoint_t.launched:
1092                        if not self.read_mountpoint_t.done:
1093                                return True
1094
1095        #def pulsate_read_mountpoint   
1096
1097        def read_mountpoint(self):
1098
1099
1100                folders=self.core.LliurexGoogleDriveManager.read_mountpoint_directory(self.profile)
1101               
1102                self.syncfolders_model.clear()
1103
1104                if len(folders)>0:
1105                       
1106                        for item in folders:
1107                                self.syncfolders_model.append([item])
1108
1109                                                               
1110                self.read=True                 
1111
1112                self.read_mountpoint_t.done=True       
1113
1114        #def read_mountpoint
1115       
1116        def edit_gdrive_folder_button_clicked(self,widget):
1117
1118
1119                self.init_threads()
1120                self.profile_msg.hide()
1121                self.profile_msg.set_text("")
1122                self.init_read_mountpoint_dialog()
1123
1124                       
1125
1126        #def edit_gdrive_folder_button_clicked 
1127       
1128
1129        def return_combobox_button_clicked(self,widget):
1130
1131               
1132                #self.gdrive_folder_entry.set_text(self.folder)
1133                #self.gdrive_folder=folder
1134
1135               
1136                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
1137                self.stack.set_visible_child_name("edit")       
1138                self.accept_add_profile_button.show()
1139                self.cancel_add_profile_button.show()
1140               
1141                self.gdrive_folder_label.show()
1142                self.gdrive_folder_entry.show()
1143                self.edit_gdrive_folder_button.set_sensitive(True)     
1144
1145        #def return_combobox_button_clicked     
1146
1147        def on_gdrive_combobox_changed (self,combo):
1148
1149
1150               
1151                tree_iter=combo.get_active_iter()
1152
1153               
1154                if tree_iter != None:
1155                        model = combo.get_model()
1156                        folder = model[tree_iter][0]
1157                        self.gdrive_folder_entry.set_text(folder)
1158
1159
1160        #def on_gdrive_combobox_changeg         
1161
1162       
1163
1164
1165
1166#class profilebox
1167
1168
1169       
1170               
Note: See TracBrowser for help on using the repository browser.