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

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

Improve performance

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