Changeset 8613


Ignore:
Timestamp:
Apr 2, 2019, 2:29:53 PM (3 weeks ago)
Author:
daduve
Message:

KernelBox? file was modify with old version

Location:
first-aid-kit/trunk/fuentes
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • first-aid-kit/trunk/fuentes/debian/changelog

    r8612 r8613  
     1first-aid-kit (0.0.5) xenial; urgency=high
     2
     3  * KernelBox file was modify with old version
     4
     5 -- Daniel Duran Vecino <daduve@gmail.com>  Tue, 02 Apr 2019 14:28:38 +0200
     6
    17first-aid-kit (0.0.4) xenial; urgency=high
    28
  • first-aid-kit/trunk/fuentes/first-aid-kit.install/usr/share/first-aid-kit/KernelBox.py

    r8612 r8613  
    1616import platform
    1717import copy
     18import shutil
    1819
    1920gettext.textdomain('first-aid-kit-gui')
     
    4344                        self.kernel_label=builder.get_object("kernel_label")
    4445                        self.kernel_vp=builder.get_object("viewport3")
     46                        self.kernel_sw=builder.get_object("scrolledwindow4")
    4547                        self.info_box_kernel=builder.get_object("info_kernel")
    4648                        self.txt_check_kernel=builder.get_object("txt_check_kernel")
     
    5254                        self.filter_kernels_button=builder.get_object("kernel_filter_button")
    5355                        self.apply_kernel_button=builder.get_object("apply_kernel_button")
     56                        self.kernel_combobox=builder.get_object("kernel_combobox")
     57                        self.kernel_combobox_spinner=builder.get_object("kernel_combobox_spinner")
     58                        self.switch_kernel_installed=builder.get_object("switch_kernel_installed")
     59                        self.kernel_installed_spinner=builder.get_object("kernel_installed_spinner")
    5460                       
    5561
     
    94100
    95101                        self.flag_installed=False
     102                        self.kernel_combobox_spinner_active=False
     103
     104                        self.kernel_installed_filter_active=False
     105                        self.switch_kernel_installed.set_state(False)
     106                        self.switch_kernel_installed.set_sensitive(False)
     107
     108                        self.init_kernel_boot_store()
    96109                        self.connect_signals()
    97110                        self.set_css_info()
    98111                        self.load_kernels()
    99112
    100                        
    101                 except Exception as e:
    102                         self.core.dprint("Error in KernelBox: %s"%e)
     113
     114                       
     115                except Exception as e:
     116                        self.core.dprint("(KernelBox)Error: %s"%e)
    103117               
    104118        #def __init__
     
    109123
    110124
     125
     126
     127
    111128        def set_css_info(self):
     129
    112130               
    113131                self.style_provider=Gtk.CssProvider()
     
    135153
    136154
     155
     156
     157
    137158        def connect_signals(self):
     159
    138160               
    139161                self.update_kernels_button.connect("clicked",self.update_kernels_button_clicked)
    140                 self.apply_kernel_button.connect("clicked",self.get_checked_kernels)
     162                self.apply_kernel_button.connect("clicked",self.set_kernel_default)
    141163                self.filter_kernels_button.connect("clicked",self.filter_kernels_button_clicked)
    142164                self.entry_kernel.connect("activate",self.entries_press_event)
     165                self.switch_kernel_installed.connect("notify::active",self.kernel_installed_filter)
    143166               
    144167        #def connect_signals
     
    146169
    147170
    148 
    149 
    150171        def entries_press_event(self,widget):
    151172               
     
    153174               
    154175        #def entries_press_event
     176
     177
     178
     179
     180
     181
     182        def init_kernel_boot_store(self):
     183
     184                #PRINT KERNEL COMBOBOX
     185
     186                #self.core.dprint("Combobox Kernel: %s"%self.kernel_installed_boot)
     187                renderer=Gtk.CellRendererText()
     188                self.kernel_combobox.pack_start(renderer,True)
     189                self.kernel_combobox.add_attribute(renderer,"text",0)
     190                self.kernel_installed_boot=Gtk.ListStore(str)
     191                self.kernel_combobox.set_model(self.kernel_installed_boot)
     192                self.kernel_combobox.set_active(0)
     193
     194        #def kernel_boot
     195
     196
     197
     198        def read_kernel_default(self):
     199                # SET IN COMBOBOX WICH KERNEL IS ACTIVE AT THE MOMENT.
     200                try:
     201                        #GRUB DEFAULT EXISTS? DEFINE POSITION, BUT NOT WICH KERNEL NUMBER
     202                        grub_file='/etc/default/grub'
     203                        f_orig=open(grub_file)
     204                        lines=f_orig.readlines()
     205                        f_orig.close()
     206                        line_writed=False
     207
     208                        for line in lines:
     209                                if "GRUB_DEFAULT=" in line:
     210                                        kernel_default_pos=line.replace('GRUB_DEFAULT=','')
     211                                        kernel_default_pos=kernel_default_pos.split()[0]
     212                                        break
     213                                else:
     214                                        kernel_default_pos="0>0"
     215
     216
     217                        ######### ESTO FUNCIONA DE LUJO NO TOCAR ACUERDATE QUE POSEES COSAS ANULADAS ABAJO Y QUE LA GUI DE GLADE NO ESTA ORGANIZANDOME EL BOX COMO QUIERO
     218                        #CHECK WICH KERNEL NUMBER IS ACTIVE, IF POSITION IS DEFINED IN GRUB DEFAUTL OR 0>0 BY DEFAULT.
     219                        kernel_file="/tmp/.first-aid-kit_set-kernel.%s"%self.core.current_user
     220                        os.system('/usr/share/first-aid-kit/grub-listmenu.sh > %s'%kernel_file)
     221                        f=open(kernel_file)
     222                        lines=f.readlines()
     223                        f.close()
     224                        os.remove(kernel_file)
     225
     226                        finded=False
     227                        for line in lines:
     228                                if kernel_default_pos in line:
     229                                        line=line.replace(kernel_default_pos,'')
     230                                        if "-generic" in line:
     231                                                line=line.replace('-generic','')
     232                                        if "LliureX 16" in line:
     233                                                line=line.replace('LliureX 16','')
     234
     235                                        newstr = ''.join((ch if ch in '0123456789.-' else ' ') for ch in line)
     236                                        kernel_active = [str(i) for i in newstr.split()]
     237                                        finded=True
     238                                        break
     239
     240                        #SELECT KERNEL ACTIVE IN COMBOBOX
     241                        pos=0
     242                        if finded:
     243                                for k in kernel_active:
     244                                        for i in self.kernel_installed_boot:
     245                                                element=(i[:])[0]
     246                                                #print ('%s element: %s'%(pos,element))
     247                                                if str(k)==str(element):
     248                                                        #print 'eureka'
     249                                                        return pos
     250                                                pos+=1
     251
     252                        #print pos
     253                        #print 'SALIDA'
     254                        return pos
     255
     256
     257                except Exception as e:
     258                        return 0
     259                        self.core.dprint("(read_kernel_default) Error: %s"%e)
     260        #def read_kernel_default
     261
     262
     263
     264
     265        def set_kernel_default(self,widget):
     266                #SET KERNEL DEFAULT IN COMBOBOX
     267                try:
     268                        it=self.kernel_combobox.get_active_iter()
     269                        kernel_selected=self.kernel_installed_boot.get(it,0)[0]
     270                        #self.kernel_po=self.eth_wharehouse[eth_selected]
     271                        self.core.dprint("(set_kernel_default)Kernel default selected: %s  "%(kernel_selected))
     272
     273                        kernel_file="/tmp/.first-aid-kit_set-kernel.%s"%self.core.current_user
     274                        os.system('/usr/share/first-aid-kit/grub-listmenu.sh > %s'%kernel_file)
     275                        f=open(kernel_file)
     276                        lines=f.readlines()
     277                        f.close()
     278                        os.remove(kernel_file)
     279
     280                       
     281                        for line in lines:
     282                                if kernel_selected in line:
     283                                        if not "recovery" in line:
     284                                                default_grub_option=line.split()[0]
     285
     286                        self.core.dprint("(set_kernel_default)Kernel defautl position in Grub: %s"%(default_grub_option))
     287
     288                        grub_file='/etc/default/grub'
     289                        f_orig=open(grub_file)
     290                        lines=f_orig.readlines()
     291                        f_orig.close()
     292
     293                        grub_file_tmp='/tmp/.grub'
     294                        f_copy=open(grub_file_tmp,"wt")
     295
     296                        line_writed=False
     297                        for line in lines:
     298                                if "GRUB_DEFAULT=" in line:
     299                                        f_copy.write("GRUB_DEFAULT=%s\n"%default_grub_option)
     300                                        line_writed=True
     301                                else:
     302                                        f_copy.write(line)
     303                       
     304                        if not line_writed:
     305                                f_copy.write("GRUB_DEFAULT=%s\n"%default_grub_option)
     306                        f_copy.close()
     307
     308                        shutil.copy(grub_file_tmp,grub_file)
     309
     310                        self.info_box_stack.set_visible_child_name("info_kernel")
     311                        self.txt_check_kernel.set_text(_("You have a new kernel boot by defect: %s"%kernel_selected))
     312                        self.core.dprint("You have a new kernel boot by defect: %s"%kernel_selected)
     313
     314                except Exception as e:
     315                        self.core.dprint("(set_kernel_default) Error: %s"%e)
     316       
     317        #def set_kernel_default
     318
     319
     320
     321
     322
     323
     324
     325        def kernel_installed_filter(self,widget,params):
     326               
     327                try:
     328                        if self.switch_kernel_installed.get_active():
     329                                self.kernel_installed_filter_active=True
     330                        else:
     331                                self.kernel_installed_filter_active=False
     332
     333                        self.switch_kernel_installed.set_sensitive(False)
     334                        self.update_kernels_button.set_sensitive(False)
     335                        self.filter_kernels_button.set_sensitive(False)
     336                        self.apply_kernel_button.set_sensitive(False)
     337                        self.entry_kernel.set_can_focus(False)
     338                        self.kernel_box_stack.set_visible_child_name("spinner")
     339
     340
     341                        allocation=self.switch_kernel_installed.get_allocation()
     342                        w=allocation.width
     343                        h=allocation.height
     344                       
     345                        self.switch_kernel_installed.hide()
     346                        self.kernel_installed_spinner.start()
     347                        self.kernel_installed_spinner.set_size_request(w,h)
     348                        self.kernel_installed_spinner.show()
     349
     350                        self.info_box_stack.set_visible_child_name("info_kernel")
     351                        self.txt_check_kernel.set_text(_("Applying filter to show only installed kernels...please wait"))
     352                        self.core.dprint("Applying filter to show only installed kernels...please wait")
     353
     354                        self.show_kernel_results()
     355
     356                except Exception as e:
     357                        self.core.dprint("(kernel_installed_filter) Error: %s"%e)
     358               
     359        #def kernel_installed_filter
    155360
    156361
     
    169374                        self.filter_kernels_button.set_sensitive(False)
    170375                        self.apply_kernel_button.set_sensitive(False)
     376                        self.switch_kernel_installed.set_sensitive(False)
    171377                        self.kernel_box_stack.set_visible_child_name("spinner")
    172378
     
    178384
    179385                except Exception as e:
    180                         self.core.dprint("Error in update_kernels_button_clicked: %s"%e)
     386                        self.core.dprint("(filter_kernels_button_clicked) Error: %s"%e)
    181387
    182388        #def filter_kernels_button_clicked
     
    190396        def update_kernels_button_clicked (self,widget):
    191397                try:
     398
    192399                        self.entry_kernel.set_can_focus(False)
    193400                        self.kernel_filter=self.entry_kernel.get_text().split()
     
    196403                        self.filter_kernels_button.set_sensitive(False)
    197404                        self.apply_kernel_button.set_sensitive(False)
     405                        self.switch_kernel_installed.set_sensitive(False)
     406                       
     407                        for i in self.kernel_list_box:
     408                                self.kernel_list_box.remove(i)
     409
    198410                        self.kernel_box_stack.set_visible_child_name("spinner")
     411                        self.kernel_box_stack.set_size_request(0,0)
     412
     413                        allocation=self.kernel_combobox.get_allocation()
     414                        w=allocation.width
     415                        h=allocation.height
     416                       
     417                        self.kernel_combobox.hide()
     418                        self.kernel_combobox_spinner.start()
     419                        self.kernel_combobox_spinner.set_size_request(w,h)
     420                        self.kernel_combobox_spinner.show()
     421                        self.kernel_combobox_spinner_active=True
    199422
    200423                        self.info_box_stack.set_visible_child_name("info_kernel")
     
    206429                        self.thread_up.start()
    207430
     431                        self.kernel_vp.set_size_request(0,0)
     432                        self.kernel_sw.get_vadjustment().set_page_size(0)
     433                        self.kernel_sw.get_hadjustment().set_page_size(0)
     434                        self.kernel_sw.set_size_request(0,0)
     435                        print("hola")
     436
    208437                        GLib.timeout_add(500,self.check_update_kernels_thread)
    209438
    210439                except Exception as e:
    211                         self.core.dprint("Error in update_kernels_button_clicked: %s"%e)
     440                        self.core.dprint("(update_kernels_button_clicked) Error: %s"%e)
    212441
    213442        #def update_kernels_button_clicked
     
    222451                               
    223452                except Exception as e:
    224                         self.core.dprint("Error in update_kernels_thread: %s"%e)       
     453                        self.core.dprint("(update_kernels_thread) Error: %s"%e)
    225454
    226455        #def update_kernels_thread
     
    237466
    238467                except Exception as e:
    239                         self.core.dprint("Error in check_update_kernels_thread: %s"%e)
     468                        self.core.dprint("(check_update_kernels_thread) Error: %s"%e)
    240469
    241470        #def check_update_kernels_thread
     
    255484                        self.filter_kernels_button.set_sensitive(False)
    256485                        self.apply_kernel_button.set_sensitive(False)
     486                        self.switch_kernel_installed.set_sensitive(False)
     487                        self.switch_kernel_installed.set_sensitive(False)
     488
     489
     490                       
    257491                        self.read_kernels()
    258492                               
    259493                except Exception as e:
    260                         self.core.dprint("Error in load_kernels: %s"%e)
     494                        self.core.dprint("(load_kernels) Error: %s"%e) 
    261495
    262496        #def load_kernels
     
    265499
    266500
    267 
    268 
    269 
    270501        def read_kernels(self):
    271502
    272503                try:
     504                        if self.kernel_combobox_spinner_active:
     505
     506                                allocation=self.kernel_combobox.get_allocation()
     507                                w=allocation.width
     508                                h=allocation.height
     509                               
     510                                self.kernel_combobox.hide()
     511                                self.kernel_combobox_spinner.start()
     512                                self.kernel_combobox_spinner.set_size_request(w,h)
     513                                self.kernel_combobox_spinner.show()
     514
    273515                        self.thread=threading.Thread(target=self.read_kernels_thread)
    274516                        self.thread.daemon=True
     
    276518
    277519                        self.core.dprint("Reading kernels avaiables..........")
    278 
     520                        self.kernel_installed_boot.clear()
    279521                        GLib.timeout_add(500,self.check_read_kernels_thread)
    280522
    281523                except Exception as e:
    282                         self.core.dprint("Error in read_kernels: %s"%e)
     524                        self.core.dprint("(read_kernels) Error: %s"%e)
    283525
    284526        #def read_kernels
     
    302544                        self.installed=[]
    303545                        self.kernel_count_orig=0
    304 
     546                       
    305547                        for i in pkgs:
    306548                                if not 'linux-headers-generic' == str(i):
     
    317559                                                                                self.installed.append(version)
    318560                                                                                self.avaiable.append((version,str(i),True,linux_image))
     561
     562                                                                                self.kernel_installed_boot.append([version])
    319563                                                                                self.kernel_count_orig=self.kernel_count_orig+1
    320564                                                                                #print ('%s is installed'%version)
     
    328572                                                                                self.installed.append(version)
    329573                                                                                self.avaiable.append((version,str(i),True,linux_image))
     574                                                                                self.kernel_installed_boot.append([version])
    330575                                                                                self.kernel_count_orig=self.kernel_count_orig+1
    331576                                                                                #print ('%s is installed'%version)
     
    333578                                                                                self.avaiable.append((version,str(i),False,linux_image))
    334579
     580                        #self.kernel_boot()
    335581                        self.filtered=[]
    336582                        if len(self.kernel_filter)>0:
     
    349595                                self.avaiable=self.filtered
    350596
     597
     598
    351599                        #print self.avaiable
    352600
    353601                except Exception as e:
    354                         self.core.dprint("Error in tread_read_kernels: %s"%e)
     602                        self.core.dprint("(read_kernels_thread) Error: %s"%e)
    355603
    356604        #def read_kernels
     
    363611                                return True
    364612
    365                         count=len(self.avaiable)
     613                        self.show_kernel_results()
     614
     615                except Exception as e:
     616                        self.core.dprint("(check_read_kernels_thread) Error: %s"%e)
     617
     618        #def check_read_kernels_thread
     619
     620
     621
     622
     623        def show_kernel_results(self):
     624                try:
     625
     626                        #count=len(self.avaiable)
     627                        count=0
    366628
    367629                        for i in self.kernel_list_box:
     
    370632                        for kernel in self.avaiable:
    371633
    372                                 hbox=Gtk.HBox()
    373                                 label=Gtk.Label(kernel[0])
    374                                 label.set_alignment(0,0)
    375                                 cb=Gtk.CheckButton()
    376                                 cb.set_halign(Gtk.Align.END)
    377                                 hbox.pack_start(label,True,True,0)
    378                                 hbox.pack_end(cb,True,True,0)
    379                                 hbox.set_margin_left(10)
    380                                 hbox.set_margin_right(10)
    381                                 hbox.show_all()
    382                                 hbox.checkbutton=cb
    383                                 hbox.label=label.get_text()
    384                                 hbox.data=kernel
    385                                 if kernel[2]:
    386                                         hbox.checkbutton.set_active(True)
    387                                 #hbox.set_name("PKG_BOX")
    388                                 self.kernel_list_box.pack_start(hbox,False,False,5)
    389 
     634                                if self.kernel_installed_filter_active:
     635                                        if kernel[2]:
     636                                                count=count+1
     637                                                self.generate_element_list(kernel)
     638                                else:
     639                                        count=count+1
     640                                        self.generate_element_list(kernel)
    390641                               
    391642                                count-=1
     
    404655                        self.apply_kernel_button.set_sensitive(True)
    405656                        self.entry_kernel.set_can_focus(True)
     657
     658                        self.kernel_installed_spinner.hide()
     659                       
     660
     661                        self.switch_kernel_installed.show()
     662                        self.switch_kernel_installed.set_sensitive(True)
     663                       
     664                        self.kernel_combobox.set_active(self.read_kernel_default())
     665                        self.kernel_combobox.show()
     666                        self.kernel_combobox_spinner.hide()
     667                        self.kernel_combobox_spinner_active=False
    406668                       
    407669                        if not self.flag_installed:
     
    413675
    414676                except Exception as e:
    415                         self.core.dprint("Error in check_read_kernels_thread: %s"%e)
    416         #def check_read_kernels_thread
    417 
    418 
    419 
    420 
    421 
    422 
    423 
    424 
    425 
    426         def get_checked_kernels(self,widget=None):
    427                
    428                 try:
     677                        self.core.dprint("(show_kernel_results) Error: %s"%e)
     678       
     679        #def show_kernel_results
     680
     681
     682
     683
     684
     685
     686        def generate_element_list(self,kernel):
     687                try:
     688                        hbox=Gtk.HBox()
     689                        label=Gtk.Label(kernel[0])
     690                        label.set_alignment(0,0)
     691                        #cb=Gtk.CheckButton()
     692                        cb=Gtk.Button()
     693                        cb.set_halign(Gtk.Align.END)
     694                        hbox.pack_start(label,True,True,0)
     695                        hbox.pack_end(cb,True,True,0)
     696                        hbox.set_margin_left(10)
     697                        hbox.set_margin_right(10)
     698                        hbox.show_all()
     699                        cb.label=label.get_text()
     700                        cb.data=kernel
     701                        hbox.checkbutton=cb
     702                        if kernel[2]:
     703                                #hbox.checkbutton.set_active(True)
     704                                hbox.checkbutton.set_label(_("Uninstall"))
     705                                hbox.checkbutton.set_name("UNINSTALL_BUTTON")
     706                                hbox.checkbutton.connect("clicked",self.uninstall_clicked)
     707                        else:
     708                                hbox.checkbutton.set_label(_("Install"))
     709                                hbox.checkbutton.set_name("INSTALL_BUTTON")
     710                                hbox.checkbutton.connect("clicked",self.install_clicked)
     711                       
     712                        #hbox.set_name("PKG_BOX")
     713                        self.kernel_list_box.pack_start(hbox,False,False,5)
     714
     715                except Exception as e:
     716                        self.core.dprint("(generate_element_list) Error: %s"%e)
     717       
     718        #def generate_element_list
     719
     720
     721
     722        def uninstall_clicked(self,widget):
     723
     724                try:
     725                        #CANCEL OPERATION IF THIS KERNEL IS IN USE AT THE MOMENT OR KERNEL IS IN META LLIUREX
     726                        kernel_file='/tmp/.uname'
     727                        os.system('uname -r > %s'%kernel_file)
     728                        f=open(kernel_file)
     729                        lines=f.readlines()
     730                        f.close()
     731                        os.remove(kernel_file)
     732
     733                        for line in lines:
     734                                if widget.label in line:
     735                                        mw=self.core.lri.main_window
     736                                        d=Dialog.InfoDialog(mw,_("First Aid Kit"),_("You can't delete this kernel because you are using now."))
     737                                        response=d.run()
     738                                        d.destroy()
     739                                        self.core.dprint("You can't delete this kernel because you are using now.: %s"%(widget.label))
     740                                        self.update_kernels_button.set_sensitive(True)
     741                                        self.filter_kernels_button.set_sensitive(True)
     742                                        self.apply_kernel_button.set_sensitive(True)
     743                                        self.entry_kernel.set_can_focus(True)
     744                                        self.switch_kernel_installed.set_sensitive(True)
     745
     746                                        return True
     747
     748                        # CANCEL OPERATION IF LLIUREX-META I AFFECTED WITH THIS OPERATION
     749                        kernel_file='/tmp/.uname'
     750                        os.system('LANG=C apt show linux-headers-generic > %s'%kernel_file)
     751                        f=open(kernel_file)
     752                        lines=f.readlines()
     753                        f.close()
     754                        os.remove(kernel_file)
     755
     756                        for line in lines:
     757                                if 'Depends' in line:
     758                                        if widget.label in line:
     759                                                mw=self.core.lri.main_window
     760                                                a=_("First Aid Kit")
     761                                                b=_("You can't delete this kernel because is essential for LliureX.")
     762                                                d=Dialog.InfoDialog(mw,a,b)
     763                                                response=d.run()
     764                                                d.destroy()
     765                                                self.core.dprint("You can't delete this kernel because is essential for LliureX: %s"%(widget.label))
     766                                                self.update_kernels_button.set_sensitive(True)
     767                                                self.filter_kernels_button.set_sensitive(True)
     768                                                self.apply_kernel_button.set_sensitive(True)
     769                                                self.entry_kernel.set_can_focus(True)
     770                                                self.switch_kernel_installed.set_sensitive(True)
     771
     772                                                return True
     773
     774
     775
     776                        mw=self.core.lri.main_window
     777                        a = _("First Aid Kit")
     778                        b = _("Do you want to DELETE this kernel?\n%s"%(widget.label))
     779                        d=Dialog.QuestionDialog(mw,a,b)
     780
     781                        response=d.run()
     782                        d.destroy()
     783                        if response== Gtk.ResponseType.OK:
     784                                self.info_box_stack.set_visible_child_name("info_kernel")
     785                                self.core.dprint('delete    %s      %s'%(widget.label,[widget.data[1],widget.data[3]]))
     786                                self.kernel_install('delete',widget.label,[widget.data[1],widget.data[3]])                             
     787                        else:
     788                                self.info_box_stack.set_visible_child_name("info_kernel")
     789                                self.txt_check_kernel.set_text(_("You cancel to uninstall kernel: %s")%(widget.label))
     790                                self.core.dprint("You cancel to uninstall kernel: %s"%(widget.label))
     791                                self.update_kernels_button.set_sensitive(True)
     792                                self.filter_kernels_button.set_sensitive(True)
     793                                self.apply_kernel_button.set_sensitive(True)
     794                                self.entry_kernel.set_can_focus(True)
     795                                self.switch_kernel_installed.set_sensitive(True)
     796
     797                except Exception as e:
     798                        self.core.dprint("(uninstall_clicked) Error: %s"%e)
     799                        self.info_box_stack.set_visible_child_name("info_kernel")
     800                        self.txt_check_kernel.set_text(_("(uninstall_clicked) Error: %s"%e))
     801
     802        #def uninstall_clicked
     803
     804
     805
     806
     807        def install_clicked(self,widget):
     808
     809                try:
     810                        mw=self.core.lri.main_window
     811                        d=Dialog.QuestionDialog(mw,_("First Aid Kit"),_("Do you want to INSTALL this kernel?\n%s"%(widget.label)))
     812                        response=d.run()
     813                        d.destroy()
     814                        if response== Gtk.ResponseType.OK:
     815                                self.info_box_stack.set_visible_child_name("info_kernel")
     816                                self.core.dprint('install    %s      %s'%(widget.label,[widget.data[1],widget.data[3]]))
     817                                self.kernel_install('install',widget.label,[widget.data[1],widget.data[3]])                     
     818                        else:
     819                                self.info_box_stack.set_visible_child_name("info_kernel")
     820                                self.txt_check_kernel.set_text(_("You cancel to uninstall kernel: %s")%(widget.label))
     821                                self.core.dprint("You cancel to uninstall kernel: %s"%(widget.label))
     822                                self.update_kernels_button.set_sensitive(True)
     823                                self.filter_kernels_button.set_sensitive(True)
     824                                self.apply_kernel_button.set_sensitive(True)
     825                                self.entry_kernel.set_can_focus(True)
     826                                self.switch_kernel_installed.set_sensitive(True)
     827
     828                except Exception as e:
     829                        self.core.dprint("(install_clicked) Error: %s"%e)
     830                        self.info_box_stack.set_visible_child_name("info_kernel")
     831                        self.txt_check_kernel.set_text(_("(install_clicked) Error: %s"%e))
     832
     833        #def install_clicked
     834
     835
     836
     837
     838        def kernel_install(self,action,kernel_label,packages):
     839
     840                try:
     841                        for i in self.kernel_list_box:
     842                                self.kernel_list_box.remove(i)
     843
     844                        self.kernel_box_stack.set_visible_child_name("spinner")
     845
    429846                        self.entry_kernel.set_can_focus(False)
    430847                        self.update_kernels_button.set_sensitive(False)
    431848                        self.filter_kernels_button.set_sensitive(False)
    432849                        self.apply_kernel_button.set_sensitive(False)
    433                         self.kernel_label_selected=[]
    434                         self.kernel_selected=[]
    435                         self.kernel_label_delete=[]
    436                         self.kernel_delete=[]
    437                         flag_install=False
    438                         self.kernel_count=self.kernel_count_orig
    439                         for item in self.kernel_list_box:
    440                                 if type(item) == Gtk.HBox:
    441                                         if item.checkbutton.get_active():
    442                                                 if not (item.data[2]):
    443                                                         self.kernel_label_selected.append(item.label)
    444                                                         self.kernel_selected.append(item.data)
    445                                                         self.kernel_count=self.kernel_count+1
    446                                                         flag_install=True
    447 
    448                                         else:
    449                                                 if (item.data[2]):
    450                                                         #Aqui guardare los Kernels que deben borrarse
    451                                                         self.kernel_delete.append(item.data)
    452                                                         self.kernel_label_delete.append(item.label)
    453                                                         self.kernel_count=self.kernel_count-1
    454                                                         flag_install=True
    455                        
    456                         #Create info tags for info box
    457                         #Install tag
    458                         self.info_kernel_label_selected='None'
    459                         if len(self.kernel_label_selected)>0:
    460                                 self.info_kernel_label_selected=self.kernel_label_selected
    461                         #Delete tag
    462                         self.info_kernel_label_delete='None'
    463                         if len(self.kernel_label_delete)>0:
    464                                 self.info_kernel_label_delete=self.kernel_label_delete
    465                        
    466                        
    467                         #Detect if kernel numbers > 0
    468                         if self.kernel_count > 0:
    469                        
    470                                 #Ask to install/delete kernels
    471                                 if flag_install:
    472                                         mw=self.core.lri.main_window
    473                                         d=Dialog.QuestionDialog(mw,"First Aid Kit","Do you want to INSTALL this kernel list?\n%s\nDo you want to DELETE this kernel list?\n%s"%(self.info_kernel_label_selected,self.info_kernel_label_delete))
    474                                         response=d.run()
    475                                         d.destroy()
    476                                         if response== Gtk.ResponseType.OK:
    477                                                 self.info_box_stack.set_visible_child_name("info_kernel")
    478                                                 self.kernel_install()
    479                                                
    480                                         else:
    481                                                 self.info_box_stack.set_visible_child_name("info_kernel")
    482                                                 self.txt_check_kernel.set_text(_("You cancel to install kernels"))
    483                                                 self.core.dprint("You cancel to install kernels")
    484                                                 self.update_kernels_button.set_sensitive(True)
    485                                                 self.filter_kernels_button.set_sensitive(True)
    486                                                 self.apply_kernel_button.set_sensitive(True)
    487                                                 self.entry_kernel.set_can_focus(True)
    488                                 else:
    489                                         mw=self.core.lri.main_window
    490                                         d=Dialog.InfoDialog(mw,"First Aid Kit","Sorry but you don have programmed any action\please select/unselect one kernel")
    491                                         d.run()
    492                                         d.destroy()
    493                                         self.update_kernels_button.set_sensitive(True)
    494                                         self.filter_kernels_button.set_sensitive(True)
    495                                         self.apply_kernel_button.set_sensitive(True)
    496                                         self.entry_kernel.set_can_focus(True)
    497                         else:
    498                                 mw=self.core.lri.main_window
    499                                 d=Dialog.InfoDialog(mw,"First Aid Kit","You can't delete all kernels, please select one or more.")
    500                                 d.run()
    501                                 d.destroy()
    502                                 self.update_kernels_button.set_sensitive(True)
    503                                 self.filter_kernels_button.set_sensitive(True)
    504                                 self.apply_kernel_button.set_sensitive(True)
    505                                 self.entry_kernel.set_can_focus(True)
    506                
    507 
    508                 except Exception as e:
    509                         self.core.dprint("Error in get_checked_kernels: %s"%e)
    510 
    511 
    512         #def get_checked_kernesl
    513        
    514        
    515        
    516        
    517         def kernel_install(self):
    518                 try:
    519                         for app in self.kernel_selected:
    520                                 #install linux-headers
    521                                 pkg=self.cache[app[1]]
    522                                 pkg.mark_install()
    523                                 #install linux-image
    524                                 pkg=self.cache[app[3]]
    525                                 pkg.mark_install()
    526                                
    527                                
    528                         for app in self.kernel_delete:
    529                                 #Delete linux-headers
    530                                 pkg=self.cache[app[1]]
    531                                 pkg.mark_delete()       
    532                                 #delete linux-image
    533                                 pkg=self.cache[app[3]]
    534                                 pkg.mark_delete()
    535                                
    536                        
     850                        self.switch_kernel_installed.set_sensitive(False)
     851
     852                        allocation=self.kernel_combobox.get_allocation()
     853                        w=allocation.width
     854                        h=allocation.height
     855                       
     856                        self.kernel_combobox.hide()
     857                        self.kernel_combobox_spinner.start()
     858                        self.kernel_combobox_spinner.set_size_request(w,h)
     859                        self.kernel_combobox_spinner.show()
     860                        self.kernel_combobox_spinner_active=True
     861
     862                        if action == 'install':
     863                                for app in packages:
     864                                        #Install linux-headers and linux-generic packages
     865                                        pkg=self.cache[app]
     866                                        pkg.mark_install()
     867                                        label_action='Installing'
     868
     869                        if action == 'delete':
     870                                for app in packages:
     871                                        #Delete linux-headers and linux-generic packages
     872                                        pkg=self.cache[app]
     873                                        pkg.mark_delete()
     874                                        label_action='Deleting'
     875
    537876                        self.info_box_stack.set_visible_child_name("info_kernel")
    538                         self.txt_check_kernel.set_text(_("Installing: %s\nDeleting: %s\nPlease wait........"%(self.info_kernel_label_selected,self.info_kernel_label_delete)))
    539                         self.core.dprint("Installing: %s\n[CORE] Deleting: %s\nPlease wait........"%(self.info_kernel_label_selected,self.info_kernel_label_delete))
     877                        self.txt_check_kernel.set_text(_("%s: %s  Please wait....."%(label_action,kernel_label)))
     878                        self.core.dprint("%s: %s  Please wait....."%(label_action,kernel_label))
    540879                       
    541880                        self.thread_install=threading.Thread(target=self.kernel_install_thread)
     
    544883
    545884                        GLib.timeout_add(500,self.check_kernel_install_thread)
    546                        
    547                        
    548                 except Exception as e:
    549                         self.core.dprint("Error in kernel_install: %s"%e)
    550                
    551         #def kernel_install
    552        
    553        
     885
     886                except Exception as e:
     887                        self.core.dprint("(kernel_install) Error: %s"%e)
     888
     889        #def install_clicked
     890
     891
    554892        def kernel_install_thread(self):
    555893
    556894                try:
     895                        self.core.working=True
    557896                        self.cache.commit()
    558897                        #os.system('update-grub2')
     
    560899                        proc.wait()
    561900                except Exception as e:
    562                         self.core.dprint("Error in kernel_install_thread: %s"%e)       
     901                        self.core.dprint("(kernel_install_thread) Error: %s"%e)
    563902
    564903        #def kernel_install_thread
     
    574913                        self.flag_installed=True
    575914                        self.load_kernels()
     915                        self.core.working=False
    576916                        self.core.dprint("Finished!!")
    577917
    578918                except Exception as e:
    579                         self.core.dprint("Error in check_kernel_install_thread: %s"%e)
     919                        self.core.dprint("(check_kernel_install_thread) Error: %s"%e)
    580920
    581921        #def check_kernel_install_thread
    582        
    583        
    584        
    585        
    586        
    587 
     922
Note: See TracChangeset for help on using the changeset viewer.