Changeset 8612


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

Problems with translations in KernelBox?

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

Legend:

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

    r8609 r8612  
     1first-aid-kit (0.0.4) xenial; urgency=high
     2
     3  * Problems with translations in Kernel Module
     4
     5 -- Daniel Duran Vecino <daduve@gmail.com>  Tue, 02 Apr 2019 14:05:58 +0200
     6
    17first-aid-kit (0.0.3) xenial; urgency=high
    28
  • first-aid-kit/trunk/fuentes/first-aid-kit.install/usr/share/first-aid-kit/KernelBox.py

    r8604 r8612  
    1616import platform
    1717import copy
    18 import shutil
    1918
    2019gettext.textdomain('first-aid-kit-gui')
     
    4443                        self.kernel_label=builder.get_object("kernel_label")
    4544                        self.kernel_vp=builder.get_object("viewport3")
    46                         self.kernel_sw=builder.get_object("scrolledwindow4")
    4745                        self.info_box_kernel=builder.get_object("info_kernel")
    4846                        self.txt_check_kernel=builder.get_object("txt_check_kernel")
     
    5452                        self.filter_kernels_button=builder.get_object("kernel_filter_button")
    5553                        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")
    6054                       
    6155
     
    10094
    10195                        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()
    10996                        self.connect_signals()
    11097                        self.set_css_info()
    11198                        self.load_kernels()
    11299
    113 
    114                        
    115                 except Exception as e:
    116                         self.core.dprint("(KernelBox)Error: %s"%e)
     100                       
     101                except Exception as e:
     102                        self.core.dprint("Error in KernelBox: %s"%e)
    117103               
    118104        #def __init__
     
    123109
    124110
    125 
    126 
    127 
    128111        def set_css_info(self):
    129 
    130112               
    131113                self.style_provider=Gtk.CssProvider()
     
    153135
    154136
    155 
    156 
    157 
    158137        def connect_signals(self):
    159 
    160138               
    161139                self.update_kernels_button.connect("clicked",self.update_kernels_button_clicked)
    162                 self.apply_kernel_button.connect("clicked",self.set_kernel_default)
     140                self.apply_kernel_button.connect("clicked",self.get_checked_kernels)
    163141                self.filter_kernels_button.connect("clicked",self.filter_kernels_button_clicked)
    164142                self.entry_kernel.connect("activate",self.entries_press_event)
    165                 self.switch_kernel_installed.connect("notify::active",self.kernel_installed_filter)
    166143               
    167144        #def connect_signals
     
    169146
    170147
     148
     149
    171150        def entries_press_event(self,widget):
    172151               
     
    174153               
    175154        #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
    360155
    361156
     
    374169                        self.filter_kernels_button.set_sensitive(False)
    375170                        self.apply_kernel_button.set_sensitive(False)
    376                         self.switch_kernel_installed.set_sensitive(False)
    377171                        self.kernel_box_stack.set_visible_child_name("spinner")
    378172
     
    384178
    385179                except Exception as e:
    386                         self.core.dprint("(filter_kernels_button_clicked) Error: %s"%e)
     180                        self.core.dprint("Error in update_kernels_button_clicked: %s"%e)
    387181
    388182        #def filter_kernels_button_clicked
     
    396190        def update_kernels_button_clicked (self,widget):
    397191                try:
    398 
    399192                        self.entry_kernel.set_can_focus(False)
    400193                        self.kernel_filter=self.entry_kernel.get_text().split()
     
    403196                        self.filter_kernels_button.set_sensitive(False)
    404197                        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 
    410198                        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
    422199
    423200                        self.info_box_stack.set_visible_child_name("info_kernel")
     
    429206                        self.thread_up.start()
    430207
    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 
    437208                        GLib.timeout_add(500,self.check_update_kernels_thread)
    438209
    439210                except Exception as e:
    440                         self.core.dprint("(update_kernels_button_clicked) Error: %s"%e)
     211                        self.core.dprint("Error in update_kernels_button_clicked: %s"%e)
    441212
    442213        #def update_kernels_button_clicked
     
    451222                               
    452223                except Exception as e:
    453                         self.core.dprint("(update_kernels_thread) Error: %s"%e)
     224                        self.core.dprint("Error in update_kernels_thread: %s"%e)       
    454225
    455226        #def update_kernels_thread
     
    466237
    467238                except Exception as e:
    468                         self.core.dprint("(check_update_kernels_thread) Error: %s"%e)
     239                        self.core.dprint("Error in check_update_kernels_thread: %s"%e)
    469240
    470241        #def check_update_kernels_thread
     
    484255                        self.filter_kernels_button.set_sensitive(False)
    485256                        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                        
    491257                        self.read_kernels()
    492258                               
    493259                except Exception as e:
    494                         self.core.dprint("(load_kernels) Error: %s"%e) 
     260                        self.core.dprint("Error in load_kernels: %s"%e)
    495261
    496262        #def load_kernels
     
    499265
    500266
     267
     268
     269
    501270        def read_kernels(self):
    502271
    503272                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 
    515273                        self.thread=threading.Thread(target=self.read_kernels_thread)
    516274                        self.thread.daemon=True
     
    518276
    519277                        self.core.dprint("Reading kernels avaiables..........")
    520                         self.kernel_installed_boot.clear()
     278
    521279                        GLib.timeout_add(500,self.check_read_kernels_thread)
    522280
    523281                except Exception as e:
    524                         self.core.dprint("(read_kernels) Error: %s"%e)
     282                        self.core.dprint("Error in read_kernels: %s"%e)
    525283
    526284        #def read_kernels
     
    544302                        self.installed=[]
    545303                        self.kernel_count_orig=0
    546                        
     304
    547305                        for i in pkgs:
    548306                                if not 'linux-headers-generic' == str(i):
     
    559317                                                                                self.installed.append(version)
    560318                                                                                self.avaiable.append((version,str(i),True,linux_image))
    561 
    562                                                                                 self.kernel_installed_boot.append([version])
    563319                                                                                self.kernel_count_orig=self.kernel_count_orig+1
    564320                                                                                #print ('%s is installed'%version)
     
    572328                                                                                self.installed.append(version)
    573329                                                                                self.avaiable.append((version,str(i),True,linux_image))
    574                                                                                 self.kernel_installed_boot.append([version])
    575330                                                                                self.kernel_count_orig=self.kernel_count_orig+1
    576331                                                                                #print ('%s is installed'%version)
     
    578333                                                                                self.avaiable.append((version,str(i),False,linux_image))
    579334
    580                         #self.kernel_boot()
    581335                        self.filtered=[]
    582336                        if len(self.kernel_filter)>0:
     
    595349                                self.avaiable=self.filtered
    596350
    597 
    598 
    599351                        #print self.avaiable
    600352
    601353                except Exception as e:
    602                         self.core.dprint("(read_kernels_thread) Error: %s"%e)
     354                        self.core.dprint("Error in tread_read_kernels: %s"%e)
    603355
    604356        #def read_kernels
     
    611363                                return True
    612364
    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
     365                        count=len(self.avaiable)
    628366
    629367                        for i in self.kernel_list_box:
     
    632370                        for kernel in self.avaiable:
    633371
    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)
     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
    641390                               
    642391                                count-=1
     
    655404                        self.apply_kernel_button.set_sensitive(True)
    656405                        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
    668406                       
    669407                        if not self.flag_installed:
     
    675413
    676414                except Exception as e:
    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:
     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:
     429                        self.entry_kernel.set_can_focus(False)
     430                        self.update_kernels_button.set_sensitive(False)
     431                        self.filter_kernels_button.set_sensitive(False)
     432                        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:
    735472                                        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."))
     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))
    737474                                        response=d.run()
    738475                                        d.destroy()
    739                                         self.core.dprint("You can't delete this kernel because you are using now.: %s"%(widget.label))
     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()
    740493                                        self.update_kernels_button.set_sensitive(True)
    741494                                        self.filter_kernels_button.set_sensitive(True)
    742495                                        self.apply_kernel_button.set_sensitive(True)
    743496                                        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                                                 d=Dialog.InfoDialog(_(mw,"First Aid Kit","You can't delete this kernel because is essential for LliureX."))
    761                                                 response=d.run()
    762                                                 d.destroy()
    763                                                 self.core.dprint("You can't delete this kernel because is essential for LliureX: %s"%(widget.label))
    764                                                 self.update_kernels_button.set_sensitive(True)
    765                                                 self.filter_kernels_button.set_sensitive(True)
    766                                                 self.apply_kernel_button.set_sensitive(True)
    767                                                 self.entry_kernel.set_can_focus(True)
    768                                                 self.switch_kernel_installed.set_sensitive(True)
    769 
    770                                                 return True
    771 
    772 
    773 
    774                         mw=self.core.lri.main_window
    775                         d=Dialog.QuestionDialog(_(mw,"First Aid Kit","Do you want to DELETE this kernel?\n%s"%(widget.label)))
    776                         response=d.run()
    777                         d.destroy()
    778                         if response== Gtk.ResponseType.OK:
    779                                 self.info_box_stack.set_visible_child_name("info_kernel")
    780                                 self.core.dprint('delete    %s      %s'%(widget.label,[widget.data[1],widget.data[3]]))
    781                                 self.kernel_install('delete',widget.label,[widget.data[1],widget.data[3]])                             
    782497                        else:
    783                                 self.info_box_stack.set_visible_child_name("info_kernel")
    784                                 self.txt_check_kernel.set_text(_("You cancel to uninstall kernel: %s")%(widget.label))
    785                                 self.core.dprint("You cancel to uninstall kernel: %s"%(widget.label))
     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()
    786502                                self.update_kernels_button.set_sensitive(True)
    787503                                self.filter_kernels_button.set_sensitive(True)
    788504                                self.apply_kernel_button.set_sensitive(True)
    789505                                self.entry_kernel.set_can_focus(True)
    790                                 self.switch_kernel_installed.set_sensitive(True)
    791 
    792                 except Exception as e:
    793                         self.core.dprint("(uninstall_clicked) Error: %s"%e)
    794 
    795         #def uninstall_clicked
    796 
    797 
    798 
    799 
    800         def install_clicked(self,widget):
    801 
    802                 try:
    803                         mw=self.core.lri.main_window
    804                         d=Dialog.QuestionDialog(_(mw,"First Aid Kit","Do you want to INSTALL this kernel?\n%s"%(widget.label)))
    805                         response=d.run()
    806                         d.destroy()
    807                         if response== Gtk.ResponseType.OK:
    808                                 self.info_box_stack.set_visible_child_name("info_kernel")
    809                                 self.core.dprint('install    %s      %s'%(widget.label,[widget.data[1],widget.data[3]]))
    810                                 self.kernel_install('install',widget.label,[widget.data[1],widget.data[3]])                     
    811                         else:
    812                                 self.info_box_stack.set_visible_child_name("info_kernel")
    813                                 self.txt_check_kernel.set_text(_("You cancel to uninstall kernel: %s")%(widget.label))
    814                                 self.core.dprint("You cancel to uninstall kernel: %s"%(widget.label))
    815                                 self.update_kernels_button.set_sensitive(True)
    816                                 self.filter_kernels_button.set_sensitive(True)
    817                                 self.apply_kernel_button.set_sensitive(True)
    818                                 self.entry_kernel.set_can_focus(True)
    819                                 self.switch_kernel_installed.set_sensitive(True)
    820 
    821                 except Exception as e:
    822                         self.core.dprint("(install_clicked) Error: %s"%e)
    823 
    824         #def install_clicked
    825 
    826 
    827 
    828 
    829         def kernel_install(self,action,kernel_label,packages):
    830 
    831                 try:
    832                         for i in self.kernel_list_box:
    833                                 self.kernel_list_box.remove(i)
    834 
    835                         self.kernel_box_stack.set_visible_child_name("spinner")
    836 
    837                         self.entry_kernel.set_can_focus(False)
    838                         self.update_kernels_button.set_sensitive(False)
    839                         self.filter_kernels_button.set_sensitive(False)
    840                         self.apply_kernel_button.set_sensitive(False)
    841                         self.switch_kernel_installed.set_sensitive(False)
    842 
    843                         allocation=self.kernel_combobox.get_allocation()
    844                         w=allocation.width
    845                         h=allocation.height
    846                        
    847                         self.kernel_combobox.hide()
    848                         self.kernel_combobox_spinner.start()
    849                         self.kernel_combobox_spinner.set_size_request(w,h)
    850                         self.kernel_combobox_spinner.show()
    851                         self.kernel_combobox_spinner_active=True
    852 
    853                         if action == 'install':
    854                                 for app in packages:
    855                                         #Install linux-headers and linux-generic packages
    856                                         pkg=self.cache[app]
    857                                         pkg.mark_install()
    858                                         label_action='Installing'
    859 
    860                         if action == 'delete':
    861                                 for app in packages:
    862                                         #Delete linux-headers and linux-generic packages
    863                                         pkg=self.cache[app]
    864                                         pkg.mark_delete()
    865                                         label_action='Deleting'
    866 
     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                       
    867537                        self.info_box_stack.set_visible_child_name("info_kernel")
    868                         self.txt_check_kernel.set_text(_("%s: %s  Please wait....."%(label_action,kernel_label)))
    869                         self.core.dprint("%s: %s  Please wait....."%(label_action,kernel_label))
     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))
    870540                       
    871541                        self.thread_install=threading.Thread(target=self.kernel_install_thread)
     
    874544
    875545                        GLib.timeout_add(500,self.check_kernel_install_thread)
    876 
    877                 except Exception as e:
    878                         self.core.dprint("(kernel_install) Error: %s"%e)
    879 
    880         #def install_clicked
    881 
    882 
     546                       
     547                       
     548                except Exception as e:
     549                        self.core.dprint("Error in kernel_install: %s"%e)
     550               
     551        #def kernel_install
     552       
     553       
    883554        def kernel_install_thread(self):
    884555
    885556                try:
    886                         self.core.working=True
    887557                        self.cache.commit()
    888558                        #os.system('update-grub2')
     
    890560                        proc.wait()
    891561                except Exception as e:
    892                         self.core.dprint("(kernel_install_thread) Error: %s"%e)
     562                        self.core.dprint("Error in kernel_install_thread: %s"%e)       
    893563
    894564        #def kernel_install_thread
     
    904574                        self.flag_installed=True
    905575                        self.load_kernels()
    906                         self.core.working=False
    907576                        self.core.dprint("Finished!!")
    908577
    909578                except Exception as e:
    910                         self.core.dprint("(check_kernel_install_thread) Error: %s"%e)
     579                        self.core.dprint("Error in check_kernel_install_thread: %s"%e)
    911580
    912581        #def check_kernel_install_thread
    913 
     582       
     583       
     584       
     585       
     586       
     587
Note: See TracChangeset for help on using the changeset viewer.