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

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

Add WIP_files folder

File size: 32.2 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                if not self.check_form_t.launched:
672                        self.profile_msg.set_text(_("Checking form..."))
673                        GLib.timeout_add(100,self.pulsate_check_form)
674
675
676        def pulsate_check_form(self):
677
678                self.profile_pbar.pulse()
679               
680                if not self.check_form_t.launched:
681                        self.check_form_t.start()
682                        self.check_form_t.launched=True
683
684
685                if self.check_form_t.done:
686
687                        if self.check_form_result['result']:
688                                self.profiles_info[self.new_profile]={}
689                                self.profiles_info[self.new_profile]["email"]=self.new_email
690                                self.profiles_info[self.new_profile]["mountpoint"]=self.new_mountpoint
691                                self.profiles_info[self.new_profile]["automount"]=self.new_automount
692                                self.profiles_info[self.new_profile]["root_folder"]=self.new_root_folder
693                                self.profiles_info[self.new_profile]["gdrive_folder"]=self.new_gdrive_folder
694                       
695                                self.profile_msg.set_name("MSG_LABEL")
696                                if not self.edition:
697                                        if not self.create_profile_t.launched:
698                                                self.profile_msg.set_text(_("Connecting with google to get account access..."))
699                                                self.profile_pbar.show()
700                                                self.retry=0
701                                                GLib.timeout_add(100,self.pulsate_add_profile)
702                                       
703                       
704                                else:
705                                                               
706                                        if not self.edit_profile_t.launched:
707                                                self.profile_msg.set_text(_("Applying changes..."))
708                                                self.profile_pbar.show()
709                                                GLib.timeout_add(100,self.pulsate_edit_profile) 
710                        else:
711                                self.profile_pbar.hide()
712                                self.profile_msg.set_name("MSG_ERROR_LABEL")
713                                #self.profile_msg.set_text(check_form["msg"])
714                                self.profile_msg.set_text(self.get_msg(self.check_form_result["code"]))
715                                self.enable_entry_profile_dialog()
716                                return False
717
718                if self.check_form_t.launched:
719                        if not self.check_form_t.done:
720                                return True             
721
722        def check_form(self):                   
723
724                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)
725                self.check_form_t.done=True
726                #self.profile_msg.show()
727
728       
729        #def accept_add_profile_clicked
730
731        def check_mountpoint_folder(self,widget):
732
733       
734                self.disable_entry_profile_dialog()
735                #ENCODING TO UNICODE
736                profile=self.profile_entry.get_text()
737
738                new_profile=profile.strip().decode("utf-8")
739                new_mountpoint=self.mountpoint_entry.get_filename().decode("utf-8")
740                               
741                check_form=self.core.LliurexGoogleDriveManager.check_mountpoint_folder(new_profile,new_mountpoint,self.edition)
742               
743                if not check_form["result"]:
744                        self.profile_msg.show()
745                        self.profile_msg.set_name("MSG_ERROR_LABEL")
746                        self.profile_msg.set_text(self.get_msg(check_form["code"]))
747                       
748                else:
749                        self.profile_msg.hide() 
750
751                self.enable_entry_profile_dialog()     
752
753        #def check_mountpoint_folder   
754
755        '''     
756        def check_profile_info(self):
757
758                msg_check=""
759
760                check_form=self.core.LliurexGoogleDriveManager.check_profile_info(self.new_profile,self.new_mountpoint,self.edition)
761
762               
763                if not check_form["result"]:
764                        if check_form["code"]==1:
765                                msg_check=_("You must indicate a profile")
766
767                        elif check_form["code"]==2:
768                                msg_check=_("Profile can not contain blanks")
769
770                        elif check_form["code"]==3 :
771                                msg_check=_("Profile already exists")
772                       
773                        elif check_form["code"]==4:
774                                msg_check=_("Mount point already used by another profile")     
775
776                        elif check_form["code"]==5:
777                                msg_check=_("The mount point must be an empty folder") 
778
779                        elif check_form["code"]==6:
780                                msg_check=_("Mount point is not owned by user")
781
782
783                return {"result":check_form["result"],"msg":msg_check}
784
785        #def check_profile_info
786
787        '''     
788
789        def pulsate_add_profile(self):
790
791                self.retry=self.retry+1
792                self.profile_pbar.pulse()
793               
794                if not self.create_profile_t.launched:
795                        self.accept_add_profile_button.hide()
796                        self.cancel_add_profile_button.hide()
797               
798                        self.create_profile_t.start()
799                        self.create_profile_t.launched=True
800
801                if not self.create_profile_t.is_alive():
802                        if not self.create_mountpoint_t.launched:
803                                self.profile_msg.set_name("MSG_LABEL")
804                                self.profile_msg.set_text(_("Creating profile... "))
805                                self.create_mountpoint_t.start()
806                                self.create_mountpoint_t.launched=True
807
808                        if self.create_mountpoint_t.done:
809                                self.profile_pbar.hide()
810                                if self.create_result["result"]:
811                                                self.initial_connection=True
812                                                self.new_profile_button(self.new_profile,self.new_email,self.new_mountpoint)
813                                                self.profile_msg.set_text(_("Profile created successfully"))
814                                                self.change_cancel_button()
815                                               
816                                else:
817                                        msg_text=self.get_msg(self.create_result["code"])
818                                        self.profile_msg.set_name("MSG_ERROR_LABEL")
819                                        self.profile_msg.set_text(msg_text)
820                                        self.cancel_add_profile_button.show()
821                                       
822                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
823                                return False   
824                                               
825                if self.create_profile_t.launched:
826                        if self.create_profile_t.is_alive():
827                                self.kill_create_profile()
828                                return True     
829                               
830
831                if self.create_mountpoint_t.launched:
832                        if not self.create_mountpoint_t.done:
833                                return True             
834
835        #def_pulsate_add_profile       
836
837
838        def get_msg(self,code):
839
840                if      code==0:
841                        msg_text=_("Changes applied successfully")
842               
843                elif code==1:
844                        msg_text=_("Error: Unable to create mount point")
845
846                elif code==2:
847                        msg_text=_("Error: Unable to mount mount point")
848
849                elif code==3:
850                        msg_text=_("Error: Mount point is not owned by user")   
851
852                elif code==4:
853                        msg_text=_("Error: No mount point indicated")
854
855                elif code==5:
856                        msg_text=_("Error: Profile is not authorized to Google Drive")
857
858                elif code==6:
859                        msg_text=_("Error: Unknow profile")
860
861                elif code==7:
862                        msg_text=_("Error: Unable to dismount mount point")
863
864                elif code==8:
865                        msg_text=_("Error: Unable to connect with google")     
866                       
867                elif code==9:
868                        msg_text=_("Status updated. Now you can change it")
869
870                elif code==10:
871                        msg_text=_("You must indicate a profile")
872
873                elif code==11:
874                        msg_text=_("Profile can not contain blanks")
875
876                elif code==12:
877                        msg_text=_("Profile already exists")
878                       
879                elif code==13:
880                        msg_text=_("Mount point already used by another profile")       
881
882                elif code==14:
883                        msg_text=_("The mount point must be an empty folder")   
884
885                elif code==15:
886                        msg_text=_("Mount point is not owned by user")         
887
888                elif code==16:
889                        msg_text=_("Path of mount point can not contain blanks")
890                       
891                elif code==17:
892                        msg_text=_("Error: You must specify a GDrive folder or disable the option")     
893
894                elif code==18:
895                        msg_text=_("Error: Unable to mount mount point. The specified GDrive folder maybe not be correct")     
896
897                elif code==19:
898                        msg_text=_("Error: The specified Gdrive folder no longer exists")
899               
900                elif code==20:
901                        msg_text=_("Error: No folders found in Gdrive profile. You must disable the option")   
902
903                               
904                return msg_text         
905               
906
907        #def get_msg                                                   
908
909        def kill_create_profile(self):
910       
911                if self.retry>MAX_RETRY_INTENTS:
912                        parent=psutil.Process(self.create_profile_t.pid)
913                        for child in parent.children(recursive=True):
914                                child.kill()
915                                self.create_profile_t.terminate()
916                                self.profile_msg.set_name("MSG_ERROR_LABEL")
917                                self.profile_msg.set_text(_("Error getting authorization"))
918
919                return True     
920
921        #def kill_create_profile       
922
923        def create_profile(self):
924
925                result=self.core.LliurexGoogleDriveManager.create_profile(self.new_profile)
926
927        #def create_profile     
928
929        def create_mountpoint(self):
930
931                self.create_result=self.core.LliurexGoogleDriveManager.create_mountpoint(self.profiles_info,self.new_profile)
932                self.create_mountpoint_t.done=True
933               
934        #def create_mountpoint 
935
936        def pulsate_edit_profile(self):
937
938                self.profile_pbar.pulse()
939                if not self.edit_profile_t.launched:
940                        self.edit_profile_t.start()
941                        self.edit_profile_t.launched=True
942                        self.accept_add_profile_button.hide()
943                        self.cancel_add_profile_button.hide()
944
945                if self.edit_profile_t.done:
946                        self.profile_pbar.hide()
947                        if self.edit_result["result"]:
948                                self.profile_msg.set_name("MSG_LABEL")
949                                self.profile_to_edit.get_children()[3].set_text(self.new_mountpoint)
950                                self.profiles_info=self.core.LliurexGoogleDriveManager.profiles_config.copy()   
951                                self.change_cancel_button()
952                       
953                        else:
954                               
955                                self.profile_msg.set_name("MSG_ERROR_LABEL")
956                                self.cancel_add_profile_button.show()
957
958                        msg_text=self.get_msg(self.edit_result["code"])
959                        self.profile_msg.set_text(msg_text)
960
961                        return False
962                       
963
964                if self.edit_profile_t.launched:
965                        if not self.edit_profile_t.done:
966                                return True
967
968        #def pulsate_edit_profile                       
969
970        def edit_profile(self):
971
972                self.edit_result=self.core.LliurexGoogleDriveManager.edit_profile(self.profiles_info,self.new_profile)
973                self.edit_profile_t.done=True
974
975        #def edit_profile       
976
977        def cancel_add_profile_clicked(self,widget):
978               
979                self.new_profile_window.hide()
980
981       
982        #def cancel_add_profile_clicked
983       
984        def root_folder_clicked(self,widget,event):
985
986                if self.root_folder_param_entry.get_active():
987                        print "ENTRANDO"
988                        if not self.root_folder:
989                                print "HOLA"
990                               
991                                self.init_read_mountpoint_dialog()     
992                       
993                else:
994                        self.root_folder=False
995                        self.gdrive_folder_label.hide()
996                        self.gdrive_folder_entry.hide()
997                        #self.gdrive_folder_entry.set_text("")
998                        self.edit_gdrive_folder_button.hide()   
999
1000        #def root_folder_clicked               
1001
1002
1003        #def pulsate_read_mountpoint                   
1004
1005        def init_read_mountpoint_dialog(self):
1006
1007                if not self.read:
1008
1009                        if not self.read_mountpoint_t.launched:
1010                                self.disable_entry_profile_dialog()
1011                                self.profile_msg.set_name("MSG_LABEL")
1012                                self.profile_msg.show()
1013                                self.profile_msg.set_text(_("Getting folders from Google Drive profile ..."))
1014                                self.profile_pbar.show()
1015                                GLib.timeout_add(100,self.pulsate_read_mountpoint)     
1016
1017                else:
1018                        if len(self.syncfolders_model)>1:
1019                                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
1020                                self.stack.set_visible_child_name("folder")     
1021                                self.gdrive_combobox.set_active(0)
1022
1023        #def init_read_mountpoint_dialog               
1024
1025
1026        def pulsate_read_mountpoint(self):
1027
1028                self.profile_pbar.pulse()
1029
1030                if not self.read_mountpoint_t.launched:
1031                        self.read_mountpoint_t.start()
1032                        self.read_mountpoint_t.launched=True
1033                        self.accept_add_profile_button.hide()
1034                        self.cancel_add_profile_button.hide()
1035
1036                if self.read_mountpoint_t.done:
1037                        self.root_folder=False
1038                        self.enable_entry_profile_dialog()
1039                        self.profile_pbar.hide()
1040                        self.profile_msg.hide()
1041               
1042                        if len(self.syncfolders_model)>1:
1043                                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
1044
1045                                self.stack.set_visible_child_name("folder")
1046                                self.accept_add_profile_button.show()
1047                                self.cancel_add_profile_button.show()
1048                        else:
1049                                self.profile_msg.show()
1050                                self.profile_msg.set_name("MSG_ERROR_LABEL")
1051                                self.profile_msg.set_text(_("No folder detected on google drive profile"))     
1052                                self.accept_add_profile_button.show()
1053                                self.cancel_add_profile_button.show()
1054                       
1055                        return False
1056                       
1057
1058                if self.read_mountpoint_t.launched:
1059                        if not self.read_mountpoint_t.done:
1060                                return True
1061
1062       
1063
1064        def read_mountpoint(self):
1065
1066
1067                folders=self.core.LliurexGoogleDriveManager.read_mountpoint_directory(self.profile)
1068               
1069                self.syncfolders_model.clear()
1070
1071                if len(folders)>0:
1072                       
1073                        for item in folders:
1074                                self.syncfolders_model.append([item])
1075
1076                                                               
1077                self.read=True                 
1078
1079                self.read_mountpoint_t.done=True       
1080
1081        #def read_mountpoint
1082       
1083        def edit_gdrive_folder_button_clicked(self,widget):
1084
1085
1086                self.init_threads()
1087                self.profile_msg.hide()
1088                self.profile_msg.set_text("")
1089                self.init_read_mountpoint_dialog()
1090
1091                       
1092
1093        #def edit_gdrive_folder_button_clicked 
1094       
1095
1096        def return_combobox_button_clicked(self,widget):
1097
1098               
1099                #self.gdrive_folder_entry.set_text(self.folder)
1100                #self.gdrive_folder=folder
1101
1102               
1103                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
1104                self.stack.set_visible_child_name("edit")       
1105
1106                self.gdrive_folder_label.show()
1107                self.gdrive_folder_entry.show()
1108                self.edit_gdrive_folder_button.set_sensitive(True)     
1109
1110        #def return_combobox_button_clicked     
1111
1112        def on_gdrive_combobox_changed (self,combo):
1113
1114
1115               
1116                tree_iter=combo.get_active_iter()
1117
1118               
1119                if tree_iter != None:
1120                        model = combo.get_model()
1121                        folder = model[tree_iter][0]
1122                        self.gdrive_folder_entry.set_text(folder)
1123
1124
1125        #def on_gdrive_combobox_changeg         
1126
1127       
1128
1129
1130
1131#class profilebox
1132
1133
1134       
1135               
Note: See TracBrowser for help on using the repository browser.