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

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

Fix declaration of the threads

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