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

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

Fix bug when epi fas depends

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