source: epi/trunk/fuentes/epi-gtk/python3-epigtk/MainWindow.py @ 8021

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

Fix code

File size: 27.1 KB
Line 
1#!/usr/bin/env python3
2
3import gi
4gi.require_version('Gtk', '3.0')
5from gi.repository import Gtk, Pango, GdkPixbuf, Gdk, Gio, GObject,GLib
6
7
8
9import signal
10import os
11import subprocess
12import json
13import sys
14import syslog
15import time
16import threading
17import tempfile
18
19
20
21signal.signal(signal.SIGINT, signal.SIG_DFL)
22
23from . import settings
24import gettext
25gettext.textdomain(settings.TEXT_DOMAIN)
26_ = gettext.gettext
27
28class MainWindow:
29       
30        def __init__(self,epi_file=None):
31
32                self.core=Core.Core.get_core()
33
34                self.epi_file=epi_file
35
36        #def init
37
38       
39       
40        def load_gui(self):
41               
42                builder=Gtk.Builder()
43                builder.set_translation_domain(settings.TEXT_DOMAIN)
44                ui_path=self.core.ui_path
45                builder.add_from_file(ui_path)
46
47                self.css_file=self.core.rsrc_dir+"epi-gtk.css"
48                self.ok_image=self.core.rsrc_dir+"ok.svg"
49                self.error_image=self.core.rsrc_dir+"error.svg"
50                self.sp1=self.core.rsrc_dir+"sp1.svg"
51                self.sp2=self.core.rsrc_dir+"sp2.svg"
52                self.sp3=self.core.rsrc_dir+"sp3.svg"
53                self.sp4=self.core.rsrc_dir+"sp4.svg"
54                self.sp5=self.core.rsrc_dir+"sp5.svg"
55                self.sp6=self.core.rsrc_dir+"sp6.svg"
56                self.sp7=self.core.rsrc_dir+"sp7.svg"
57                self.sp8=self.core.rsrc_dir+"sp8.svg"
58               
59                self.stack = Gtk.Stack()
60                self.stack.set_transition_duration(10)
61                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
62               
63                self.main_window=builder.get_object("main_window")
64                self.main_window.set_title("EPI-GTK")
65                self.main_box=builder.get_object("main_box")
66                self.next_button=builder.get_object("next_button")
67                self.apply_button=builder.get_object("apply_button")
68                image = Gtk.Image()
69                image.set_from_stock(Gtk.STOCK_APPLY,Gtk.IconSize.MENU)
70                self.apply_button.set_image(image)     
71                self.uninstall_button=builder.get_object("uninstall_button")   
72                image = Gtk.Image()
73                image.set_from_stock(Gtk.STOCK_REMOVE,Gtk.IconSize.MENU)
74                self.uninstall_button.set_image(image)         
75
76                self.return_button=builder.get_object("return_button")
77                self.chooserBox=self.core.chooserBox
78                self.loadingBox=self.core.loadingBox
79                self.epiBox=self.core.epiBox
80                self.infoBox=self.core.infoBox
81
82                self.stack.add_titled(self.chooserBox,"chooserBox","ChooserBox")
83                self.stack.add_titled(self.loadingBox,"loadingBox","LoadingBox")
84                self.stack.add_titled(self.epiBox,"epiBox", "EpiBox")
85                self.stack.add_titled(self.infoBox,"infoBox","InfoBox")
86
87                self.main_box.pack_start(self.stack,True,False,5)
88
89               
90                self.set_css_info()
91
92                self.connect_signals()
93                self.init_install_process()
94                self.init_threads()
95               
96                self.main_window.show_all()
97
98                self.next_button.hide()
99                self.apply_button.hide()
100                self.uninstall_button.hide()
101                self.return_button.hide()
102                self.epiBox.epi_depend_label.hide()
103                self.epiBox.terminal_label.hide()
104                self.epiBox.terminal_scrolled.hide()
105                self.epiBox.viewport.hide()
106               
107                self.eulaBox=self.core.eulaBox
108                self.install_dep=True
109                self.eula_accepted=True
110                self.final_column=0
111                self.final_row=0
112
113                if self.epi_file!=None:
114                        self.init_process()
115                else:
116                        self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
117                        self.stack.set_visible_child_name("chooserBox") 
118
119               
120               
121        #def load_gui
122
123        def set_css_info(self):
124               
125               
126                self.style_provider=Gtk.CssProvider()
127                f=Gio.File.new_for_path(self.css_file)
128                self.style_provider.load_from_file(f)
129                Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),self.style_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
130                self.main_window.set_name("WINDOW")
131
132        #def set_css_info       
133                               
134                       
135        def connect_signals(self):
136               
137                self.main_window.connect("destroy",self.quit)
138                self.apply_button.connect("clicked",self.apply_button_clicked)
139                self.uninstall_button.connect("clicked",self.uninstall_process)
140                self.return_button.connect("clicked",self.go_back)
141                self.next_button.connect("clicked",self.go_forward)
142       
143               
144        #def connect_signals
145
146        def go_forward(self,widget):
147
148                self.epi_file=self.core.chooserBox.epi_loaded
149                self.stack.set_transition_duration(1000)
150                self.init_process()
151
152        #def go_forward
153
154        def init_process(self):
155
156                msg_log='APP conf file loaded by EPI-GTK: ' + self.epi_file
157                self.write_log(msg_log)
158                self.next_button.hide()
159                self.loadingBox.loading_spinner.start()
160                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
161                self.stack.set_visible_child_name("loadingBox") 
162                self.stack.set_transition_duration(1000)
163                GLib.timeout_add(100,self.pulsate_checksystem)
164       
165        #def init_process
166
167        def init_threads(self):
168
169                self.checking_system_t=threading.Thread(target=self.checking_system)
170                self.checking_system_t.daemon=True
171                self.checking_system_t.launched=False
172                self.checking_system_t.done=False
173
174                GObject.threads_init()
175
176        #def init_threads       
177
178
179        def load_info(self):
180
181                self.epiBox.load_info(self.load_epi_conf)
182               
183                if self.order>1:
184                        self.epiBox.epi_depend_label.show()
185                        self.epiBox.scrolledwindow.set_size_request(500,160)
186                else:
187                        if len(self.load_epi_conf[0]["pkg_list"])>1:
188                                self.epiBox.scrolledwindow.set_size_request(500,160)
189                        else:   
190                                self.epiBox.scrolledwindow.set_size_request(500,90)
191               
192       
193        #def load_info
194
195        def pulsate_checksystem(self):
196
197                error=False
198                aditional_info=""
199
200                if not self.checking_system_t.launched:
201                        self.checking_system_t.start()
202                        self.checking_system_t.launched=True
203
204
205                if self.checking_system_t.done:
206
207                        if self.connection[0]:
208                                if self.order>0:
209                                        if not self.required_root:
210                                                self.load_info()
211                                                self.apply_button.show()
212                                                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT)
213                                                if self.load_epi_conf[0]["status"]=="installed":
214                                                        self.epiBox.terminal_label.set_name("MSG_LABEL")
215                                                        self.epiBox.terminal_label.show()
216                                                        msg_code=0
217                                                        msg=self.get_msg_text(msg_code)
218                                                        self.epiBox.terminal_label.set_text(msg)
219                                                self.show_apply_uninstall_buttons()
220                                                self.stack.set_visible_child_name("epiBox")     
221
222                                                return False
223                                        else:
224                                                error=True
225                                                msg_code=2     
226                                else:
227                                        error=True
228                                        if self.valid_json:
229                                                msg_code=1
230                                        else:
231                                                msg_code=18     
232                                       
233                        else:
234                                error=True
235                                msg_code=3
236                                aditional_info=self.connection[1]
237                                                               
238
239                if error:
240                        self.loadingBox.loading_spinner.stop()
241                        self.loadingBox.loading_label.set_name("MSG_ERROR_LABEL")       
242                        msg_error=self.get_msg_text(msg_code)
243                        if aditional_info!="":
244                                self.write_log(msg_error+":"+aditional_info)
245                        else:
246                                self.write_log(msg_error)       
247                        self.loadingBox.loading_label.set_text(msg_error)
248                        return False
249
250
251                if self.checking_system_t.launched:
252                        if not self.checking_system_t.done:
253                                return True     
254
255
256        #def pulsate_checksystem                       
257       
258        def checking_system(self):
259       
260                time.sleep(1)
261                self.connection=self.core.epiManager.check_connection()
262               
263                if self.connection[0]:
264                        self.valid_json=self.core.epiManager.read_conf(self.epi_file)
265                        epi_loaded=self.core.epiManager.epiFiles
266                        order=len(epi_loaded)
267                        if order>0:
268                                self.core.epiManager.check_root()
269                                self.core.epiManager.get_pkg_info()
270                                self.required_root=self.core.epiManager.required_root()
271                                self.required_eula=self.core.epiManager.required_eula()
272                                if self.required_eula:
273                                        self.eula_accepted=False
274                                self.checking_system_t.done=True
275                                self.load_epi_conf=self.core.epiManager.epiFiles
276                                self.order=len(self.load_epi_conf)
277                        else:
278                                self.load_epi_conf=epi_loaded
279                                self.order=order
280                       
281
282                self.checking_system_t.done=True       
283
284        #def checking_system   
285
286        def check_remove_script(self):
287
288                remove=False
289                if len(self.load_epi_conf[0]["script"])>0:
290                        try:
291                                remove=self.load_epi_conf[0]["script"]["remove"]
292                        except Exception as e:
293                                pass
294
295                return remove
296
297        #def check_remove_script                       
298
299        def show_remove_button(self,action=None):
300
301                remove=self.check_remove_script()
302
303                status=self.load_epi_conf[0]["status"]
304
305                if remove:
306                        if action=="install":
307                                self.uninstall_button.show()
308                                self.uninstall_button.set_sensitive(True)
309                        elif action=="uninstalled":
310                                        self.uninstall_button.hide()
311                        else:
312                                if status=="installed":
313                                        self.uninstall_button.show()
314
315                                else:
316                                        self.uninstall_button.hide()           
317                       
318                else:
319                        self.uninstall_button.hide()   
320
321        #def show_remove_button                 
322
323
324        def show_apply_uninstall_buttons(self):
325
326                remove=self.check_remove_script()
327                status=self.load_epi_conf[0]["status"]
328
329                if status=='availabled':
330
331                        if not self.eula_accepted:
332                                self.apply_button.set_label(_("Accept Eula and Install"))
333                        else:   
334                                self.apply_button.set_label(_("Install"))
335                        self.apply_button.set_sensitive(True)
336                        self.uninstall_button.hide()
337
338                else:
339                        self.eula_accepted=True
340                        self.apply_button.set_label(_("Reinstall"))
341                        self.apply_button.set_sensitive(True)
342                        if remove:
343                                self.uninstall_button.show()
344                                self.uninstall_button.set_sensitive(True)
345
346                        else:
347                                self.uninstall_button.hide()                   
348
349        #def show_apply_uninstall_buttons                       
350
351        def init_install_process(self):
352
353                self.add_repository_keys_launched=False
354                self.add_repository_keys_done=False
355
356                self.download_app_launched=False
357                self.download_app_done=False
358
359                self.check_download_launched=False
360                self.check_download_done=False
361
362                self.preinstall_app_launched=False
363                self.preinstall_app_done=False
364
365                self.check_preinstall_launched=False
366                self.check_preinstall_donde=False
367
368                self.install_app_launched=False
369                self.install_app_done=False
370
371                self.check_install_launched=False
372                self.check_install_done=False
373
374                self.postinstall_app_launched=False
375                self.postinstall_app_done=False
376
377                self.check_postinstall_launched=False
378                self.check_postinstall_done=False
379
380
381        #def init_install_process       
382
383        def spinner_sync(self,order):
384
385               
386                if self.sp_cont>40:
387                        self.sp_cont=0
388                               
389                if self.sp_cont==0:
390                        self.img=self.sp1
391                       
392                elif self.sp_cont==5:
393                        self.img=self.sp2
394                                       
395                elif self.sp_cont==10:
396                        self.img=self.sp3
397                       
398                elif self.sp_cont==15:
399                        self.img=self.sp4
400                       
401                elif self.sp_cont==20:
402                        self.img=self.sp5
403
404                elif self.sp_cont==25:
405                        self.img=self.sp6
406
407                elif self.sp_cont==30:
408                        self.img=self.sp7
409
410                elif self.sp_cont==35:
411                        self.img=self.sp8                       
412
413       
414                elements=self.epiBox.update_icons[order]
415                for item in elements:
416                        item['icon_status'].set_from_file(self.img)
417                       
418        #def spinner_sync                                               
419
420
421        def apply_button_clicked(self,widget):
422
423                if self.eula_accepted:
424                        self.install_process()
425                else:
426                        self.eula_order=self.order
427                        self.cont_eula=self.eula_order-1
428                        self.accept_eula()
429
430        #def apply_button_clicked
431       
432
433        def accept_eula(self):
434
435                if self.cont_eula>-1:
436                        if self.eula_order>0:
437                                self.eula_order=self.eula_order-1
438                                if self.load_epi_conf[self.eula_order]["eula"]!="":
439                                        self.eulaBox.load_info(self.load_epi_conf,self.eula_order)
440                                else:
441                                        self.cont_eula-=1
442                                        self.accept_eula()
443                        else:
444                                if self.load_epi_conf[self.eula_order]["eula"]!="":
445                                        self.eulaBox.load_info(self.load_epi_conf,self.eula_order)
446                                else:
447                                        self.install_process() 
448                else:
449                        self.eula_accepted=True
450                        self.write_log("Eula accepted")
451                        self.eulaBox.eula_window.hide()
452                        self.install_process()
453
454        #def accept_eula               
455
456        def install_process(self):
457
458                self.sp_cont=0
459                self.epiBox.terminal_scrolled.show()
460                self.epiBox.viewport.show()
461                self.epiBox.manage_vterminal(True,False)
462                self.init_install_process()
463                self.apply_button.set_sensitive(False)
464                self.uninstall_button.set_sensitive(False)
465               
466                if self.install_dep:
467                        if self.order>0:
468                                self.order=self.order-1
469                else:
470                        self.order=0
471
472                self.epiBox.terminal_label.set_name("MSG_LABEL")
473                self.core.epiManager.zerocenter_feedback(self.order,"init")     
474                GLib.timeout_add(100,self.pulsate_install_package,self.order)
475
476        #def install_processs
477
478
479        def pulsate_install_package(self,order):
480               
481                self.spinner_sync(order)
482                self.sp_cont=self.sp_cont+1
483                error=False
484
485                if not self.add_repository_keys_launched:
486                        self.epiBox.terminal_label.show()
487                        msg=self.get_msg_text(4)
488                        self.epiBox.terminal_label.set_text(msg)
489                        self.add_repository_keys_launched=True
490                        self.sp_cont=self.sp_cont+1
491                        if order==0:
492                                self.install_dep=False
493                               
494                        self.add_repository_keys(order)
495                       
496               
497                if self.add_repository_keys_done:
498                        if not self.download_app_launched:
499                                msg=self.get_msg_text(5)
500                                self.epiBox.terminal_label.set_text(msg)
501                                self.download_app_launched=True
502                                self.download_app()
503
504                        if self.download_app_done:
505
506                                if not self.check_download_launched:
507                                        self.check_download_launched=True
508                                        self.check_download()
509
510                                if self.check_download_done:
511                                        if self.download_result:       
512                                                                       
513                                                if not self.preinstall_app_launched:
514                                                        msg=self.get_msg_text(6)
515                                                        self.epiBox.terminal_label.set_text(msg)
516                                                        self.preinstall_app_launched=True
517                                                        self.preinstall_app()
518
519                                                if self.preinstall_app_done:   
520
521                                                        if not self.check_preinstall_launched:
522                                                                self.check_preinstall_launched=True
523                                                                self.check_preinstall()
524
525                                                        if self.check_preinstall_done:
526                                                               
527                                                               
528                                                                if self.preinstall_result:
529                                                                        if not self.install_app_launched:
530                                                                                msg=self.get_msg_text(7)
531                                                                                self.epiBox.terminal_label.set_text(msg)
532                                                                                self.install_app_launched=True
533                                                                                self.install_app()
534
535                                                                        if self.install_app_done:
536
537                                                                                if not self.check_install_launched:
538                                                                                        self.check_install_launched=True
539                                                                                        self.check_install()
540
541                                                                                       
542                                                                                if self.check_install_done:     
543                                                                                        if self.installed:
544                                                                                                if not self.postinstall_app_launched:
545                                                                                                        msg=self.get_msg_text(8)
546                                                                                                        self.epiBox.terminal_label.set_text(msg)
547                                                                                                        self.postinstall_app_launched=True
548                                                                                                        self.postinstall_app() 
549
550                                                                                                if self.postinstall_app_done:
551
552                                                                                                        if not self.check_postinstall_launched:
553                                                                                                                self.check_postinstall_launched=True
554                                                                                                                self.check_postinstall()
555
556                                                                                                        if self.check_postinstall_done:
557                                                                                                               
558                                                                                                                if self.postinstall_result:     
559                                                                                                                        params=[order,True,'install',None]
560                                                                                                                        self.update_icon(params)
561                                                                                                                        self.core.epiManager.zerocenter_feedback(self.order,"install",True)
562
563                                                                                                                        if self.order>0:
564                                                                                                                                self.order=self.order-1
565                                                                                                                                self.sp_cont=0
566                                                                                                                                self.init_install_process()
567                                                                                                                                GLib.timeout_add(100,self.pulsate_install_package,self.order)
568
569                                                                                                                        else:
570                                                                                                                                msg=self.get_msg_text(9)
571                                                                                                                                self.epiBox.terminal_label.set_name("MSG_CORRECT_LABEL")
572                                                                                                                                self.epiBox.terminal_label.set_text(msg)
573                                                                                                                                self.epiBox.manage_vterminal(False,True)
574                                                                                                                                self.write_log_terminal('install')
575                                                                                                                                self.load_epi_conf[0]["status"]="installed"
576                                                                                                                                self.write_log(msg)
577                                                                                                                                self.show_apply_uninstall_buttons()
578                                                                                                                                self.core.epiManager.remove_repo_keys()
579
580                                                                                                                                return False
581                                                                                                                        return False
582
583                                                                                                                else:
584                                                                                                                        error=True
585                                                                                                                        error_code=10
586                                                                                                                        params=[order,False,'install',None]
587                                                                                        else:
588                                                                                                error=True
589                                                                                                error_code=11
590                                                                                                params=[order,False,'install',self.dpkg_status]
591                                                                                               
592                                                                else:
593                                                                        error=True
594                                                                        error_code=12
595                                                                        params=[order,False,'install',None]
596                                                                                                                                                               
597                                        else:
598                                                error=True
599                                                error_code=13
600                                                params=[order,False,'install',None]
601                                                                               
602
603                if error:
604                        self.epiBox.manage_vterminal(False,True)
605                        msg_error=self.get_msg_text(error_code)
606                        self.epiBox.terminal_label.set_name("MSG_ERROR_LABEL")
607                        self.epiBox.terminal_label.set_text(msg_error)
608                        self.update_icon(params)
609                        self.core.epiManager.zerocenter_feedback(params[0],"install",False)
610                        self.write_log_terminal('install')
611                        self.write_log(msg_error)
612                        self.core.epiManager.remove_repo_keys()
613                        return False
614
615                if self.add_repository_keys_launched:
616                       
617                        if      not self.add_repository_keys_done:
618                                if os.path.exists(self.token_keys[1]):
619                                        return True
620                                else:
621                                       
622                                        self.add_repository_keys_done=True
623                                        return True
624               
625                if self.download_app_launched:
626                       
627                        if      not self.download_app_done:
628                                if os.path.exists(self.token_download[1]):
629                                        return True
630                                else:
631                                        self.download_app_done=True
632                                        return True     
633
634                if self.check_download_launched:
635                        if not self.check_download_done:
636                                return True                     
637               
638                if self.preinstall_app_launched:
639                       
640                        if      not self.preinstall_app_done:
641                                if os.path.exists(self.token_preinstall[1]):
642                                        return True
643                                else:
644                                        self.preinstall_app_done=True
645                                        return True             
646
647                if self.check_preinstall_launched:
648                        if not self.check_preinstall_done:
649                                return                         
650
651                if self.install_app_launched:
652                       
653                        if      not self.install_app_done:
654                                if os.path.exists(self.token_install[1]):
655                                        return True
656                                else:
657                                        self.install_app_done=True
658                                        return True             
659
660                if self.check_install_launched:
661                        if not self.check_install_done:
662                                return True
663
664
665                if self.postinstall_app_launched:
666                       
667                        if      not self.postinstall_app_done:
668                                if os.path.exists(self.token_postinstall[1]):
669                                        return True
670                                else:
671                                        self.postinstall_app_done=True
672                                        return True             
673
674                if self.check_postinstall_launched:
675                        if not self.check_postinstall_done:
676                                return                                                                         
677
678        #def pulsate_install_package                           
679
680        def add_repository_keys(self,order):
681
682                command=self.core.epiManager.add_repository_keys(order)
683                length=len(command)
684                if length>0:
685                        command=self.create_process_token(command,"keys")
686                        length=len(command)
687                        self.epiBox.vterminal.feed_child(command,length)
688                else:
689                        self.add_repository_keys_done=True
690
691        #def add_repository_keys               
692
693        def download_app(self):
694
695                command=self.core.epiManager.download_app()
696                length=len(command)
697                if length>0:
698                        command=self.create_process_token(command,"download")
699                        length=len(command)
700                        self.epiBox.vterminal.feed_child(command,length)
701                else:
702                        self.download_app_done=True     
703
704        #def download_app               
705
706        def check_download(self):
707
708                self.download_result=self.core.epiManager.check_download()
709                self.check_download_done=True
710
711        #def check_download
712
713        def check_preinstall(self):
714
715                self.preinstall_result=self.core.epiManager.check_preinstall()
716                self.check_preinstall_done=True
717
718        #def check_preinstall           
719
720       
721        def preinstall_app(self):
722
723                command=self.core.epiManager.preinstall_app()
724
725                length=len(command)
726                if length>0:
727                        command=self.create_process_token(command,"preinstall")
728                        length=len(command)
729                        self.epiBox.vterminal.feed_child(command,length)
730
731                else:
732                        self.preinstall_app_done=True                   
733
734        #def preinstall_app             
735
736
737        def install_app(self):
738
739                command=self.core.epiManager.install_app()
740
741                length=len(command)
742                if length>0:
743                        command=self.create_process_token(command,"install")
744                        length=len(command)
745                        self.epiBox.vterminal.feed_child(command,length)
746                else:
747                        self.install_app_done=True     
748
749         #def install_app
750
751        def check_install(self):
752
753                self.dpkg_status,self.installed=self.core.epiManager.check_install_remove("install")
754                self.check_install_done=True
755
756        #def check_install     
757
758        def postinstall_app(self):
759
760                command=self.core.epiManager.postinstall_app()
761                length=len(command)
762                if length>0:
763                        command=self.create_process_token(command,"postinstall")
764                        length=len(command)
765                        self.epiBox.vterminal.feed_child(command,length)
766                else:
767                        self.postinstall_app_done=True                 
768
769        #def postinstall_app
770
771        def check_postinstall(self):
772
773                self.postinstall_result=self.core.epiManager.check_postinstall()
774                self.check_postinstall_done=True
775
776        #def check_postinstall                                 
777
778        def init_uninstall_process(self):
779
780                self.remove_package_launched=False
781                self.remove_package_done=False
782
783                self.check_remove_launched=False
784                self.check_remove_done=False
785
786        #def init_uninstall_process     
787
788        def uninstall_process(self,widget):
789
790                dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO, "EPI-GTK")
791                msg=self.get_msg_text(14)
792                dialog.format_secondary_text(msg)
793                response=dialog.run()
794                dialog.destroy()
795               
796
797                if response==Gtk.ResponseType.YES:
798                        self.epiBox.manage_vterminal(True,False)
799                        self.sp_cont=0
800                        self.epiBox.terminal_scrolled.show()
801                        self.epiBox.viewport.show()
802                        self.init_uninstall_process()
803                        self.apply_button.set_sensitive(False)
804                        self.uninstall_button.set_sensitive(False)
805                        self.epiBox.terminal_label.set_name("MSG_LABEL")
806                       
807                        GLib.timeout_add(100,self.pulsate_uninstall_process,0)
808
809        #def uninstall_process         
810
811
812        def pulsate_uninstall_process(self,order):
813
814                self.spinner_sync(order)
815                self.sp_cont=self.sp_cont+1
816               
817                if not self.remove_package_launched:
818                        self.epiBox.terminal_label.show()
819                        msg=self.get_msg_text(15)
820                        self.epiBox.terminal_label.set_text(msg)
821                        self.remove_package_launched=True
822                        self.sp_cont=self.sp_cont+1
823                        self.uninstall_app(order)
824
825
826                if self.remove_package_done:
827
828                        if not self.check_remove_launched:
829                                self.check_remove_launched=True
830                                self.check_remove()
831                       
832                        if self.check_remove_done:
833                                self.epiBox.manage_vterminal(False,True)
834                               
835                                if self.remove:
836                                        msg=self.get_msg_text(16)
837                                        self.epiBox.terminal_label.set_name("MSG_CORRECT_LABEL")
838                                        self.epiBox.terminal_label.set_text(msg)
839                                        params=[order,True,'remove',None]
840                                        self.update_icon(params)
841                                        self.load_epi_conf[0]["status"]="availabled"
842                                        self.show_apply_uninstall_buttons()
843                                        if self.order==0:
844                                                self.install_dep=False
845                                        self.core.epiManager.zerocenter_feedback(0,"uninstall",True)
846                                        self.write_log_terminal('uninstall')
847                                        self.write_log(msg)
848                                        return False
849                                else:
850                                        msg=self.get_msg_text(17)
851                                        self.epiBox.terminal_label.set_name("MSG_ERROR_LABEL")
852                                        self.epiBox.terminal_label.set_text(msg)
853                                        params=[order,False,'remove',self.dpkg_status]
854                                        self.update_icon(params)
855                                        self.core.epiManager.zerocenter_feedback(0,"uninstall",False)
856                                        self.write_log_terminal('unistall')
857                                        self.write_log(msg)
858                                        return False
859
860       
861
862                if self.remove_package_launched:
863                        if      not self.remove_package_done:
864                                if os.path.exists(self.token_uninstall[1]):
865                                        return True
866                                else:
867                                        self.remove_package_done=True
868                                        return True             
869
870                if self.check_remove_launched:
871                        if not self.check_remove_done:
872                                return True                             
873
874        #def pulsate_uninstall_process                         
875
876
877        def uninstall_app(self,order):
878
879                command=self.core.epiManager.uninstall_app(order)
880
881                length=len(command)
882                if length>0:
883                        command=self.create_process_token(command,"uninstall")
884                        length=len(command)
885                        self.epiBox.vterminal.feed_child(command,length)
886
887                else:
888                        self.preinstall_app_done=True   
889
890        #def uninstall_app     
891
892        def check_remove(self):
893
894                self.dpkg_status,self.remove=self.core.epiManager.check_install_remove("uninstall")
895                self.check_remove_done=True
896
897        #def check_remove       
898
899        def update_icon(self,params):
900
901                order=params[0]
902                result=params[1]
903                process=params[2]
904                dpkg_status=params[3]
905
906                elements=self.epiBox.update_icons[order]
907
908                elements=self.epiBox.update_icons[order]
909                for item in elements:
910                        item['icon_status'].set_from_file(self.img)
911
912                if result:
913                        for item in elements:
914                                item['icon_status'].set_from_file(self.ok_image)
915                                if process=="install":
916                                        if order==0:
917                                                item['icon_package'].set_from_file(self.core.epiBox.package_installed)
918
919                                        else:
920                                                item['icon_package'].set_from_file(self.core.epiBox.package_installed_dep)
921
922                                else:
923                                        if order==0:
924                                                item['icon_package'].set_from_file(self.core.epiBox.package_availabled)
925                                        else:
926                                                item['icon_package'].set_from_file(self.core.epiBox.package_availabled_dep)
927
928
929                else:
930                        if dpkg_status !=None and len(dpkg_status)>0:
931                                for item in elements:
932                                        status=dpkg_status[item['icon_status'].id]
933                                        if process=="install":
934                                                if status=="installed":
935                                                        item['icon_status'].set_from_file(self.ok_image)
936                                                        if order==0:
937                                                                item["icon_package"].set_from_file(self.core.epiBox.package_installed) 
938                                                        else:
939                                                                item["icon_package"].set_from_file(self.core.epiBox.package_installed_dep)     
940               
941                                                else:
942                                                        item['icon_status'].set_from_file(self.error_image)
943
944                                                        if order==0:
945                                                                item["icon_package"].set_from_file(self.core.epiBox.package_availabled)
946                                                        else:
947                                                                item["icon_package"].set_from_file(self.core.epiBox.package_availabled_dep)
948
949                                        else:
950                                                if status=="availabled":
951                                                        item["icon_status"].set_from_file(self.ok_image)
952                                                else:
953                                                        item["icon_status"].set_from_file(self.error_image)     
954
955                        else:
956                                for item in elements:
957                                        item['icon_status'].set_from_file(self.error_image)                     
958
959
960        #def update_icon
961                                                                                                                       
962        def go_back(self,widget):
963
964                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
965                self.stack.set_visible_child_name("epiBox")             
966                self.apply_button.show()
967                self.return_button.hide()
968                self.show_apply_uninstall_buttons()
969
970        #def go_back   
971
972
973        def get_msg_text(self,code):
974
975                if code==0:
976                        msg=_("Application already installed")
977                elif code==1:
978                        msg=_("Application epi file does not exist")   
979                elif code==2:
980                        msg=_("You need root privileges")
981                elif code==3:
982                        msg=_("Internet connection not detected")
983                elif code==4:
984                        msg=_("Gathering Information...")
985                elif code==5:
986                        msg=_("Downloading application...")
987                elif code==6:
988                        msg=_("Preparing installation...")
989                elif code==7:
990                        msg=_("Installing application...")
991                elif code==8:
992                        msg=_("Ending the installation...")
993                elif code==9:
994                        msg=_("Installation completed successfully")
995                elif code==10:
996                        msg=_("Installation aborted. Error ending installation")
997                elif code==11:
998                        msg=_("Installation aborted. Error installing application")
999                elif code==12:
1000                        msg=_("Installation aborted. Error preparing system")
1001                elif code==13:
1002                        msg=_("Installation aborted. Unable to download package")
1003                elif code==14:
1004                        msg=_("Do you want uninstall the application?")
1005                elif code==15:
1006                        msg=_("Uninstall application...")
1007                elif code==16:
1008                        msg=_("Application successfully uninstalled")
1009                elif code==17:
1010                        msg=_("Uninstalled process ending with errors")
1011                elif code==18:
1012                        msg=_("Application epi file it is not a valid json")
1013
1014                return msg     
1015
1016        #def get_msg_text
1017
1018        def create_process_token(self,command,action):
1019
1020
1021                if action=="keys":
1022                        self.token_keys=tempfile.mkstemp('_keys')
1023                        remove_tmp=' rm -f ' + self.token_keys[1] + ';'+'\n'
1024                       
1025                elif action=="download":
1026                        self.token_download=tempfile.mkstemp('_download')
1027                        remove_tmp=' rm -f ' + self.token_download[1] + ';'+'\n'
1028
1029                elif action=="preinstall":
1030                        self.token_preinstall=tempfile.mkstemp('_preinstall')   
1031                        remove_tmp=' rm -f ' + self.token_preinstall[1] + ';'+'\n'
1032                       
1033                elif action=="install":
1034                        self.token_install=tempfile.mkstemp('_install')
1035                        remove_tmp=' rm -f ' + self.token_install[1] +';'+'\n'
1036
1037                elif action=="postinstall":     
1038                        self.token_postinstall=tempfile.mkstemp('_postinstall')
1039                        remove_tmp=' rm -f ' + self.token_postinstall[1] +';'+'\n'
1040
1041                elif action=="uninstall":
1042                        self.token_uninstall=tempfile.mkstemp('_uninstall')
1043                        remove_tmp=' rm -f ' + self.token_uninstall[1] +';'+'\n'
1044
1045                cmd=command+remove_tmp
1046                return cmd
1047
1048        #def create_process_token                       
1049
1050        def quit(self,widget):
1051
1052                msg_log='Quit'
1053                self.write_log(msg_log)
1054                self.core.epiManager.remove_repo_keys()
1055                Gtk.main_quit() 
1056
1057        #def quit       
1058
1059        def write_log_terminal(self,action):
1060
1061                init_row=self.final_row
1062                init_column=self.final_column
1063
1064                self.final_column,self.final_row = self.epiBox.vterminal.get_cursor_position()
1065                log_text=self.epiBox.vterminal.get_text_range(init_row,init_column,self.final_row,self.final_column)[0]
1066
1067                log_text=log_text.split("\n")
1068
1069               
1070                if action=="install":
1071                        syslog.openlog("EPI")
1072                        syslog.syslog("Install Application")
1073                else:
1074                        syslog.openlog("EPI")
1075                        syslog.syslog("Uninstall Application")
1076                               
1077               
1078                for item in log_text:
1079                        if item!="":
1080                                self.write_log(item)
1081                                                                                                                                                               
1082                return
1083
1084        #def write_log_terminal
1085
1086        def write_log(self,msg):
1087       
1088                syslog.openlog("EPI")
1089                syslog.syslog(msg)     
1090
1091        #def write_log 
1092
1093       
1094        def start_gui(self):
1095               
1096                GObject.threads_init()
1097                Gtk.main()
1098               
1099        #def start_gui
1100
1101       
1102
1103       
1104#class MainWindow
1105'''
1106
1107if __name__=="__main__":
1108       
1109        lgd.start_gui()
1110'''     
1111from . import Core
Note: See TracBrowser for help on using the repository browser.