path: root/grubconfig/grubconfig.py

#!/usr/bin/python
# -*- coding: UTF-8 -*-
###########################################################################
# grubconfig.py - description                                             #
# ------------------------------                                          #
# begin     : Sun Dec 10 2006                                             #
# copyright : (C) 2006-2007 by Martin Böhm                                #
# email     : martin.bohm@kubuntu.org                                     #
#                                                                         #
###########################################################################
#                                                                         #
#   This program is free software; you can redistribute it and/or modify  #
#   it under the terms of the GNU General Public License as published by  #
#   the Free Software Foundation; either version 2 of the License, or     #
#   (at your option) any later version.                                   #
#                                                                         #
###########################################################################

import sys
import os
import os.path
from PyTQt.qt import *
from tdeui import *
from tdecore import *
from tdefile import *
import string, re
import shutil
import locale
import tempfile

programname = "Boot Loader Configuration"
version = "0.0.2"

standalone = __name__=='__main__'


if standalone:
  programbase = KDialogBase
else:
  programbase = TDECModule

parsable = ["default","menu","color","timeout","hiddenmenu","title","root","kernel","initrd"]
cat1 = ["default","menu","color","timeout","hiddenmenu","root","initrd"]
cat2 = ["savedefault","makeactive","chainloader"]
cat3 = ["kernel"]


class GreyListViewItem(TDEListViewItem):
  def paintCell(self, p, cg, column, width, align ):
    cgGrey = cg
    cgGrey.setColor(TQColorGroup.Text,TQColor("grey"))
    TDEListViewItem.paintCell(self, p, cgGrey, column, width, align)
    cg.restore()


class BoldListViewItem(TDEListViewItem):
  def paintCell(self, p, cg, column, width, align ):
    p.save()
    f = p.font()
    f.setBold(True)
    TDEListViewItem.paintCell(self, p, cg, column, width, align)
    p.restore()


class GrubConfigAppClass(programbase):
  def __init__(self,parent=None,name=None):
    if standalone:
      KDialogBase.__init__(self,KJanusWidget.Tabbed,i18n("Boot Loader Configuration"),
        KDialogBase.Help|KDialogBase.Ok|KDialogBase.Close, KDialogBase.Close)
      # no need to include About button yet
    self.menulstlocation = "/boot/grub/menu.lst"
    self.readfilename = self.menulstlocation
    self.globalvars = {}
    self.itemslist = []

    #--- Load menu.lst using the load_menulst() method
    self.load_menulst()
    print self.globalvars
    print self.itemslist

    # - GRUB Options Tab -
    if standalone:
      usershbox = self.addHBoxPage(i18n("Grub Options"))
      vbox = TQVBox(usershbox)
    else:
      vbox = TQVBox(tabcontrol)
      vbox.setMargin(KDialog.marginHint())

    # -- Operating Systems List & MakeDefault Button --
    horizontalbox = TQHBox(vbox)
    self.itemslistview = TDEListView(horizontalbox)
    self.itemslistview.addColumn("")
    self.itemslistview.setSorting(-1)
    self.itemslistview.header().hide()
    self.itemslistviewitems = []
    arrowsbox = TQVBox(horizontalbox)
    self.upbutton = KPushButton(i18n("Move Up"),arrowsbox)
    self.connect(self.upbutton,SIGNAL("clicked()"),self.slotUpButtonClicked)

    self.downbutton = KPushButton(i18n("Move Down"),arrowsbox)
    self.connect(self.downbutton,SIGNAL("clicked()"),self.slotDownButtonClicked)

    self.defaultbutton = KPushButton(i18n("Make Default"),vbox)
    self.connect(self.defaultbutton,SIGNAL("clicked()"),self.slotSetDefaultButtonClicked)


    # -- Boot Options Group Box --
    bootoptionsbasebox = TQVGroupBox(vbox,"Boot Options")
    bootoptionsbasebox.setTitle(i18n("Boot Options"));

    bootoptionsbasevbox = TQWidget(bootoptionsbasebox)

    infogrid = TQGridLayout(bootoptionsbasevbox,3,2)
    infogrid.setSpacing(KDialog.spacingHint())

    # --- Timeout ---
    label = TQLabel(i18n("Timeout:"),bootoptionsbasevbox)
    infogrid.addWidget(label,0,0)    

    timeoutbox = TQHBox(bootoptionsbasevbox)
    timeoutbox.setSpacing(KDialog.spacingHint())

    self.timeout = KIntSpinBox(timeoutbox,"Timeout")
    if "timeout" in self.globalvars:
      self.timeout.setValue(int(self.globalvars['timeout'][0]))
    label = TQLabel(i18n("seconds"),timeoutbox)
    infogrid.addWidget(timeoutbox,0,1)    
  

    infogrid.addWidget(self.timeout,0,1)

    # --- Hide Menu on Boot ---
    self.hidemenuonboot = TQCheckBox(i18n("Hide Menu on Boot"),bootoptionsbasevbox)
    if 'hiddenmenu' in self.globalvars:
      self.hidemenuonboot.setChecked(int(self.globalvars['hiddenmenu'][0]))
    infogrid.addWidget(self.hidemenuonboot,1,1)

    # --- Make Last OS Default ---
    self.lastdefault = TQCheckBox(i18n("Make Last Operating System Default"),bootoptionsbasevbox)
    infogrid.addWidget(self.lastdefault,2,1)


    # -- Security Group Box --
    securitybox = TQVGroupBox(vbox,"Security")
    securitybox.setTitle(i18n("Security"));
    securityvbox = TQWidget(securitybox)

    infogrid = TQGridLayout(securityvbox,2,2)
    infogrid.setSpacing(KDialog.spacingHint())

    # --- Password ---    
    label = TQLabel(i18n("Password:"),securityvbox)
    infogrid.addWidget(label,0,0)    
    self.userpassword = KPasswordEdit(securityvbox)
    infogrid.addWidget(self.userpassword,0,1)

    # --- Repeat Password ---
    label = TQLabel(i18n("Repeat Password:"),securityvbox)
    infogrid.addWidget(label,1,0)    
    self.userrepeatpassword = KPasswordEdit(securityvbox)
    infogrid.addWidget(self.userrepeatpassword,1,1)    

    # -- Splash Screen Group Box --
    splashbox = TQVGroupBox(vbox,"Splash screen")
    splashbox.setTitle(i18n("Splash screen"));

    # --- Background Color ---
    labelandeditbox = TQHBox(splashbox)
    label = TQLabel(i18n("Background Color:"),labelandeditbox)
    self.backgroundcolor = TQComboBox(labelandeditbox)

    # --- Highlight Color ---
    labelandeditbox = TQHBox(splashbox)
    label = TQLabel(i18n("Highlight Color:"),labelandeditbox)
    self.highlightcolor = TQComboBox(labelandeditbox)

    # - Operating Systems Tab -

    if standalone:
      groupsvbox = self.addVBoxPage(i18n("Operating Systems"))
      vb = TQVBox(groupsvbox)
    else:
      groupsvbox = TQVBox(tabcontrol)
      roupsvbox.setMargin(KDialog.marginHint())
      vb = TQVBox(groupsvbox)

    # -- Operating Systems List --
    
    horizontalbox = TQHBox(vb)
    self.oslistview = TDEListView(horizontalbox)
    self.oslistview.addColumn("")
    self.oslistview.addColumn("")
    self.oslistview.setSorting(-1)
    self.oslistview.header().hide()
    self.oslistviewitems = []
    self.connect(self.oslistview,SIGNAL("selectionChanged()"),self.oslistviewitemSelected)
    
    # -- Operating Systems Details Box --
    osdetailsbox = TQVGroupBox(vb,"Operating System Details")
    # label = TQLabel(i18n("Security"),securitybox)
    detailsvbox = TQWidget(osdetailsbox)

    infogrid = TQGridLayout(detailsvbox,7,2)
    infogrid.setSpacing(KDialog.spacingHint())

    osdetailsbox.setTitle(i18n("Operating System Details"));

    # --- List in GRUB Menu --- 
    self.listingrub = TQCheckBox(i18n("List in GRUB Menu"),detailsvbox)
    infogrid.addWidget(self.listingrub,0,1)

    # --- Display Name ---
    label = TQLabel(i18n("Display Name:"),detailsvbox)
    infogrid.addWidget(label,1,0)
    self.displaynamelabel = TQLineEdit("",detailsvbox)
    infogrid.addWidget(self.displaynamelabel,1,1)
    self.connect(self.displaynamelabel,SIGNAL("textChanged(const TQString &)"),self.slotDisplayNameLabelChanged)

    # --- Operating System ---
    label = TQLabel(i18n("Operating System:"),detailsvbox)
    infogrid.addWidget(label,2,0)
    self.operatingsystem = TQComboBox(detailsvbox)
    infogrid.addWidget(self.operatingsystem,2,1)

    # --- Kernel ---
    label = TQLabel(i18n("Kernel:"),detailsvbox)
    infogrid.addWidget(label,3,0)
    self.kernel = KURLRequester(detailsvbox)
    infogrid.addWidget(self.kernel,3,1)

    # --- Failsafe Kernel ---
    # not sure if that is possible - requested by seele
    label = TQLabel(i18n("Failsafe Kernel:"),detailsvbox)
    infogrid.addWidget(label,4,0)
    self.failsafekernel = TQComboBox(detailsvbox)
    infogrid.addWidget(self.failsafekernel,4,1)

    # --- Initial RAM Disk ---
    label = TQLabel(i18n("Initial RAM Disk:"),detailsvbox)
    infogrid.addWidget(label,5,0)
    self.initrd = KURLRequester(detailsvbox)
    infogrid.addWidget(self.initrd,5,1)

    # --- Root Filesystem ---
    label = TQLabel(i18n("Root Filesystem:"),detailsvbox)
    infogrid.addWidget(label,6,0)
    self.rootfilesystem = TQComboBox(detailsvbox)
    infogrid.addWidget(self.rootfilesystem,6,1)


    # -- Boot Options Box --
    bootoptionsbox = TQVGroupBox(vb,"Boot Options")
    # label = TQLabel(i18n("Security"),securitybox)
    bootoptionsbox.setTitle(i18n("Boot Options"));



    self.acpibox    = TQCheckBox(i18n("Power Management (ACPI) "),bootoptionsbox)
    self.debugbox   = TQCheckBox(i18n("Debugging Messages "),bootoptionsbox)
    self.selinuxbox = TQCheckBox(i18n("SELinux Support "),bootoptionsbox)
    self.splashbox  = TQCheckBox(i18n("Splash Screen"),bootoptionsbox)

    labelandeditbox = TQHBox(bootoptionsbox)
    label = TQLabel(i18n("Custom Options:"),labelandeditbox)
    self.customoptions = KLineEdit("",labelandeditbox)

    # -- (static) UI finished --
    self.reloadListViews("oslist")
    self.reloadListViews("itemslist")
    try:
      self.oslistview.setSelected(self.oslistviewitems[int(self.globalvars['default'][0])],True)
    except ValueError:
      self.oslistview.setSelected(self.oslistviewitems[0],True)
    
    ops_list = self.load_osprobe()
    print ops_list # mhb debug
    
  #######################################################################
  # reload listviews, because they have changed
  def reloadListViews(self,name):
    print "reloaded"
    # you should repaint the one that is not changed on screen
    if name == "oslist":
      self.oslistview.clear()
      
      for item in self.itemslist:
          try:
            if self.itemslist.index(item) == int(self.globalvars['default'][0]):
              self.oslistviewitems.append(BoldListViewItem(self.oslistview,self.oslistview.lastItem(),item['title'][0]))
            else:
              self.oslistviewitems.append(TDEListViewItem(self.oslistview,self.oslistview.lastItem(),item['title'][0]))
          except ValueError:
            self.oslistviewitems.append(TDEListViewItem(self.oslistview,self.oslistview.lastItem(),item['title'][0]))
      # if it has a root option (other than 1 which means only root by itself), it is an OS
    else:
      self.itemslistview.clear()
      #repaint main list
      for item in self.itemslist:
        try:
          if self.itemslist.index(item) == int(self.globalvars['default'][0]):
            print "bam!"
            self.itemslistviewitems.append(BoldListViewItem(self.itemslistview,self.itemslistview.lastItem(),item['title'][0]))
          else:
            self.itemslistviewitems.append(TDEListViewItem(self.itemslistview,self.itemslistview.lastItem(),item['title'][0]))
        except ValueError:
          self.itemslistviewitems.append(TDEListViewItem(self.itemslistview,self.itemslistview.lastItem(),item['title'][0]))
  
  #######################################################################
  def slotUser1(self):
    self.aboutus.show()


  #######################################################################
  # def slotClose(self):
  #   self.close()

  #######################################################################
  def slotOk(self):
    self.save_menulst()
    # mhb TODO: catching exceptions here would be useful
    self.close()

  #######################################################################
  def slotCheckOsClicked(self):
    self.OsProbedList = self.load_osprobe()

  #######################################################################
  def oslistviewitemSelected(self):
    # save current item changes & select another one
    i = self.oslistviewitems.index(self.oslistview.selectedItem())
    self.updatingGUI = True
    self.displaynamelabel.setText(self.itemslist[i]["title"][0])
    # visible in GRUB reload
    # kernel reload
    try:
      self.kernel.setURL(self.itemslist[i]["kernel"][0])
    except KeyError:
      self.initrd.setURL("unavailable") # mhb debug
    # initrd reload
    try:
      self.initrd.setURL(self.itemslist[i]["initrd"][0])
    except KeyError:
      self.initrd.setURL("unavailable") # mhb debug
    
    # custom options reload
    customoptions = ""
    for word in self.itemslist[i]["kernel"][1:-1]:
      customoptions += word + " "
    self.customoptions.setText(customoptions[:-1])
    
    self.updatingGUI = False
    print "oslistview item selected" #mhb debug
    pass
  #######################################################################
  def slotDisplayNameLabelChanged(self, string):
    if(self.updatingGUI == False):
      print "display name changed" #mhb debug
      i = self.oslistviewitems.index(self.oslistview.selectedItem())
      self.itemslist[i]["title"][0] = string
      self.oslistview.selectedItem().setText(0,string)
      self.reloadListViews("itemslist")
      pass
  #######################################################################
  def slotUpButtonClicked(self):
    print "UpButton clicked" #mhb debug
    i = self.itemslistviewitems.index(self.itemslistview.selectedItem())
    self.itemslistview.selectedItem().itemAbove().moveItem(self.itemslistview.selectedItem())
    # itemslist should have the same i for the same option
    if(i != 0):
      container = self.itemslist[i]
      self.itemslist[i] = self.itemslist[i-1]
      self.itemslist[i-1] = container
    self.reloadListViews("oslist")
    return "not working yet"

  #######################################################################
  def slotDownButtonClicked(self):
    print "DownButton clicked" #mhb debug
    i = self.itemslistviewitems.index(self.itemslistview.selectedItem())
    self.itemslistview.selectedItem().moveItem(self.itemslistview.selectedItem().itemBelow())
    if(i != len(self.itemslist)-1):
      container = self.itemslist[i]
    self.itemslist[i] = self.itemslist[i+1]
    self.itemslist[i+1] = container
    self.reloadListViews("oslist")
    return "not working yet"

    #######################################################################
  def slotSetDefaultButtonClicked(self):
    print "SetDefaultButton cliicked" #mhb debug
    try:
      defaultn = int(self.globalvars["default"][0])
    except ValueError:
      pass
    else:
      container = self.itemslistviewitems[defaultn]
      self.itemslistviewitems[defaultn] = TDEListViewItem(self.itemslistview,container,self.itemslist[defaultn]['title'][0])
    self.itemslistview.takeItem(container)

      
    indexn = self.itemslistviewitems.index(self.itemslistview.selectedItem())
    self.globalvars["default"] = str(indexn)
    self.itemslistviewitems[indexn] = BoldListViewItem(self.itemslistview,self.itemslistview.selectedItem(),self.itemslist[indexn]['title'][0])
    self.itemslistview.takeItem(self.itemslistview.selectedItem())
    
    self.reloadListViews("oslist")

    return "not working yet"



  #######################################################################
  # loop
  def exec_loop(self):
    global programbase
    # self.__loadOptions()
    self.updatingGUI = True
    #self.__updateUserList()
    #self.__updateGroupList()
    self.updatingGUI = False
    programbase.exec_loop(self)
    print "done"


  #######################################################################
  # loads menu.lst
  # NOT YET parsing:
  #   fallback
  # currently parsing:                  (type of the location number)
  #   default                           <int>
  #   timeout                           <int>
  #   hiddenmenu                        <int>
  #   color                             <int>
  #   password (consider an md5 sum?)   <int>
  #   AUTOMAGIC KERNELS LIST            <interval - two ints>
  #   GRUBCONFIG DISABLED ITEMS         <interval - two ints>
  # IMPORTANT note:
  #   any value that is not parsed MUST not be ommited at the end!
  #   any value that is commented (parsed or not) MUST not be omitted at the end!
  # not so important note:
  #   if a value we parse is not defined:
  #     apply defaults (how do find them out?)
  #     but specify it in the menu.lst when saving
  # mhb TODO: somehow handle automagic kernel list (target: feisty)
  # mhb TODO: adapt to more distributions, find menu.lst on different locations
  def load_menulst(self):
    self.modifiedlines = []
    menufd = open(self.menulstlocation,"r")
    linenum = 0
    lock = 0
    itemlock = 0
    currentitem = 0
    for line in menufd:
      # Checks if the first non-white char in a line is a #
      if re.search(r'^(/s)*#',line) or re.search(r'^(/s)*$',line):
        print "a commented line" # mhb debug
        if itemlock == 1:
          itemlock = 0
          currentitem += 1
          
        # if it is a start of an area we parse, use a lock
        if re.search(r'sumthin',line) and (lock == 0):
          lock = 1
        elif re.search(r'sumthin_other',line) and (lock == 0):
          lock = 2
        # else if it is an end of an area we parse, close the lock
        elif re.search(r'sumthin_other_end',line) and (lock == 2):
          lock = 0
        elif re.search(r'sumthin_end',line) and (lock == 1):
          lock = 0

        # errors
        # mhb TODO: exception catching
        elif re.search(r'sumthin',line) and (lock == 0):
          raise IdentationError
        elif re.search(r'sumthin_other',line) and (lock == 1):
          raise EndOfNotOpenedError

        # if it is in the lock, do the mumbo-jumbo
        # find out what kind of lock it is
        # AUTOCONFIG
        if lock == 1:
         
          
          # automagic kernels list?
          if re.search(r'sumthin',line):
            pass
          # or the other one (grubconfig disabled kernel's list )?
          else:
            self.modifiedlines.append(linenum)
        # else save it as a commented line (does not save the locks)
        # GRUBCONFiG commented item
        elif lock == 2:
          # remove leading spaces and one #
          # the parse as a normal menu item
          pass
        # it's a commented, no need to do anything
        else:
          pass
      # okay, it's not commented
      else:
        print "a not commented line" # mhb debug
        self.modifiedlines.append(linenum)
        # we presume the first character is already a name
        var_name = line.split()[0]
        #print "variable name is " + var_name # mhb debug
        # var_value's last item is always the line that has to be changed
        var_value = []
        if var_name in parsable:
          # cat 0 - a title - triggers itemlock, has a name and a value, which should be stored as text
          if var_name == "title":
            print line.split(None,1)
            var_value.append(line.split(None,1)[1][:-1])
            itemlock = 1
            self.itemslist.append({})
          # cat 1 - has a name and 1 value
          elif var_name in cat1:
            try:
              var_value.append(line.split()[1])
            except IndexError:
              var_value.append(1)
          # cat 2 - has a name, but no value ( implicit 1 )
          elif var_name in cat2:
            var_value.append(1)
          # cat 3 - has a name, has multiple values, should be saved as list
          elif var_name in cat3:
              var_value = line.split()[1:]
          # now, append the number
          var_value.append(linenum)
          
          if itemlock == 1:
            self.itemslist[currentitem][var_name] = var_value
          else:
            self.globalvars[var_name] = var_value
        
        
        
        
        
        #if var_name in parsable:
          #print "variable name " + var_name + " is parsable " # mhb debug
          #if var_name == "title":
            #itemlock = 1
            #self.itemslist.append({})
          #if(len(line.split()) > 1):
            #var_value = line.split()[1]
            #if itemlock == 1:
              
            #else:
              
            #print "variable value is " + var_value # mhb debug
            
          #else:
            #if itemlock == 1:
              #self.itemslist[currentitem][var_name] = var_value
            #else:
              #self.globalvars[var_name] = 1
        #else:
          #print "variable name " + var_name + " is currently not parsable" # mhb debug

          #print "it has no value" # mhb debug
      # print "parsed another line" # mhb debug
      linenum += 1;
    print "load_menulst() called" # mhb debug
    return "not working yet"

  #######################################################################
  # writes menu.lst
  def save_menulst(self):
    delimeter = "      "
    # phase 1: preparing the values
    lines = []
    linecontent = []
    # this consists of:
    #   1. concatenating the list of lines that were modified
    #   2. writing the lines in another list (or something more efficient
    output = {}
    # the globals first
    for unit, value in self.globalvars.items():
      lines.append(value[-1])
      temp_str=""
      temp_str+=(str(unit)+" ")
      for index in range(len(value)-1):
        temp_str+=(str(value[index])+" ")
      linecontent.append(temp_str)

    # itemslist next (abattoir)
    for item in self.itemslist:
      for unit, value in reversed(item.items()):
        lines.append(value[-1])
        temp_str=""
        temp_str+=(str(unit)+" ")
        for index in range(len(value)-1):
          temp_str+=(str(value[index])+" ")
        linecontent.append(temp_str)

    # phase 2: writing the file
    # by now we have a list of numbers (let's call it lines[])
    # and a list of mofified lines  (let's call it linecontent[] )
    # lines[i] corresponds with linecontent[]
    trfile = open(self.readfilename, "r" )
    twfilename = tempfile.mkstemp("menulst")[1]
    twfile = open(twfilename,"w")
    # the current solution is:
    # read the menu.lst again (or rather its copy, to prevent the file being changed)
    # line by line write it in the output file (to be exact, to a file in /tmp)
    linenum = 0
    print linecontent
    print lines
    # foreach file as line:
    for originalline in trfile:
      # if its number isn't in the location list, simply write it
      if linenum in lines:
        twfile.writelines(linecontent[linenum])
      else:
        twfile.writelines(originalline)

      linenum += 1;

    # if there are any more lines to be written (newly detected options)
    # write them at the end (now)
      
    # when that process works out fine do a quick rewrite to /boot/grub/menu.lst
    # mhb TODO: declare self.menulstlocation
    twfile.close()
    shutil.move(twfilename,self.menulstlocation)
    # mhb TODO: Exception handling
    os.remove(self.readfilename)

    print "save_menulst() called" # mhb debug
    return "not working yet"


  #######################################################################
  # loads output from os-probe
  def load_osprobe(self):
    detected = os.popen('os-prober').readlines()
    ops_list = []
    for ops in detected:
      ops = string.replace(ops,"\n","")
      temp_list = ops.split(':')
      partition = temp_list[0]
      temp_list[0] = string.replace(temp_list[0],"/dev/","")
      re_obj = re.search(r'([sh]d)([a-z])([0-9])*$',temp_list[0])
      disk = ord(re_obj.group(2))%97
      part = int(re_obj.group(3))-1
      if re_obj == None:
        re_obj = re.search(r'(fd[0-9]*)$',temp_list[0])
        if re_obj:
          disk = temp_list[0]
          part = ""
        else : re_obj = re.search(r'(part[0-9]*$', temp_list[0])
        if re_obj:
          disk = '/disc'
          part = temp_list[0]
      temp_list[0] = '('+re_obj.group(1)+str(disk)+','+str(part)+')'
      if temp_list[3].lower() == "linux":
        mounted = os.popen('mount | grep '+partition).readlines()
        if mounted:
          linux_os = os.popen('linux-boot-prober --mounted '+partition).readlines()
        else:
          linux_os = os.popen('linux-boot-prober '+partition).readlines()
        linux_list = []
        for lops in linux_os:
          lops = string.replace(lops,"\n","")
          temp_linux_list = lops.split(':')
          linux_list.append(temp_linux_list)
        temp_list.append(linux_list)
      ops_list.append(temp_list)
      temp_list = []
    return ops_list


############################################################################
# Factory function for KControl
def create_grubconfig(parent,name):
    return GrubConfigAppClass(parent, name)


##########################################################################
def MakeAboutData():
    aboutdata = TDEAboutData("guidance", programname, version,
        unicode(i18n("Boot Loader Configuration Tool")).encode(locale.getpreferredencoding()),
        TDEAboutData.License_GPL, "Copyright (C) 2006-2007 Martin Böhm")
    aboutdata.addAuthor("Martin Böhm", "Developer", "martin.bohm@kubuntu.org", "http://mhb.ath.cx/")
    aboutdata.addAuthor("Simon Edwards", "Developer", "simon@simonzone.com", "http://www.simonzone.com/software/")
    aboutdata.addAuthor("Sebastian Kügler", "Developer", "sebas@kde.org", "http://vizZzion.org")
    return aboutdata

if standalone:
    aboutdata = MakeAboutData()

    TDECmdLineArgs.init(sys.argv,aboutdata)

    kapp = TDEApplication()
    grubconfigapp = GrubConfigAppClass()
    grubconfigapp.exec_loop()