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

Last change on this file since 6717 was 6717, checked in by jrpelegrina, 20 months ago

Fixed files and addded logrotate

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