source: lliurex-gdrive/trunk/WIP_files/ProfileBox.py @ 5889

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

Fix files

File size: 32.3 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                                print "ACTIVANDO"
278                                print self.root_folder
279                                self.edit_gdrive_folder_button.show()
280                                self.edit_gdrive_folder_button.set_sensitive(True)
281                        else:
282                                print "#########3"
283                                print self.read
284                                if self.read:
285                                        self.edit_gdrive_folder_button.show()   
286                                        self.edit_gdrive_folder_button.set_sensitive(True)
287                       
288                self.mountpoint_entry.set_sensitive(True)
289                self.automount_entry.set_sensitive(True)       
290
291        #def enable_entry_profile_dialog       
292
293        def change_cancel_button(self):
294               
295                image = Gtk.Image()
296                image.set_from_stock(Gtk.STOCK_CLOSE,Gtk.IconSize.MENU)
297                self.cancel_add_profile_button.set_image(image)
298                self.cancel_add_profile_button.set_label(_("Close"))   
299                self.cancel_add_profile_button.show()   
300
301        #def change_cancel_button       
302
303        def add_new_profile_button_clicked(self,widget):
304
305                self.edition=False
306                self.core.lgd.check_plabel.set_text(_("Checking connection to google..."))
307                self.core.lgd.check_window.show()
308                self.init_threads()
309                self.check_connection_t.start()
310                GLib.timeout_add(100,self.pulsate_add_connection)
311
312        #def add_new_profile_button_clicked     
313       
314        def pulsate_add_connection(self):
315               
316                if self.check_connection_t.is_alive():
317                                self.core.lgd.check_pbar.pulse()
318                                return True
319
320                else:
321                        self.core.lgd.check_window.hide()
322                        self.enable_entry_profile_dialog()
323                        #ENCODING TO UNICODE
324                        if self.connection:
325                                self.profile_entry.set_text("")
326                                self.email_entry.set_text("")
327                                self.mountpoint_entry.set_filename(os.environ["HOME"])
328                                self.automount_entry.set_active(False)
329                                self.profile_msg.set_text("")
330               
331
332                                self.init_threads()
333                               
334                                self.msg_label.set_text("")
335                                self.profile_msg.hide()
336                                self.profile_pbar.hide()
337                                self.init_profile_dialog_button()
338                                self.new_profile_window.show()
339                               
340                        else:           
341                                msg_error=self.get_msg(8)
342                                self.msg_label.set_name("MSG_ERROR_LABEL")
343                                self.msg_label.set_text(msg_error)             
344               
345                return False   
346               
347
348        #def add_new_profile_button_clicked     
349
350        def delete_profile_clicked(self,button,hbox):
351
352                dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO, "Lliurex GDrive")
353                dialog.format_secondary_text(_("Do you want delete the profile?"))
354                response=dialog.run()
355                dialog.destroy()
356               
357
358                if response==Gtk.ResponseType.YES:
359                        profile=hbox.get_children()[1].get_text().split("\n")[0]
360                        #ENCODING TO UNICODE                   
361                        profile=profile.decode("utf-8")
362                        self.delete_profile_t=threading.Thread(target=self.delete_profile,args=(profile,))
363                        self.delete_profile_t.daemon=True
364                        GObject.threads_init()
365
366                        self.msg_label.set_text("")
367                       
368                        self.profiles_info.pop(profile)
369                        self.delete_profile_t.start()
370                        self.delete_profile_t.launched=True
371                        self.core.lgd.check_plabel.set_text(_("Applying changes..."))
372                        self.core.lgd.check_window.show()
373                        GLib.timeout_add(100,self.pulsate_delete_profile,profile,hbox)
374
375        # def delete_profile_clicked
376               
377        def pulsate_delete_profile(self,profile,hbox):
378
379                        if self.delete_profile_t.is_alive():
380                                self.core.lgd.check_pbar.pulse()
381                                return True
382
383                        else:
384                                self.msg_label.show()
385                                self.core.lgd.check_window.hide()
386                                if self.delete["result"]:
387                                        self.msg_label.set_name("MSG_LABEL")
388                                        self.profile_list_box.remove(hbox)
389                                else:
390                                        self.msg_label.set_name("MSG_ERROR_LABEL")
391                               
392                                msg_text=self.get_msg(self.delete["code"])
393                                self.msg_label.set_text(msg_text)
394                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()
395                               
396                        return False   
397
398        #def pulsate_delete_profile             
399
400       
401        def delete_profile(self,profile):
402
403                self.delete=self.core.LliurexGoogleDriveManager.delete_profile(self.profiles_info,profile)
404
405        #def delete_profile     
406
407        def sync_profile_clicked(self,button,hbox):
408
409                self.msg_label.set_text("")
410                self.sync_profile_t=threading.Thread(target=self.sync_profile,args=(hbox,))
411                self.sync_profile_t.daemon=True
412                GObject.threads_init()
413               
414                self.sync_profile_t.start()
415                self.core.lgd.check_plabel.set_text(_("Applying changes..."))
416                self.core.lgd.check_window.show()
417                GLib.timeout_add(100,self.pulsate_sync_profile,button,hbox)
418
419       
420        #def sync_profile_cicked
421
422        def pulsate_sync_profile(self,button,hbox):
423
424                if self.sync_profile_t.is_alive():
425                        self.core.lgd.check_pbar.pulse()
426                        return True
427
428                else:
429                        self.core.lgd.check_window.hide()
430                        if self.status_mod["result"]:
431                                msg_text=self.get_msg(self.status_mod["code"])
432                                self.msg_label.set_name("MSG_LABEL")
433                                self.msg_label.set_text(msg_text)
434                               
435                        else:
436                                msg_text=self.get_msg(self.status_mod["code"])
437                                self.msg_label.set_name("MSG_ERROR_LABEL")
438                                self.msg_label.set_text(msg_text)       
439                       
440
441                        info=self.item_status_info(self.status_info['status'])
442                        profile=hbox.get_children()[1].get_text().split("\n")[0]
443                        self.current_status[profile.decode("utf-8")]=self.status_info["status"]
444                        button.set_tooltip_text(info["tooltip"])
445                        button.set_name(info["css"])           
446                        hbox.get_children()[4].set_image(info["img"])   
447
448                return False                                   
449
450        #def pulsate_sync_profile       
451
452        def sync_profile(self,hbox):
453       
454                profile=hbox.get_children()[1].get_text().split("\n")[0]
455                mountpoint=hbox.get_children()[3].get_text()
456                # ENCODING TO UNICODE           
457                profile=profile.decode("utf-8")
458                mountpoint=mountpoint.decode("utf-8")
459                connect=True
460                current_status=self.current_status[profile]
461                self.status_mod,self.status_info=self.core.LliurexGoogleDriveManager.sync_profile(profile,mountpoint,current_status)
462               
463        #def sync_profile       
464
465        def edit_profile_clicked(self,button,hbox):
466
467                self.edition=True
468                self.read=False
469                self.core.lgd.check_plabel.set_text(_("Checking connection to google..."))
470                self.core.lgd.check_window.show()
471                self.init_threads()
472                self.check_connection_t.start()
473                GLib.timeout_add(100,self.pulsate_edit_connection,hbox)
474
475               
476        #def edit_profile_clicked
477
478        def pulsate_edit_connection(self,hbox):
479
480                if self.check_connection_t.is_alive():
481                                #self.disable_entry_profile_dialog()
482                                self.core.lgd.check_pbar.pulse()
483                                return True
484
485                else:
486                        self.core.lgd.check_window.hide()
487                        self.enable_entry_profile_dialog()
488                        #ENCODING TO UNICODE
489                        if self.connection:
490                                self.stack.set_visible_child_name("edit")
491
492                                self.profile_to_edit=hbox               
493                                self.profile=self.profile_to_edit.get_children()[1].get_text().split("\n")[0]
494                                self.profile_entry.set_text(self.profile)
495                                email=self.profile_to_edit.get_children()[1].get_text().split("\n")[1]
496                                self.email_entry.set_text(email)
497                                mountpoint=self.profile_to_edit.get_children()[3].get_text()
498                                self.mountpoint_entry.set_filename(mountpoint)
499                                automount=self.profiles_info[self.profile.decode("utf-8")]["automount"]
500                                self.automount_entry.set_active(automount)
501
502                                try:
503                                        self.root_folder=self.profiles_info[self.profile.decode("utf-8")]["root_folder"]
504                                except Exception as e:
505                                        self.root_folder=False
506
507                                if self.root_folder:
508                                        self.gdrive_folder_label.show()
509                                        self.gdrive_folder_entry.show()
510                                        self.gdrive_folder_entry.set_text(self.profiles_info[self.profile.decode("utf-8")]["gdrive_folder"])
511                                        #self.gdrive_folder=self.gdrive_folder_entry.get_text()
512                                        self.edit_gdrive_folder_button.show()
513                                        self.edit_gdrive_folder_button.set_sensitive(True)
514                                else:
515                                        self.gdrive_folder_label.hide()
516                                        self.gdrive_folder_entry.set_text("")
517                                        #self.gdrive_folder=self.gdrive_folder_entry.get_text()
518                                        self.gdrive_folder_entry.hide()
519                                        self.edit_gdrive_folder_button.hide()   
520
521                                self.root_folder_param_entry.set_active(self.root_folder)       
522
523                                self.init_threads()
524
525                                self.profile_msg.hide()
526                                self.profile_pbar.hide()
527                                self.msg_label.set_text("")
528                                self.init_profile_dialog_button()
529                                self.new_profile_window.show()
530
531                        else:           
532                                msg_text=self.get_msg(8)
533                                self.msg_label.set_name("MSG_ERROR_LABEL")
534                                self.msg_label.set_text(msg_text)               
535                return False
536
537        #def pulsate_edit_connection   
538
539
540        def check_connection(self):
541                self.connection=self.core.LliurexGoogleDriveManager.check_google_connection()
542
543        #def check_connection   
544
545        def new_profile_button(self,profile_name,email,mountpoint):
546               
547                hbox=Gtk.HBox()
548                profile_image=Gtk.Image.new_from_file(PROFILE_IMAGE)
549                profile_image.set_margin_left(10)
550                profile_image.set_halign(Gtk.Align.CENTER)
551                profile_image.set_valign(Gtk.Align.CENTER)
552                profile_info="<span font='Roboto'><b>"+profile_name+"</b></span>\n"+"<span font='Roboto'>"+email+"</span>"
553                profile=Gtk.Label()
554                profile.set_markup(profile_info)
555                profile.set_margin_left(10)
556                profile.set_margin_right(15)
557                profile.set_margin_top(21)
558                profile.set_margin_bottom(21)
559                profile.set_width_chars(25)
560                profile.set_max_width_chars(25)
561                profile.set_xalign(-1)
562                profile.set_ellipsize(Pango.EllipsizeMode.END)
563                folder_image=Gtk.Image.new_from_file(FOLDER_IMAGE)
564                folder_image.set_margin_left(20)
565                folder_image.set_halign(Gtk.Align.CENTER)
566                folder_image.set_valign(Gtk.Align.CENTER)
567                folder=Gtk.Label()
568                folder.set_text(mountpoint)
569                folder.set_margin_left(10)
570                delete=Gtk.Button()
571                delete_image=Gtk.Image.new_from_file(DELETE_IMAGE)
572                delete.add(delete_image)
573                delete.set_halign(Gtk.Align.CENTER)
574                delete.set_valign(Gtk.Align.CENTER)
575                delete.set_name("DELETE_ITEM_BUTTON")
576                delete.connect("clicked",self.delete_profile_clicked,hbox)
577                delete.set_tooltip_text(_("Delete profile"))
578                edit=Gtk.Button()
579                edit_image=Gtk.Image.new_from_file(EDIT_IMAGE)
580                edit.add(edit_image)
581                edit.set_halign(Gtk.Align.CENTER)
582                edit.set_valign(Gtk.Align.CENTER)
583                edit.set_name("EDIT_ITEM_BUTTON")
584                edit.connect("clicked",self.edit_profile_clicked,hbox)
585                edit.set_tooltip_text(_("Edit profile"))
586                mount=Gtk.Button()
587               
588                if self.initial_connection:
589                        status_info=self.core.LliurexGoogleDriveManager.check_mountpoint_status(mountpoint)
590                        self.current_status[profile_name]=status_info["status"]
591                        info=self.item_status_info(status_info["status"])
592                else:
593                        info=self.item_status_info(None)
594                        self.current_status[profile_name]=None
595                       
596               
597                mount_image=info["img"]
598                mount.set_tooltip_text(info["tooltip"])
599                mount.set_name(info["css"])
600                mount.add(mount_image)
601                mount.set_halign(Gtk.Align.CENTER)
602                mount.set_valign(Gtk.Align.CENTER)
603                mount.connect("clicked",self.sync_profile_clicked,hbox)
604               
605                hbox.pack_start(profile_image,False,False,0)
606                hbox.pack_start(profile,False,False,0)
607                hbox.pack_start(folder_image,False,False,0)
608                hbox.pack_start(folder,False,False,0)
609                hbox.pack_end(delete,False,False,10)
610                hbox.pack_end(edit,False,False,10)
611                hbox.pack_end(mount,False,False,10)
612                hbox.show_all()
613                hbox.set_name("PROFILE_BOX")
614                self.profile_list_box.pack_start(hbox,False,False,5)
615                self.profile_list_box.queue_draw()
616                hbox.queue_draw()
617               
618        #def new_profile_button
619
620        def item_status_info(self,status_info):
621       
622               
623
624                if status_info==None:
625                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
626                        css="WARNING_ITEM_BUTTON"
627                        tooltip=_("Without connection. Clicked to update")
628                        css="WARNING_ITEM_BUTTON"                       
629                elif status_info:
630                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
631                        tooltip=_("Mounted. Clicked to dismount now")
632                        css="MOUNT_ITEM_BUTTON"
633                else:
634                        img=Gtk.Image.new_from_file(MOUNT_ON_IMAGE)
635                        tooltip=_("Dismounted. Clicked to mount now")
636                        css="DELETE_ITEM_BUTTON"       
637
638                return {"img":img ,"tooltip":tooltip, "css":css}       
639
640        #def item_status_info                   
641
642        def accept_add_profile_clicked(self,widget):
643
644                self.disable_entry_profile_dialog()
645                #ENCODING TO UNICODE
646                profile=self.profile_entry.get_text()
647
648                self.new_profile=profile.strip().decode("utf-8")
649                email=self.email_entry.get_text()
650                self.new_email=email.strip()
651                self.new_mountpoint=self.mountpoint_entry.get_filename().decode("utf-8")
652                self.new_automount=self.automount_entry.get_state()
653
654                if not self.edition:
655                        self.new_root_folder=False
656                        self.new_gdrive_folder=""
657                else:
658                        self.new_root_folder=self.root_folder_param_entry.get_state()
659                        if self.new_root_folder:
660                                        try:
661                                                self.new_gdrive_folder=self.gdrive_folder_entry.get_text().decode("utf-8")
662                                        except Exception as e:
663                                                print str(e)
664                                                self.new_gdrive_folder=""       
665                        else:
666                                self.new_gdrive_folder=""       
667         
668                self.profile_msg.show()
669                self.profile_msg.set_name("MSG_LABEL")
670                self.profile_pbar.show()
671                self.init_threads()
672                if not self.check_form_t.launched:
673                        self.profile_msg.set_text(_("Validating entered data..."))
674                        GLib.timeout_add(100,self.pulsate_check_form)
675
676
677        def pulsate_check_form(self):
678
679                self.profile_pbar.pulse()
680               
681                if not self.check_form_t.launched:
682                        self.check_form_t.start()
683                        self.check_form_t.launched=True
684
685
686                if self.check_form_t.done:
687
688                        if self.check_form_result['result']:
689                                self.profiles_info[self.new_profile]={}
690                                self.profiles_info[self.new_profile]["email"]=self.new_email
691                                self.profiles_info[self.new_profile]["mountpoint"]=self.new_mountpoint
692                                self.profiles_info[self.new_profile]["automount"]=self.new_automount
693                                self.profiles_info[self.new_profile]["root_folder"]=self.new_root_folder
694                                self.profiles_info[self.new_profile]["gdrive_folder"]=self.new_gdrive_folder
695                       
696                                self.profile_msg.set_name("MSG_LABEL")
697                                if not self.edition:
698                                        if not self.create_profile_t.launched:
699                                                self.profile_msg.set_text(_("Connecting with google to get account access..."))
700                                                self.profile_pbar.show()
701                                                self.retry=0
702                                                GLib.timeout_add(100,self.pulsate_add_profile)
703                                       
704                       
705                                else:
706                                                               
707                                        if not self.edit_profile_t.launched:
708                                                self.profile_msg.set_text(_("Applying changes..."))
709                                                self.profile_pbar.show()
710                                                GLib.timeout_add(100,self.pulsate_edit_profile) 
711                        else:
712                                self.profile_pbar.hide()
713                                self.profile_msg.set_name("MSG_ERROR_LABEL")
714                                #self.profile_msg.set_text(check_form["msg"])
715                                self.profile_msg.set_text(self.get_msg(self.check_form_result["code"]))
716                                self.enable_entry_profile_dialog()
717                                return False
718
719                if self.check_form_t.launched:
720                        if not self.check_form_t.done:
721                                return True             
722
723        def check_form(self):                   
724
725                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)
726                self.check_form_t.done=True
727                #self.profile_msg.show()
728
729       
730        #def accept_add_profile_clicked
731
732        def check_mountpoint_folder(self,widget):
733
734       
735                self.disable_entry_profile_dialog()
736                #ENCODING TO UNICODE
737                profile=self.profile_entry.get_text()
738
739                new_profile=profile.strip().decode("utf-8")
740                new_mountpoint=self.mountpoint_entry.get_filename().decode("utf-8")
741                               
742                check_form=self.core.LliurexGoogleDriveManager.check_mountpoint_folder(new_profile,new_mountpoint,self.edition)
743               
744                if not check_form["result"]:
745                        self.profile_msg.show()
746                        self.profile_msg.set_name("MSG_ERROR_LABEL")
747                        self.profile_msg.set_text(self.get_msg(check_form["code"]))
748                       
749                else:
750                        self.profile_msg.hide() 
751
752                self.enable_entry_profile_dialog()     
753
754        #def check_mountpoint_folder   
755
756        '''     
757        def check_profile_info(self):
758
759                msg_check=""
760
761                check_form=self.core.LliurexGoogleDriveManager.check_profile_info(self.new_profile,self.new_mountpoint,self.edition)
762
763               
764                if not check_form["result"]:
765                        if check_form["code"]==1:
766                                msg_check=_("You must indicate a profile")
767
768                        elif check_form["code"]==2:
769                                msg_check=_("Profile can not contain blanks")
770
771                        elif check_form["code"]==3 :
772                                msg_check=_("Profile already exists")
773                       
774                        elif check_form["code"]==4:
775                                msg_check=_("Mount point already used by another profile")     
776
777                        elif check_form["code"]==5:
778                                msg_check=_("The mount point must be an empty folder") 
779
780                        elif check_form["code"]==6:
781                                msg_check=_("Mount point is not owned by user")
782
783
784                return {"result":check_form["result"],"msg":msg_check}
785
786        #def check_profile_info
787
788        '''     
789
790        def pulsate_add_profile(self):
791
792                self.retry=self.retry+1
793                self.profile_pbar.pulse()
794               
795                if not self.create_profile_t.launched:
796                        self.accept_add_profile_button.hide()
797                        self.cancel_add_profile_button.hide()
798               
799                        self.create_profile_t.start()
800                        self.create_profile_t.launched=True
801
802                if not self.create_profile_t.is_alive():
803                        if not self.create_mountpoint_t.launched:
804                                self.profile_msg.set_name("MSG_LABEL")
805                                self.profile_msg.set_text(_("Creating profile... "))
806                                self.create_mountpoint_t.start()
807                                self.create_mountpoint_t.launched=True
808
809                        if self.create_mountpoint_t.done:
810                                self.profile_pbar.hide()
811                                if self.create_result["result"]:
812                                                self.initial_connection=True
813                                                self.new_profile_button(self.new_profile,self.new_email,self.new_mountpoint)
814                                                self.profile_msg.set_text(_("Profile created successfully"))
815                                                self.change_cancel_button()
816                                               
817                                else:
818                                        msg_text=self.get_msg(self.create_result["code"])
819                                        self.profile_msg.set_name("MSG_ERROR_LABEL")
820                                        self.profile_msg.set_text(msg_text)
821                                        self.cancel_add_profile_button.show()
822                                       
823                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
824                                return False   
825                                               
826                if self.create_profile_t.launched:
827                        if self.create_profile_t.is_alive():
828                                self.kill_create_profile()
829                                return True     
830                               
831
832                if self.create_mountpoint_t.launched:
833                        if not self.create_mountpoint_t.done:
834                                return True             
835
836        #def_pulsate_add_profile       
837
838
839        def get_msg(self,code):
840
841                if      code==0:
842                        msg_text=_("Changes applied successfully")
843               
844                elif code==1:
845                        msg_text=_("Error: Unable to create mount point")
846
847                elif code==2:
848                        msg_text=_("Error: Unable to mount mount point")
849
850                elif code==3:
851                        msg_text=_("Error: Mount point is not owned by user")   
852
853                elif code==4:
854                        msg_text=_("Error: No mount point indicated")
855
856                elif code==5:
857                        msg_text=_("Error: Profile is not authorized to Google Drive")
858
859                elif code==6:
860                        msg_text=_("Error: Unknow profile")
861
862                elif code==7:
863                        msg_text=_("Error: Unable to dismount mount point")
864
865                elif code==8:
866                        msg_text=_("Error: Unable to connect with google")     
867                       
868                elif code==9:
869                        msg_text=_("Status updated. Now you can change it")
870
871                elif code==10:
872                        msg_text=_("You must indicate a profile")
873
874                elif code==11:
875                        msg_text=_("Profile can not contain blanks")
876
877                elif code==12:
878                        msg_text=_("Profile already exists")
879                       
880                elif code==13:
881                        msg_text=_("Mount point already used by another profile")       
882
883                elif code==14:
884                        msg_text=_("The mount point must be an empty folder")   
885
886                elif code==15:
887                        msg_text=_("Mount point is not owned by user")         
888
889                elif code==16:
890                        msg_text=_("Path of mount point can not contain blanks")
891                       
892                elif code==17:
893                        msg_text=_("Error: You must specify a GDrive folder or disable the option")     
894
895                elif code==18:
896                        msg_text=_("Error: Unable to mount mount point. The specified GDrive folder maybe not be correct")     
897
898                elif code==19:
899                        msg_text=_("Error: The specified Gdrive folder no longer exists")
900               
901                elif code==20:
902                        msg_text=_("Error: No folders found in Gdrive profile. You must disable the option")   
903
904                               
905                return msg_text         
906               
907
908        #def get_msg                                                   
909
910        def kill_create_profile(self):
911       
912                if self.retry>MAX_RETRY_INTENTS:
913                        parent=psutil.Process(self.create_profile_t.pid)
914                        for child in parent.children(recursive=True):
915                                child.kill()
916                                self.create_profile_t.terminate()
917                                self.profile_msg.set_name("MSG_ERROR_LABEL")
918                                self.profile_msg.set_text(_("Error getting authorization"))
919
920                return True     
921
922        #def kill_create_profile       
923
924        def create_profile(self):
925
926                result=self.core.LliurexGoogleDriveManager.create_profile(self.new_profile)
927
928        #def create_profile     
929
930        def create_mountpoint(self):
931
932                self.create_result=self.core.LliurexGoogleDriveManager.create_mountpoint(self.profiles_info,self.new_profile)
933                self.create_mountpoint_t.done=True
934               
935        #def create_mountpoint 
936
937        def pulsate_edit_profile(self):
938
939                self.profile_pbar.pulse()
940                if not self.edit_profile_t.launched:
941                        self.edit_profile_t.start()
942                        self.edit_profile_t.launched=True
943                        self.accept_add_profile_button.hide()
944                        self.cancel_add_profile_button.hide()
945
946                if self.edit_profile_t.done:
947                        self.profile_pbar.hide()
948                        if self.edit_result["result"]:
949                                self.profile_msg.set_name("MSG_LABEL")
950                                self.profile_to_edit.get_children()[3].set_text(self.new_mountpoint)
951                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
952                                self.change_cancel_button()
953                       
954                        else:
955                               
956                                self.profile_msg.set_name("MSG_ERROR_LABEL")
957                                self.cancel_add_profile_button.show()
958
959                        msg_text=self.get_msg(self.edit_result["code"])
960                        self.profile_msg.set_text(msg_text)
961
962                        return False
963                       
964
965                if self.edit_profile_t.launched:
966                        if not self.edit_profile_t.done:
967                                return True
968
969        #def pulsate_edit_profile                       
970
971        def edit_profile(self):
972
973                self.edit_result=self.core.LliurexGoogleDriveManager.edit_profile(self.profiles_info,self.new_profile)
974                self.edit_profile_t.done=True
975
976        #def edit_profile       
977
978        def cancel_add_profile_clicked(self,widget):
979               
980                self.new_profile_window.hide()
981
982       
983        #def cancel_add_profile_clicked
984       
985        def root_folder_clicked(self,widget,event):
986
987                if self.root_folder_param_entry.get_active():
988                        print "ENTRANDO"
989                        if not self.root_folder:
990                                print "HOLA"
991                               
992                                self.init_read_mountpoint_dialog()     
993                       
994                else:
995                        self.root_folder=False
996                        self.gdrive_folder_label.hide()
997                        self.gdrive_folder_entry.hide()
998                        #self.gdrive_folder_entry.set_text("")
999                        self.edit_gdrive_folder_button.hide()   
1000
1001        #def root_folder_clicked               
1002
1003
1004        #def pulsate_read_mountpoint                   
1005
1006        def init_read_mountpoint_dialog(self):
1007
1008                if not self.read:
1009
1010                        if not self.read_mountpoint_t.launched:
1011                                self.disable_entry_profile_dialog()
1012                                self.profile_msg.set_name("MSG_LABEL")
1013                                self.profile_msg.show()
1014                                self.profile_msg.set_text(_("Getting folders from Google Drive profile ..."))
1015                                self.profile_pbar.show()
1016                                GLib.timeout_add(100,self.pulsate_read_mountpoint)     
1017
1018                else:
1019                        if len(self.syncfolders_model)>1:
1020                                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
1021                                self.stack.set_visible_child_name("folder")     
1022                                self.gdrive_combobox.set_active(0)
1023
1024        #def init_read_mountpoint_dialog               
1025
1026
1027        def pulsate_read_mountpoint(self):
1028
1029                self.profile_pbar.pulse()
1030
1031                if not self.read_mountpoint_t.launched:
1032                        self.read_mountpoint_t.start()
1033                        self.read_mountpoint_t.launched=True
1034                        self.accept_add_profile_button.hide()
1035                        self.cancel_add_profile_button.hide()
1036
1037                if self.read_mountpoint_t.done:
1038                        self.root_folder=False
1039                        self.enable_entry_profile_dialog()
1040                        self.profile_pbar.hide()
1041                        self.profile_msg.hide()
1042               
1043                        if len(self.syncfolders_model)>1:
1044                                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
1045
1046                                self.stack.set_visible_child_name("folder")
1047                                self.accept_add_profile_button.show()
1048                                self.cancel_add_profile_button.show()
1049                        else:
1050                                self.profile_msg.show()
1051                                self.profile_msg.set_name("MSG_ERROR_LABEL")
1052                                self.profile_msg.set_text(_("No folder detected on google drive profile"))     
1053                                self.accept_add_profile_button.show()
1054                                self.cancel_add_profile_button.show()
1055                       
1056                        return False
1057                       
1058
1059                if self.read_mountpoint_t.launched:
1060                        if not self.read_mountpoint_t.done:
1061                                return True
1062
1063       
1064
1065        def read_mountpoint(self):
1066
1067
1068                folders=self.core.LliurexGoogleDriveManager.read_mountpoint_directory(self.profile)
1069               
1070                self.syncfolders_model.clear()
1071
1072                if len(folders)>0:
1073                       
1074                        for item in folders:
1075                                self.syncfolders_model.append([item])
1076
1077                                                               
1078                self.read=True                 
1079
1080                self.read_mountpoint_t.done=True       
1081
1082        #def read_mountpoint
1083       
1084        def edit_gdrive_folder_button_clicked(self,widget):
1085
1086
1087                self.init_threads()
1088                self.profile_msg.hide()
1089                self.profile_msg.set_text("")
1090                self.init_read_mountpoint_dialog()
1091
1092                       
1093
1094        #def edit_gdrive_folder_button_clicked 
1095       
1096
1097        def return_combobox_button_clicked(self,widget):
1098
1099               
1100                #self.gdrive_folder_entry.set_text(self.folder)
1101                #self.gdrive_folder=folder
1102
1103               
1104                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
1105                self.stack.set_visible_child_name("edit")       
1106
1107                self.gdrive_folder_label.show()
1108                self.gdrive_folder_entry.show()
1109                self.edit_gdrive_folder_button.set_sensitive(True)     
1110
1111        #def return_combobox_button_clicked     
1112
1113        def on_gdrive_combobox_changed (self,combo):
1114
1115
1116               
1117                tree_iter=combo.get_active_iter()
1118
1119               
1120                if tree_iter != None:
1121                        model = combo.get_model()
1122                        folder = model[tree_iter][0]
1123                        self.gdrive_folder_entry.set_text(folder)
1124
1125
1126        #def on_gdrive_combobox_changeg         
1127
1128       
1129
1130
1131
1132#class profilebox
1133
1134
1135       
1136               
Note: See TracBrowser for help on using the repository browser.