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

Last change on this file since 7557 was 7557, checked in by jrpelegrina, 17 months ago

Added checking of valid epi file

File size: 25.6 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.init_install_process()
412                self.apply_button.set_sensitive(False)
413                self.uninstall_button.set_sensitive(False)
414               
415                if self.install_dep:
416                        if self.order>0:
417                                self.order=self.order-1
418                else:
419                        self.order=0
420
421                self.epiBox.terminal_label.set_name("MSG_LABEL")
422                self.core.epiManager.zerocenter_feedback(self.order,"init")     
423                GLib.timeout_add(100,self.pulsate_install_package,self.order)
424
425        #def install_processs
426
427
428        def pulsate_install_package(self,order):
429               
430                self.spinner_sync(order)
431                self.sp_cont=self.sp_cont+1
432                error=False
433
434                if not self.add_repository_keys_launched:
435                        self.epiBox.terminal_label.show()
436                        msg=self.get_msg_text(4)
437                        self.epiBox.terminal_label.set_text(msg)
438                        self.add_repository_keys_launched=True
439                        self.sp_cont=self.sp_cont+1
440                        if order==0:
441                                self.install_dep=False
442                               
443                        self.add_repository_keys(order)
444                       
445               
446                if self.add_repository_keys_done:
447                        if not self.download_app_launched:
448                                msg=self.get_msg_text(5)
449                                self.epiBox.terminal_label.set_text(msg)
450                                self.download_app_launched=True
451                                self.download_app()
452
453                        if self.download_app_done:
454
455                                if not self.check_download_launched:
456                                        self.check_download_launched=True
457                                        self.check_download()
458
459                                if self.check_download_done:
460                                        if self.download_result:       
461                                                                       
462                                                if not self.preinstall_app_launched:
463                                                        msg=self.get_msg_text(6)
464                                                        self.epiBox.terminal_label.set_text(msg)
465                                                        self.preinstall_app_launched=True
466                                                        self.preinstall_app()
467
468                                                if self.preinstall_app_done:   
469
470                                                        if not self.check_preinstall_launched:
471                                                                self.check_preinstall_launched=True
472                                                                self.check_preinstall()
473
474                                                        if self.check_preinstall_done:
475                                                               
476                                                               
477                                                                if self.preinstall_result:
478                                                                        if not self.install_app_launched:
479                                                                                msg=self.get_msg_text(7)
480                                                                                self.epiBox.terminal_label.set_text(msg)
481                                                                                self.install_app_launched=True
482                                                                                self.install_app()
483
484                                                                        if self.install_app_done:
485
486                                                                                if not self.check_install_launched:
487                                                                                        self.check_install_launched=True
488                                                                                        self.check_install()
489
490                                                                                       
491                                                                                if self.check_install_done:     
492                                                                                        if self.installed:
493                                                                                                if not self.postinstall_app_launched:
494                                                                                                        msg=self.get_msg_text(8)
495                                                                                                        self.epiBox.terminal_label.set_text(msg)
496                                                                                                        self.postinstall_app_launched=True
497                                                                                                        self.postinstall_app() 
498
499                                                                                                if self.postinstall_app_done:
500
501                                                                                                        if not self.check_postinstall_launched:
502                                                                                                                self.check_postinstall_launched=True
503                                                                                                                self.check_postinstall()
504
505                                                                                                        if self.check_postinstall_done:
506                                                                                                               
507                                                                                                                if self.postinstall_result:     
508                                                                                                                        params=[order,True,'install',None]
509                                                                                                                        self.update_icon(params)
510                                                                                                                        self.core.epiManager.zerocenter_feedback(self.order,"install",True)
511
512                                                                                                                        if self.order>0:
513                                                                                                                                self.order=self.order-1
514                                                                                                                                self.sp_cont=0
515                                                                                                                                self.init_install_process()
516                                                                                                                                GLib.timeout_add(100,self.pulsate_install_package,self.order)
517
518                                                                                                                        else:
519                                                                                                                                msg=self.get_msg_text(9)
520                                                                                                                                self.epiBox.terminal_label.set_name("MSG_CORRECT_LABEL")
521                                                                                                                                self.epiBox.terminal_label.set_text(msg)
522                                                                                                                                self.write_log_terminal('install')
523                                                                                                                                self.load_epi_conf[0]["status"]="installed"
524                                                                                                                                self.write_log(msg)
525                                                                                                                                self.show_apply_uninstall_buttons()
526                                                                                                                                self.core.epiManager.remove_repo_keys()
527
528                                                                                                                                return False
529                                                                                                                        return False
530
531                                                                                                                else:
532                                                                                                                        error=True
533                                                                                                                        error_code=10
534                                                                                                                        params=[order,False,'install',None]
535                                                                                        else:
536                                                                                                error=True
537                                                                                                error_code=11
538                                                                                                params=[order,False,'install',self.dpkg_status]
539                                                                                               
540                                                                else:
541                                                                        error=True
542                                                                        error_code=12
543                                                                        params=[order,False,'install',None]
544                                                                                                                                                               
545                                        else:
546                                                error=True
547                                                error_code=13
548                                                params=[order,False,'install',None]
549                                                                               
550
551                if error:
552                        msg_error=self.get_msg_text(error_code)
553                        self.epiBox.terminal_label.set_name("MSG_ERROR_LABEL")
554                        self.epiBox.terminal_label.set_text(msg_error)
555                        self.update_icon(params)
556                        self.core.epiManager.zerocenter_feedback(params[0],"install",False)
557                        self.write_log_terminal('install')
558                        self.write_log(msg_error)
559                        self.core.epiManager.remove_repo_keys()
560                        return False
561
562                if self.add_repository_keys_launched:
563                       
564                        if      not self.add_repository_keys_done:
565                                if os.path.exists(self.token_keys[1]):
566                                        return True
567                                else:
568                                       
569                                        self.add_repository_keys_done=True
570                                        return True
571               
572                if self.download_app_launched:
573                       
574                        if      not self.download_app_done:
575                                if os.path.exists(self.token_download[1]):
576                                        return True
577                                else:
578                                        self.download_app_done=True
579                                        return True     
580
581                if self.check_download_launched:
582                        if not self.check_download_done:
583                                return True                     
584               
585                if self.preinstall_app_launched:
586                       
587                        if      not self.preinstall_app_done:
588                                if os.path.exists(self.token_preinstall[1]):
589                                        return True
590                                else:
591                                        self.preinstall_app_done=True
592                                        return True             
593
594                if self.check_preinstall_launched:
595                        if not self.check_preinstall_done:
596                                return                         
597
598                if self.install_app_launched:
599                       
600                        if      not self.install_app_done:
601                                if os.path.exists(self.token_install[1]):
602                                        return True
603                                else:
604                                        self.install_app_done=True
605                                        return True             
606
607                if self.check_install_launched:
608                        if not self.check_install_done:
609                                return True
610
611
612                if self.postinstall_app_launched:
613                       
614                        if      not self.postinstall_app_done:
615                                if os.path.exists(self.token_postinstall[1]):
616                                        return True
617                                else:
618                                        self.postinstall_app_done=True
619                                        return True             
620
621                if self.check_postinstall_launched:
622                        if not self.check_postinstall_done:
623                                return                                                                         
624
625        #def pulsate_install_package                           
626
627        def add_repository_keys(self,order):
628
629                command=self.core.epiManager.add_repository_keys(order)
630                length=len(command)
631                if length>0:
632                        command=self.create_process_token(command,"keys")
633                        length=len(command)
634                        self.epiBox.vterminal.feed_child(command,length)
635                else:
636                        self.add_repository_keys_done=True
637
638        #def add_repository_keys               
639
640        def download_app(self):
641
642                command=self.core.epiManager.download_app()
643                length=len(command)
644                if length>0:
645                        command=self.create_process_token(command,"download")
646                        length=len(command)
647                        self.epiBox.vterminal.feed_child(command,length)
648                else:
649                        self.download_app_done=True     
650
651        #def download_app               
652
653        def check_download(self):
654
655                self.download_result=self.core.epiManager.check_download()
656                self.check_download_done=True
657
658        #def check_download
659
660        def check_preinstall(self):
661
662                self.preinstall_result=self.core.epiManager.check_preinstall()
663                self.check_preinstall_done=True
664
665        #def check_preinstall           
666
667       
668        def preinstall_app(self):
669
670                command=self.core.epiManager.preinstall_app()
671
672                length=len(command)
673                if length>0:
674                        command=self.create_process_token(command,"preinstall")
675                        length=len(command)
676                        self.epiBox.vterminal.feed_child(command,length)
677
678                else:
679                        self.preinstall_app_done=True                   
680
681        #def preinstall_app             
682
683
684        def install_app(self):
685
686                command=self.core.epiManager.install_app()
687
688                length=len(command)
689                if length>0:
690                        command=self.create_process_token(command,"install")
691                        length=len(command)
692                        self.epiBox.vterminal.feed_child(command,length)
693                else:
694                        self.install_app_done=True     
695
696         #def install_app
697
698        def check_install(self):
699
700                self.dpkg_status,self.installed=self.core.epiManager.check_install_remove("install")
701                self.check_install_done=True
702
703        #def check_install     
704
705        def postinstall_app(self):
706
707                command=self.core.epiManager.postinstall_app()
708                length=len(command)
709                if length>0:
710                        command=self.create_process_token(command,"postinstall")
711                        length=len(command)
712                        self.epiBox.vterminal.feed_child(command,length)
713                else:
714                        self.postinstall_app_done=True                 
715
716        #def postinstall_app
717
718        def check_postinstall(self):
719
720                self.postinstall_result=self.core.epiManager.check_postinstall()
721                self.check_postinstall_done=True
722
723        #def check_postinstall                                 
724
725        def init_uninstall_process(self):
726
727                self.remove_package_launched=False
728                self.remove_package_done=False
729
730                self.check_remove_launched=False
731                self.check_remove_done=False
732
733        #def init_uninstall_process     
734
735        def uninstall_process(self,widget):
736
737                dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO, "EPI-GTK")
738                msg=self.get_msg_text(14)
739                dialog.format_secondary_text(msg)
740                response=dialog.run()
741                dialog.destroy()
742               
743
744                if response==Gtk.ResponseType.YES:
745
746                        self.sp_cont=0
747                        self.epiBox.terminal_scrolled.show()
748                        self.epiBox.viewport.show()
749                        self.init_uninstall_process()
750                        self.apply_button.set_sensitive(False)
751                        self.uninstall_button.set_sensitive(False)
752                        self.epiBox.terminal_label.set_name("MSG_LABEL")
753                       
754                        GLib.timeout_add(100,self.pulsate_uninstall_process,0)
755
756        #def uninstall_process         
757
758
759        def pulsate_uninstall_process(self,order):
760
761                self.spinner_sync(order)
762                self.sp_cont=self.sp_cont+1
763               
764                if not self.remove_package_launched:
765                        self.epiBox.terminal_label.show()
766                        msg=self.get_msg_text(15)
767                        self.epiBox.terminal_label.set_text(msg)
768                        self.remove_package_launched=True
769                        self.sp_cont=self.sp_cont+1
770                        self.uninstall_app(order)
771
772
773                if self.remove_package_done:
774
775                        if not self.check_remove_launched:
776                                self.check_remove_launched=True
777                                self.check_remove()
778                       
779                        if self.check_remove_done:
780                               
781                                if self.remove:
782                                        msg=self.get_msg_text(16)
783                                        self.epiBox.terminal_label.set_name("MSG_CORRECT_LABEL")
784                                        self.epiBox.terminal_label.set_text(msg)
785                                        params=[order,True,'remove',None]
786                                        self.update_icon(params)
787                                        self.load_epi_conf[0]["status"]="availabled"
788                                        self.show_apply_uninstall_buttons()
789                                        if self.order==0:
790                                                self.install_dep=False
791                                        self.core.epiManager.zerocenter_feedback(0,"uninstall",True)
792                                        self.write_log_terminal('uninstall')
793                                        self.write_log(msg)
794                                        return False
795                                else:
796                                        msg=self.get_msg_text(17)
797                                        self.epiBox.terminal_label.set_name("MSG_ERROR_LABEL")
798                                        self.epiBox.terminal_label.set_text(msg)
799                                        params=[order,False,'remove',self.dpkg_status]
800                                        self.update_icon(params)
801                                        self.core.epiManager.zerocenter_feedback(0,"uninstall",False)
802                                        self.write_log_terminal('unistall')
803                                        self.write_log(msg)
804                                        return False
805
806       
807
808                if self.remove_package_launched:
809                        if      not self.remove_package_done:
810                                if os.path.exists(self.token_uninstall[1]):
811                                        return True
812                                else:
813                                        self.remove_package_done=True
814                                        return True             
815
816                if self.check_remove_launched:
817                        if not self.check_remove_done:
818                                return True                             
819
820        #def pulsate_uninstall_process                         
821
822
823        def uninstall_app(self,order):
824
825                command=self.core.epiManager.uninstall_app(order)
826
827                length=len(command)
828                if length>0:
829                        command=self.create_process_token(command,"uninstall")
830                        length=len(command)
831                        self.epiBox.vterminal.feed_child(command,length)
832
833                else:
834                        self.preinstall_app_done=True   
835
836        #def uninstall_app     
837
838        def check_remove(self):
839
840                self.dpkg_status,self.remove=self.core.epiManager.check_install_remove("uninstall")
841                self.check_remove_done=True
842
843        #def check_remove       
844
845        def update_icon(self,params):
846
847                order=params[0]
848                result=params[1]
849                process=params[2]
850                dpkg_status=params[3]
851
852                elements=self.epiBox.update_icons[order]
853
854                elements=self.epiBox.update_icons[order]
855                for item in elements:
856                        item['icon_status'].set_from_file(self.img)
857
858                if result:
859                        for item in elements:
860                                item['icon_status'].set_from_file(self.ok_image)
861                                if process=="install":
862                                        if order==0:
863                                                item['icon_package'].set_from_file(self.core.epiBox.package_installed)
864
865                                        else:
866                                                item['icon_package'].set_from_file(self.core.epiBox.package_installed_dep)
867
868                                else:
869                                        if order==0:
870                                                item['icon_package'].set_from_file(self.core.epiBox.package_availabled)
871                                        else:
872                                                item['icon_package'].set_from_file(self.core.epiBox.package_availabled_dep)
873
874
875                else:
876                        if dpkg_status !=None and len(dpkg_status)>0:
877                                for item in elements:
878                                        status=dpkg_status[item['icon_status'].id]
879                                        if process=="install":
880                                                if status=="installed":
881                                                        item['icon_status'].set_from_file(self.ok_image)
882                                                        if order==0:
883                                                                item["icon_package"].set_from_file(self.core.epiBox.package_installed) 
884                                                        else:
885                                                                item["icon_package"].set_from_file(self.core.epiBox.package_installed_dep)     
886               
887                                                else:
888                                                        item['icon_status'].set_from_file(self.error_image)
889
890                                                        if order==0:
891                                                                item["icon_package"].set_from_file(self.core.epiBox.package_availabled)
892                                                        else:
893                                                                item["icon_package"].set_from_file(self.core.epiBox.package_availabled_dep)
894
895                                        else:
896                                                if status=="availabled":
897                                                        item["icon_status"].set_from_file(self.ok_image)
898                                                else:
899                                                        item["icon_status"].set_from_file(self.error_image)     
900
901                        else:
902                                for item in elements:
903                                        item['icon_status'].set_from_file(self.error_image)                     
904
905
906        #def update_icon
907                                                                                                                       
908        def go_back(self,widget):
909
910                self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_RIGHT)
911                self.stack.set_visible_child_name("epiBox")             
912                self.apply_button.show()
913                self.return_button.hide()
914                self.show_apply_uninstall_buttons()
915
916        #def go_back   
917
918
919        def get_msg_text(self,code):
920
921                if code==0:
922                        msg=_("Application already installed")
923                elif code==1:
924                        msg=_("Application epi file does not exist")   
925                elif code==2:
926                        msg=_("You need root privileges")
927                elif code==3:
928                        msg=_("Internet connection not detected")
929                elif code==4:
930                        msg=_("Gathering Information...")
931                elif code==5:
932                        msg=_("Downloading application...")
933                elif code==6:
934                        msg=_("Preparing installation...")
935                elif code==7:
936                        msg=_("Installing application...")
937                elif code==8:
938                        msg=_("Ending the installation...")
939                elif code==9:
940                        msg=_("Installation completed successfully")
941                elif code==10:
942                        msg=_("Installation aborted. Error ending installation")
943                elif code==11:
944                        msg=_("Installation aborted. Error installing application")
945                elif code==12:
946                        msg=_("Installation aborted. Error preparing system")
947                elif code==13:
948                        msg=_("Installation aborted. Unable to download package")
949                elif code==14:
950                        msg=_("Do you want uninstall the application?")
951                elif code==15:
952                        msg=_("Uninstall application...")
953                elif code==16:
954                        msg=_("Application successfully uninstalled")
955                elif code==17:
956                        msg=_("Uninstalled process ending with errors")
957                elif code==18:
958                        msg=_("Application epi file it is not a valid json")
959
960                return msg     
961
962        #def get_msg_text
963
964        def create_process_token(self,command,action):
965
966
967                if action=="keys":
968                        self.token_keys=tempfile.mkstemp('_keys')
969                        remove_tmp=' rm -f ' + self.token_keys[1] + ';'+'\n'
970                       
971                elif action=="download":
972                        self.token_download=tempfile.mkstemp('_download')
973                        remove_tmp=' rm -f ' + self.token_download[1] + ';'+'\n'
974
975                elif action=="preinstall":
976                        self.token_preinstall=tempfile.mkstemp('_preinstall')   
977                        remove_tmp=' rm -f ' + self.token_preinstall[1] + ';'+'\n'
978                       
979                elif action=="install":
980                        self.token_install=tempfile.mkstemp('_install')
981                        remove_tmp=' rm -f ' + self.token_install[1] +';'+'\n'
982
983                elif action=="postinstall":     
984                        self.token_postinstall=tempfile.mkstemp('_postinstall')
985                        remove_tmp=' rm -f ' + self.token_postinstall[1] +';'+'\n'
986
987                elif action=="uninstall":
988                        self.token_uninstall=tempfile.mkstemp('_uninstall')
989                        remove_tmp=' rm -f ' + self.token_uninstall[1] +';'+'\n'
990
991                cmd=command+remove_tmp
992                return cmd
993
994        #def create_process_token                       
995
996        def quit(self,widget):
997
998                msg_log='Quit'
999                self.write_log(msg_log)
1000                self.core.epiManager.remove_repo_keys()
1001                Gtk.main_quit() 
1002
1003        #def quit       
1004
1005        def write_log_terminal(self,action):
1006
1007                init_row=self.final_row
1008                init_column=self.final_column
1009
1010                self.final_column,self.final_row = self.epiBox.vterminal.get_cursor_position()
1011                log_text=self.epiBox.vterminal.get_text_range(init_row,init_column,self.final_row,self.final_column)[0]
1012
1013                log_text=log_text.split("\n")
1014
1015               
1016                if action=="install":
1017                        syslog.openlog("EPI")
1018                        syslog.syslog("Install Application")
1019                else:
1020                        syslog.openlog("EPI")
1021                        syslog.syslog("Uninstall Application")
1022                               
1023               
1024                for item in log_text:
1025                        if item!="":
1026                                self.write_log(item)
1027                                                                                                                                                               
1028                return
1029
1030        #def write_log_terminal
1031
1032        def write_log(self,msg):
1033       
1034                syslog.openlog("EPI")
1035                syslog.syslog(msg)     
1036
1037        #def write_log 
1038
1039       
1040        def start_gui(self):
1041               
1042                GObject.threads_init()
1043                Gtk.main()
1044               
1045        #def start_gui
1046
1047       
1048
1049       
1050#class MainWindow
1051'''
1052
1053if __name__=="__main__":
1054       
1055        lgd.start_gui()
1056'''     
1057from . import Core
Note: See TracBrowser for help on using the repository browser.