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

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

Fix files

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