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

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

WIP in manage vterminal

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