File indexing completed on 2024-05-12 16:08:30

 class pyqtSignal():
  def connect(self, targetSignal): pass
  def emit(self, *args): pass
 from QtCore import *
 
 class K3Icon():
     """"""
     context = None # KIconLoader.Context - member
     path = None # QString - member
     size = None # int - member
     threshold = None # int - member
     type = None # KIconLoader.Type - member
     def __init__(self):
         '''void K3Icon.__init__()'''
     def __init__(self):
         '''K3Icon K3Icon.__init__()'''
         return K3Icon()
     def isValid(self):
         '''bool K3Icon.isValid()'''
         return bool()
 
 
 class KDialog(QDialog):
     """"""
     # Enum KDialog.CaptionFlag
     NoCaptionFlags = 0
     AppNameCaption = 0
     ModifiedCaption = 0
     HIGCompliantCaption = 0
 
     # Enum KDialog.ButtonPopupMode
     InstantPopup = 0
     DelayedPopup = 0
 
     # Enum KDialog.ButtonCode
     __kdevpythondocumentation_builtin_None = 0
     Help = 0
     Default = 0
     Ok = 0
     Apply = 0
     Try = 0
     Cancel = 0
     Close = 0
     No = 0
     Yes = 0
     Reset = 0
     Details = 0
     User1 = 0
     User2 = 0
     User3 = 0
     NoDefault = 0
 
     def __init__(self, parent = None, flags = 0):
         '''void KDialog.__init__(QWidget parent = None, Qt.WindowFlags flags = 0)'''
     def setAllowEmbeddingInGraphicsView(self, allowEmbedding):
         '''static void KDialog.setAllowEmbeddingInGraphicsView(bool allowEmbedding)'''
     def updateGeometry(self):
         '''void KDialog.updateGeometry()'''
     def slotButtonClicked(self, button):
         '''void KDialog.slotButtonClicked(int button)'''
     def keyPressEvent(self):
         '''QKeyEvent KDialog.keyPressEvent()'''
         return QKeyEvent()
     def closeEvent(self, e):
         '''void KDialog.closeEvent(QCloseEvent e)'''
     def hideEvent(self):
         '''QHideEvent KDialog.hideEvent()'''
         return QHideEvent()
     aboutToShowDetails = pyqtSignal() # void aboutToShowDetails() - signal
     finished = pyqtSignal() # void finished() - signal
     hidden = pyqtSignal() # void hidden() - signal
     buttonClicked = pyqtSignal() # void buttonClicked(KDialog::ButtonCode) - signal
     closeClicked = pyqtSignal() # void closeClicked() - signal
     cancelClicked = pyqtSignal() # void cancelClicked() - signal
     noClicked = pyqtSignal() # void noClicked() - signal
     yesClicked = pyqtSignal() # void yesClicked() - signal
     okClicked = pyqtSignal() # void okClicked() - signal
     tryClicked = pyqtSignal() # void tryClicked() - signal
     applyClicked = pyqtSignal() # void applyClicked() - signal
     user1Clicked = pyqtSignal() # void user1Clicked() - signal
     user2Clicked = pyqtSignal() # void user2Clicked() - signal
     user3Clicked = pyqtSignal() # void user3Clicked() - signal
     resetClicked = pyqtSignal() # void resetClicked() - signal
     defaultClicked = pyqtSignal() # void defaultClicked() - signal
     helpClicked = pyqtSignal() # void helpClicked() - signal
     layoutHintChanged = pyqtSignal() # void layoutHintChanged() - signal
     def delayedDestruct(self):
         '''void KDialog.delayedDestruct()'''
     def setDetailsWidget(self, detailsWidget):
         '''void KDialog.setDetailsWidget(QWidget detailsWidget)'''
     def setDetailsWidgetVisible(self, visible):
         '''void KDialog.setDetailsWidgetVisible(bool visible)'''
     def isDetailsWidgetVisible(self):
         '''bool KDialog.isDetailsWidgetVisible()'''
         return bool()
     def setHelp(self, anchor, appname = QString()):
         '''void KDialog.setHelp(QString anchor, QString appname = QString())'''
     def setHelpLinkText(self, text):
         '''void KDialog.setHelpLinkText(QString text)'''
     def enableLinkedHelp(self, state):
         '''void KDialog.enableLinkedHelp(bool state)'''
     def enableButtonCancel(self, state):
         '''void KDialog.enableButtonCancel(bool state)'''
     def enableButtonApply(self, state):
         '''void KDialog.enableButtonApply(bool state)'''
     def enableButtonOk(self, state):
         '''void KDialog.enableButtonOk(bool state)'''
     def enableButton(self, id, state):
         '''void KDialog.enableButton(KDialog.ButtonCode id, bool state)'''
     def setPlainCaption(self, caption):
         '''void KDialog.setPlainCaption(QString caption)'''
     def setCaption(self, caption):
         '''void KDialog.setCaption(QString caption)'''
     def setCaption(self, caption, modified):
         '''void KDialog.setCaption(QString caption, bool modified)'''
     def minimumSizeHint(self):
         '''QSize KDialog.minimumSizeHint()'''
         return QSize()
     def sizeHint(self):
         '''QSize KDialog.sizeHint()'''
         return QSize()
     def mainWidget(self):
         '''QWidget KDialog.mainWidget()'''
         return QWidget()
     def setMainWidget(self, widget):
         '''void KDialog.setMainWidget(QWidget widget)'''
     def avoidArea(self, widget, area, screen = None):
         '''static bool KDialog.avoidArea(QWidget widget, QRect area, int screen = -1)'''
         return bool()
     def centerOnScreen(self, widget, screen = None):
         '''static void KDialog.centerOnScreen(QWidget widget, int screen = -1)'''
     def resizeLayout(self, widget, margin, spacing):
         '''static void KDialog.resizeLayout(QWidget widget, int margin, int spacing)'''
     def resizeLayout(self, lay, margin, spacing):
         '''static void KDialog.resizeLayout(QLayout lay, int margin, int spacing)'''
     def makeStandardCaption(self, userCaption, window = None, flags = None):
         '''static QString KDialog.makeStandardCaption(QString userCaption, QWidget window = None, KDialog.CaptionFlags flags = KDialog.HIGCompliantCaption)'''
         return QString()
     def groupSpacingHint(self):
         '''static int KDialog.groupSpacingHint()'''
         return int()
     def spacingHint(self):
         '''static int KDialog.spacingHint()'''
         return int()
     def marginHint(self):
         '''static int KDialog.marginHint()'''
         return int()
     def button(self, id):
         '''KPushButton KDialog.button(KDialog.ButtonCode id)'''
         return KPushButton()
     def isButtonEnabled(self, id):
         '''bool KDialog.isButtonEnabled(KDialog.ButtonCode id)'''
         return bool()
     def helpLinkText(self):
         '''QString KDialog.helpLinkText()'''
         return QString()
     def saveDialogSize(self, config, options = None):
         '''void KDialog.saveDialogSize(KConfigGroup config, KConfigBase.WriteConfigFlags options = KConfigGroup.Normal)'''
     def restoreDialogSize(self, config):
         '''void KDialog.restoreDialogSize(KConfigGroup config)'''
     def incrementInitialSize(self, size):
         '''void KDialog.incrementInitialSize(QSize size)'''
     def setInitialSize(self, size):
         '''void KDialog.setInitialSize(QSize size)'''
     def setButtonFocus(self, id):
         '''void KDialog.setButtonFocus(KDialog.ButtonCode id)'''
     def setButtonMenu(self, id, menu, popupmode = None):
         '''void KDialog.setButtonMenu(KDialog.ButtonCode id, QMenu menu, KDialog.ButtonPopupMode popupmode = KDialog.InstantPopup)'''
     def setButtonGuiItem(self, id, item):
         '''void KDialog.setButtonGuiItem(KDialog.ButtonCode id, KGuiItem item)'''
     def buttonWhatsThis(self, id):
         '''QString KDialog.buttonWhatsThis(KDialog.ButtonCode id)'''
         return QString()
     def setButtonWhatsThis(self, id, text):
         '''void KDialog.setButtonWhatsThis(KDialog.ButtonCode id, QString text)'''
     def buttonToolTip(self, id):
         '''QString KDialog.buttonToolTip(KDialog.ButtonCode id)'''
         return QString()
     def setButtonToolTip(self, id, text):
         '''void KDialog.setButtonToolTip(KDialog.ButtonCode id, QString text)'''
     def buttonIcon(self, id):
         '''KIcon KDialog.buttonIcon(KDialog.ButtonCode id)'''
         return KIcon()
     def setButtonIcon(self, id, icon):
         '''void KDialog.setButtonIcon(KDialog.ButtonCode id, KIcon icon)'''
     def buttonText(self, id):
         '''QString KDialog.buttonText(KDialog.ButtonCode id)'''
         return QString()
     def setButtonText(self, id, text):
         '''void KDialog.setButtonText(KDialog.ButtonCode id, QString text)'''
     def showButton(self, id, state):
         '''void KDialog.showButton(KDialog.ButtonCode id, bool state)'''
     def showButtonSeparator(self, state):
         '''void KDialog.showButtonSeparator(bool state)'''
     def defaultButton(self):
         '''KDialog.ButtonCode KDialog.defaultButton()'''
         return KDialog.ButtonCode()
     def setDefaultButton(self, id):
         '''void KDialog.setDefaultButton(KDialog.ButtonCode id)'''
     def setEscapeButton(self, id):
         '''void KDialog.setEscapeButton(KDialog.ButtonCode id)'''
     def setButtonsOrientation(self, orientation):
         '''void KDialog.setButtonsOrientation(Qt.Orientation orientation)'''
     def setButtons(self, buttonMask):
         '''void KDialog.setButtons(KDialog.ButtonCodes buttonMask)'''
     class ButtonPopupModes():
         """"""
         def __init__(self):
             '''KDialog.ButtonPopupModes KDialog.ButtonPopupModes.__init__()'''
             return KDialog.ButtonPopupModes()
         def __init__(self):
             '''int KDialog.ButtonPopupModes.__init__()'''
             return int()
         def __init__(self):
             '''void KDialog.ButtonPopupModes.__init__()'''
         def __bool__(self):
             '''int KDialog.ButtonPopupModes.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KDialog.ButtonPopupModes.__ne__(KDialog.ButtonPopupModes f)'''
             return bool()
         def __eq__(self, f):
             '''bool KDialog.ButtonPopupModes.__eq__(KDialog.ButtonPopupModes f)'''
             return bool()
         def __invert__(self):
             '''KDialog.ButtonPopupModes KDialog.ButtonPopupModes.__invert__()'''
             return KDialog.ButtonPopupModes()
         def __and__(self, mask):
             '''KDialog.ButtonPopupModes KDialog.ButtonPopupModes.__and__(int mask)'''
             return KDialog.ButtonPopupModes()
         def __xor__(self, f):
             '''KDialog.ButtonPopupModes KDialog.ButtonPopupModes.__xor__(KDialog.ButtonPopupModes f)'''
             return KDialog.ButtonPopupModes()
         def __xor__(self, f):
             '''KDialog.ButtonPopupModes KDialog.ButtonPopupModes.__xor__(int f)'''
             return KDialog.ButtonPopupModes()
         def __or__(self, f):
             '''KDialog.ButtonPopupModes KDialog.ButtonPopupModes.__or__(KDialog.ButtonPopupModes f)'''
             return KDialog.ButtonPopupModes()
         def __or__(self, f):
             '''KDialog.ButtonPopupModes KDialog.ButtonPopupModes.__or__(int f)'''
             return KDialog.ButtonPopupModes()
         def __int__(self):
             '''int KDialog.ButtonPopupModes.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KDialog.ButtonPopupModes KDialog.ButtonPopupModes.__ixor__(KDialog.ButtonPopupModes f)'''
             return KDialog.ButtonPopupModes()
         def __ior__(self, f):
             '''KDialog.ButtonPopupModes KDialog.ButtonPopupModes.__ior__(KDialog.ButtonPopupModes f)'''
             return KDialog.ButtonPopupModes()
         def __iand__(self, mask):
             '''KDialog.ButtonPopupModes KDialog.ButtonPopupModes.__iand__(int mask)'''
             return KDialog.ButtonPopupModes()
     class ButtonCodes():
         """"""
         def __init__(self):
             '''KDialog.ButtonCodes KDialog.ButtonCodes.__init__()'''
             return KDialog.ButtonCodes()
         def __init__(self):
             '''int KDialog.ButtonCodes.__init__()'''
             return int()
         def __init__(self):
             '''void KDialog.ButtonCodes.__init__()'''
         def __bool__(self):
             '''int KDialog.ButtonCodes.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KDialog.ButtonCodes.__ne__(KDialog.ButtonCodes f)'''
             return bool()
         def __eq__(self, f):
             '''bool KDialog.ButtonCodes.__eq__(KDialog.ButtonCodes f)'''
             return bool()
         def __invert__(self):
             '''KDialog.ButtonCodes KDialog.ButtonCodes.__invert__()'''
             return KDialog.ButtonCodes()
         def __and__(self, mask):
             '''KDialog.ButtonCodes KDialog.ButtonCodes.__and__(int mask)'''
             return KDialog.ButtonCodes()
         def __xor__(self, f):
             '''KDialog.ButtonCodes KDialog.ButtonCodes.__xor__(KDialog.ButtonCodes f)'''
             return KDialog.ButtonCodes()
         def __xor__(self, f):
             '''KDialog.ButtonCodes KDialog.ButtonCodes.__xor__(int f)'''
             return KDialog.ButtonCodes()
         def __or__(self, f):
             '''KDialog.ButtonCodes KDialog.ButtonCodes.__or__(KDialog.ButtonCodes f)'''
             return KDialog.ButtonCodes()
         def __or__(self, f):
             '''KDialog.ButtonCodes KDialog.ButtonCodes.__or__(int f)'''
             return KDialog.ButtonCodes()
         def __int__(self):
             '''int KDialog.ButtonCodes.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KDialog.ButtonCodes KDialog.ButtonCodes.__ixor__(KDialog.ButtonCodes f)'''
             return KDialog.ButtonCodes()
         def __ior__(self, f):
             '''KDialog.ButtonCodes KDialog.ButtonCodes.__ior__(KDialog.ButtonCodes f)'''
             return KDialog.ButtonCodes()
         def __iand__(self, mask):
             '''KDialog.ButtonCodes KDialog.ButtonCodes.__iand__(int mask)'''
             return KDialog.ButtonCodes()
     class CaptionFlags():
         """"""
         def __init__(self):
             '''KDialog.CaptionFlags KDialog.CaptionFlags.__init__()'''
             return KDialog.CaptionFlags()
         def __init__(self):
             '''int KDialog.CaptionFlags.__init__()'''
             return int()
         def __init__(self):
             '''void KDialog.CaptionFlags.__init__()'''
         def __bool__(self):
             '''int KDialog.CaptionFlags.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KDialog.CaptionFlags.__ne__(KDialog.CaptionFlags f)'''
             return bool()
         def __eq__(self, f):
             '''bool KDialog.CaptionFlags.__eq__(KDialog.CaptionFlags f)'''
             return bool()
         def __invert__(self):
             '''KDialog.CaptionFlags KDialog.CaptionFlags.__invert__()'''
             return KDialog.CaptionFlags()
         def __and__(self, mask):
             '''KDialog.CaptionFlags KDialog.CaptionFlags.__and__(int mask)'''
             return KDialog.CaptionFlags()
         def __xor__(self, f):
             '''KDialog.CaptionFlags KDialog.CaptionFlags.__xor__(KDialog.CaptionFlags f)'''
             return KDialog.CaptionFlags()
         def __xor__(self, f):
             '''KDialog.CaptionFlags KDialog.CaptionFlags.__xor__(int f)'''
             return KDialog.CaptionFlags()
         def __or__(self, f):
             '''KDialog.CaptionFlags KDialog.CaptionFlags.__or__(KDialog.CaptionFlags f)'''
             return KDialog.CaptionFlags()
         def __or__(self, f):
             '''KDialog.CaptionFlags KDialog.CaptionFlags.__or__(int f)'''
             return KDialog.CaptionFlags()
         def __int__(self):
             '''int KDialog.CaptionFlags.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KDialog.CaptionFlags KDialog.CaptionFlags.__ixor__(KDialog.CaptionFlags f)'''
             return KDialog.CaptionFlags()
         def __ior__(self, f):
             '''KDialog.CaptionFlags KDialog.CaptionFlags.__ior__(KDialog.CaptionFlags f)'''
             return KDialog.CaptionFlags()
         def __iand__(self, mask):
             '''KDialog.CaptionFlags KDialog.CaptionFlags.__iand__(int mask)'''
             return KDialog.CaptionFlags()
 
 
 class KAboutApplicationDialog(KDialog):
     """"""
     # Enum KAboutApplicationDialog.Option
     NoOptions = 0
     HideTranslators = 0
     HideKdeVersion = 0
 
     def __init__(self, aboutData, parent = None):
         '''void KAboutApplicationDialog.__init__(KAboutData aboutData, QWidget parent = None)'''
     def __init__(self, aboutData, opts, parent = None):
         '''void KAboutApplicationDialog.__init__(KAboutData aboutData, KAboutApplicationDialog.Options opts, QWidget parent = None)'''
     class Options():
         """"""
         def __init__(self):
             '''KAboutApplicationDialog.Options KAboutApplicationDialog.Options.__init__()'''
             return KAboutApplicationDialog.Options()
         def __init__(self):
             '''int KAboutApplicationDialog.Options.__init__()'''
             return int()
         def __init__(self):
             '''void KAboutApplicationDialog.Options.__init__()'''
         def __bool__(self):
             '''int KAboutApplicationDialog.Options.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KAboutApplicationDialog.Options.__ne__(KAboutApplicationDialog.Options f)'''
             return bool()
         def __eq__(self, f):
             '''bool KAboutApplicationDialog.Options.__eq__(KAboutApplicationDialog.Options f)'''
             return bool()
         def __invert__(self):
             '''KAboutApplicationDialog.Options KAboutApplicationDialog.Options.__invert__()'''
             return KAboutApplicationDialog.Options()
         def __and__(self, mask):
             '''KAboutApplicationDialog.Options KAboutApplicationDialog.Options.__and__(int mask)'''
             return KAboutApplicationDialog.Options()
         def __xor__(self, f):
             '''KAboutApplicationDialog.Options KAboutApplicationDialog.Options.__xor__(KAboutApplicationDialog.Options f)'''
             return KAboutApplicationDialog.Options()
         def __xor__(self, f):
             '''KAboutApplicationDialog.Options KAboutApplicationDialog.Options.__xor__(int f)'''
             return KAboutApplicationDialog.Options()
         def __or__(self, f):
             '''KAboutApplicationDialog.Options KAboutApplicationDialog.Options.__or__(KAboutApplicationDialog.Options f)'''
             return KAboutApplicationDialog.Options()
         def __or__(self, f):
             '''KAboutApplicationDialog.Options KAboutApplicationDialog.Options.__or__(int f)'''
             return KAboutApplicationDialog.Options()
         def __int__(self):
             '''int KAboutApplicationDialog.Options.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KAboutApplicationDialog.Options KAboutApplicationDialog.Options.__ixor__(KAboutApplicationDialog.Options f)'''
             return KAboutApplicationDialog.Options()
         def __ior__(self, f):
             '''KAboutApplicationDialog.Options KAboutApplicationDialog.Options.__ior__(KAboutApplicationDialog.Options f)'''
             return KAboutApplicationDialog.Options()
         def __iand__(self, mask):
             '''KAboutApplicationDialog.Options KAboutApplicationDialog.Options.__iand__(int mask)'''
             return KAboutApplicationDialog.Options()
 
 
 class KAbstractWidgetJobTracker(KJobTrackerInterface):
     """"""
     def __init__(self, parent = None):
         '''void KAbstractWidgetJobTracker.__init__(QWidget parent = None)'''
     resume = pyqtSignal() # void resume(KJob *) - signal
     suspend = pyqtSignal() # void suspend(KJob *) - signal
     stopped = pyqtSignal() # void stopped(KJob *) - signal
     def slotClean(self, job):
         '''void KAbstractWidgetJobTracker.slotClean(KJob job)'''
     def slotResume(self, job):
         '''void KAbstractWidgetJobTracker.slotResume(KJob job)'''
     def slotSuspend(self, job):
         '''void KAbstractWidgetJobTracker.slotSuspend(KJob job)'''
     def slotStop(self, job):
         '''void KAbstractWidgetJobTracker.slotStop(KJob job)'''
     def finished(self, job):
         '''void KAbstractWidgetJobTracker.finished(KJob job)'''
     def autoDelete(self, job):
         '''bool KAbstractWidgetJobTracker.autoDelete(KJob job)'''
         return bool()
     def setAutoDelete(self, job, autoDelete):
         '''void KAbstractWidgetJobTracker.setAutoDelete(KJob job, bool autoDelete)'''
     def stopOnClose(self, job):
         '''bool KAbstractWidgetJobTracker.stopOnClose(KJob job)'''
         return bool()
     def setStopOnClose(self, job, stopOnClose):
         '''void KAbstractWidgetJobTracker.setStopOnClose(KJob job, bool stopOnClose)'''
     def widget(self, job):
         '''abstract QWidget KAbstractWidgetJobTracker.widget(KJob job)'''
         return QWidget()
     def unregisterJob(self, job):
         '''void KAbstractWidgetJobTracker.unregisterJob(KJob job)'''
     def registerJob(self, job):
         '''void KAbstractWidgetJobTracker.registerJob(KJob job)'''
 
 
 class KAcceleratorManager():
     """"""
     def __init__(self):
         '''void KAcceleratorManager.__init__()'''
     def __init__(self):
         '''KAcceleratorManager KAcceleratorManager.__init__()'''
         return KAcceleratorManager()
     def setNoAccel(self, widget):
         '''static void KAcceleratorManager.setNoAccel(QWidget widget)'''
     def last_manage(self, added, changed, removed):
         '''static void KAcceleratorManager.last_manage(QString added, QString changed, QString removed)'''
     def manage(self, widget, programmers_mode = False):
         '''static void KAcceleratorManager.manage(QWidget widget, bool programmers_mode = False)'''
 
 
 class KAccelGen():
     """"""
     def generate(self, source, target):
         '''static void KAccelGen.generate(QStringList source, QStringList target)'''
     def isLegalAccelerator(self, str, index):
         '''static bool KAccelGen.isLegalAccelerator(QString str, int index)'''
         return bool()
 
 
 class KAction(QWidgetAction):
     """"""
     # Enum KAction.GlobalShortcutLoading
     Autoloading = 0
     NoAutoloading = 0
 
     # Enum KAction.ShortcutType
     ActiveShortcut = 0
     DefaultShortcut = 0
 
     def __init__(self, parent):
         '''void KAction.__init__(QObject parent)'''
     def __init__(self, text, parent):
         '''void KAction.__init__(QString text, QObject parent)'''
     def __init__(self, icon, text, parent):
         '''void KAction.__init__(KIcon icon, QString text, QObject parent)'''
     authorized = pyqtSignal() # void authorized(KAuth::Action *) - signal
     def setAuthAction(self, action):
         '''void KAction.setAuthAction(KAuth.Action action)'''
     def setAuthAction(self, actionName):
         '''void KAction.setAuthAction(QString actionName)'''
     def authAction(self):
         '''KAuth.Action KAction.authAction()'''
         return KAuth.Action()
     globalShortcutChanged = pyqtSignal() # void globalShortcutChanged(const QKeySequenceamp;) - signal
     triggered = pyqtSignal() # void triggered(Qt::MouseButtons,Qt::KeyboardModifiers) - signal
     def event(self):
         '''QEvent KAction.event()'''
         return QEvent()
     def setRockerGesture(self, gest, type = None):
         '''void KAction.setRockerGesture(KRockerGesture gest, KAction.ShortcutTypes type = KAction.ShortcutTypes(KAction.ActiveShortcut|KAction.DefaultShortcut))'''
     def setShapeGesture(self, gest, type = None):
         '''void KAction.setShapeGesture(KShapeGesture gest, KAction.ShortcutTypes type = KAction.ShortcutTypes(KAction.ActiveShortcut|KAction.DefaultShortcut))'''
     def rockerGesture(self, type = None):
         '''KRockerGesture KAction.rockerGesture(KAction.ShortcutTypes type = KAction.ActiveShortcut)'''
         return KRockerGesture()
     def shapeGesture(self, type = None):
         '''KShapeGesture KAction.shapeGesture(KAction.ShortcutTypes type = KAction.ActiveShortcut)'''
         return KShapeGesture()
     def forgetGlobalShortcut(self):
         '''void KAction.forgetGlobalShortcut()'''
     def isGlobalShortcutEnabled(self):
         '''bool KAction.isGlobalShortcutEnabled()'''
         return bool()
     def setGlobalShortcutAllowed(self, allowed, loading = None):
         '''void KAction.setGlobalShortcutAllowed(bool allowed, KAction.GlobalShortcutLoading loading = KAction.Autoloading)'''
     def globalShortcutAllowed(self):
         '''bool KAction.globalShortcutAllowed()'''
         return bool()
     def setGlobalShortcut(self, shortcut, type = None, loading = None):
         '''void KAction.setGlobalShortcut(KShortcut shortcut, KAction.ShortcutTypes type = KAction.ShortcutTypes(KAction.ActiveShortcut|KAction.DefaultShortcut), KAction.GlobalShortcutLoading loading = KAction.Autoloading)'''
     def globalShortcut(self, type = None):
         '''KShortcut KAction.globalShortcut(KAction.ShortcutTypes type = KAction.ActiveShortcut)'''
         return KShortcut()
     def setShortcutConfigurable(self, configurable):
         '''void KAction.setShortcutConfigurable(bool configurable)'''
     def isShortcutConfigurable(self):
         '''bool KAction.isShortcutConfigurable()'''
         return bool()
     def setShortcuts(self, shortcuts, type = None):
         '''void KAction.setShortcuts(list-of-QKeySequence shortcuts, KAction.ShortcutTypes type = KAction.ShortcutTypes(KAction.ActiveShortcut|KAction.DefaultShortcut))'''
     def setShortcut(self, shortcut, type = None):
         '''void KAction.setShortcut(KShortcut shortcut, KAction.ShortcutTypes type = KAction.ShortcutTypes(KAction.ActiveShortcut|KAction.DefaultShortcut))'''
     def setShortcut(self, shortcut, type = None):
         '''void KAction.setShortcut(QKeySequence shortcut, KAction.ShortcutTypes type = KAction.ShortcutTypes(KAction.ActiveShortcut|KAction.DefaultShortcut))'''
     def shortcut(self, types = None):
         '''KShortcut KAction.shortcut(KAction.ShortcutTypes types = KAction.ActiveShortcut)'''
         return KShortcut()
     def setHelpText(self, text):
         '''void KAction.setHelpText(QString text)'''
     class ShortcutTypes():
         """"""
         def __init__(self):
             '''KAction.ShortcutTypes KAction.ShortcutTypes.__init__()'''
             return KAction.ShortcutTypes()
         def __init__(self):
             '''int KAction.ShortcutTypes.__init__()'''
             return int()
         def __init__(self):
             '''void KAction.ShortcutTypes.__init__()'''
         def __bool__(self):
             '''int KAction.ShortcutTypes.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KAction.ShortcutTypes.__ne__(KAction.ShortcutTypes f)'''
             return bool()
         def __eq__(self, f):
             '''bool KAction.ShortcutTypes.__eq__(KAction.ShortcutTypes f)'''
             return bool()
         def __invert__(self):
             '''KAction.ShortcutTypes KAction.ShortcutTypes.__invert__()'''
             return KAction.ShortcutTypes()
         def __and__(self, mask):
             '''KAction.ShortcutTypes KAction.ShortcutTypes.__and__(int mask)'''
             return KAction.ShortcutTypes()
         def __xor__(self, f):
             '''KAction.ShortcutTypes KAction.ShortcutTypes.__xor__(KAction.ShortcutTypes f)'''
             return KAction.ShortcutTypes()
         def __xor__(self, f):
             '''KAction.ShortcutTypes KAction.ShortcutTypes.__xor__(int f)'''
             return KAction.ShortcutTypes()
         def __or__(self, f):
             '''KAction.ShortcutTypes KAction.ShortcutTypes.__or__(KAction.ShortcutTypes f)'''
             return KAction.ShortcutTypes()
         def __or__(self, f):
             '''KAction.ShortcutTypes KAction.ShortcutTypes.__or__(int f)'''
             return KAction.ShortcutTypes()
         def __int__(self):
             '''int KAction.ShortcutTypes.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KAction.ShortcutTypes KAction.ShortcutTypes.__ixor__(KAction.ShortcutTypes f)'''
             return KAction.ShortcutTypes()
         def __ior__(self, f):
             '''KAction.ShortcutTypes KAction.ShortcutTypes.__ior__(KAction.ShortcutTypes f)'''
             return KAction.ShortcutTypes()
         def __iand__(self, mask):
             '''KAction.ShortcutTypes KAction.ShortcutTypes.__iand__(int mask)'''
             return KAction.ShortcutTypes()
 
 
 class KActionCategory(QObject):
     """"""
     def __init__(self, text, parent = None):
         '''void KActionCategory.__init__(QString text, KActionCollection parent = None)'''
     def setText(self, text):
         '''void KActionCategory.setText(QString text)'''
     def text(self):
         '''QString KActionCategory.text()'''
         return QString()
     def collection(self):
         '''KActionCollection KActionCategory.collection()'''
         return KActionCollection()
     def actions(self):
         '''list-of-QAction KActionCategory.actions()'''
         return [QAction()]
     def addAction(self, name, action):
         '''QAction KActionCategory.addAction(QString name, QAction action)'''
         return QAction()
     def addAction(self, name, action):
         '''KAction KActionCategory.addAction(QString name, KAction action)'''
         return KAction()
     def addAction(self, actionType, receiver = None, member = None):
         '''KAction KActionCategory.addAction(KStandardAction.StandardAction actionType, QObject receiver = None, str member = None)'''
         return KAction()
     def addAction(self, actionType, name, receiver = None, member = None):
         '''KAction KActionCategory.addAction(KStandardAction.StandardAction actionType, QString name, QObject receiver = None, str member = None)'''
         return KAction()
     def addAction(self, name, receiver = None, member = None):
         '''KAction KActionCategory.addAction(QString name, QObject receiver = None, str member = None)'''
         return KAction()
 
 
 class KActionCollection(QObject):
     """"""
     def __init__(self, parent, cData = KComponentData()):
         '''void KActionCollection.__init__(QObject parent, KComponentData cData = KComponentData())'''
     def takeAction(self, action):
         '''QAction KActionCollection.takeAction(QAction action)'''
         return QAction()
     def removeAction(self, action):
         '''void KActionCollection.removeAction(QAction action)'''
     def addAction(self, name, action):
         '''QAction KActionCollection.addAction(QString name, QAction action)'''
         return QAction()
     def addAction(self, name, action):
         '''KAction KActionCollection.addAction(QString name, KAction action)'''
         return KAction()
     def addAction(self, actionType, receiver = None, member = None):
         '''KAction KActionCollection.addAction(KStandardAction.StandardAction actionType, QObject receiver = None, str member = None)'''
         return KAction()
     def addAction(self, actionType, name, receiver = None, member = None):
         '''KAction KActionCollection.addAction(KStandardAction.StandardAction actionType, QString name, QObject receiver = None, str member = None)'''
         return KAction()
     def addAction(self, name, receiver = None, member = None):
         '''KAction KActionCollection.addAction(QString name, QObject receiver = None, str member = None)'''
         return KAction()
     def slotActionHighlighted(self):
         '''void KActionCollection.slotActionHighlighted()'''
     def slotActionTriggered(self):
         '''void KActionCollection.slotActionTriggered()'''
     def connectNotify(self):
         '''SIGNAL() KActionCollection.connectNotify()'''
         return SIGNAL()()
     actionTriggered = pyqtSignal() # void actionTriggered(QAction *) - signal
     actionHovered = pyqtSignal() # void actionHovered(QAction *) - signal
     actionHighlighted = pyqtSignal() # void actionHighlighted(QAction *) - signal
     removed = pyqtSignal() # void removed(QAction *) - signal
     inserted = pyqtSignal() # void inserted(QAction *) - signal
     def parentGUIClient(self):
         '''KXMLGUIClient KActionCollection.parentGUIClient()'''
         return KXMLGUIClient()
     def componentData(self):
         '''KComponentData KActionCollection.componentData()'''
         return KComponentData()
     def setComponentData(self, componentData):
         '''void KActionCollection.setComponentData(KComponentData componentData)'''
     def actionGroups(self):
         '''list-of-QActionGroup KActionCollection.actionGroups()'''
         return [QActionGroup()]
     def actionsWithoutGroup(self):
         '''list-of-QAction KActionCollection.actionsWithoutGroup()'''
         return [QAction()]
     def actions(self):
         '''list-of-QAction KActionCollection.actions()'''
         return [QAction()]
     def action(self, index):
         '''QAction KActionCollection.action(int index)'''
         return QAction()
     def action(self, name):
         '''QAction KActionCollection.action(QString name)'''
         return QAction()
     def isEmpty(self):
         '''bool KActionCollection.isEmpty()'''
         return bool()
     def count(self):
         '''int KActionCollection.count()'''
         return int()
     def writeSettings(self, config = None, writeDefaults = False, oneAction = None):
         '''void KActionCollection.writeSettings(KConfigGroup config = None, bool writeDefaults = False, QAction oneAction = None)'''
     def exportGlobalShortcuts(self, config, writeDefaults = False):
         '''void KActionCollection.exportGlobalShortcuts(KConfigGroup config, bool writeDefaults = False)'''
     def importGlobalShortcuts(self, config):
         '''void KActionCollection.importGlobalShortcuts(KConfigGroup config)'''
     def readSettings(self, config = None):
         '''void KActionCollection.readSettings(KConfigGroup config = None)'''
     def setConfigGlobal(self, global_):
         '''void KActionCollection.setConfigGlobal(bool global)'''
     def setConfigGroup(self, group):
         '''void KActionCollection.setConfigGroup(QString group)'''
     def configIsGlobal(self):
         '''bool KActionCollection.configIsGlobal()'''
         return bool()
     def configGroup(self):
         '''QString KActionCollection.configGroup()'''
         return QString()
     def clearAssociatedWidgets(self):
         '''void KActionCollection.clearAssociatedWidgets()'''
     def associatedWidgets(self):
         '''list-of-QWidget KActionCollection.associatedWidgets()'''
         return [QWidget()]
     def removeAssociatedWidget(self, widget):
         '''void KActionCollection.removeAssociatedWidget(QWidget widget)'''
     def addAssociatedWidget(self, widget):
         '''void KActionCollection.addAssociatedWidget(QWidget widget)'''
     def associateWidget(self, widget):
         '''void KActionCollection.associateWidget(QWidget widget)'''
     def clear(self):
         '''void KActionCollection.clear()'''
     def allCollections(self):
         '''static list-of-KActionCollection KActionCollection.allCollections()'''
         return [KActionCollection()]
 
 
 class KActionMenu(KAction):
     """"""
     def __init__(self, parent):
         '''void KActionMenu.__init__(QObject parent)'''
     def __init__(self, text, parent):
         '''void KActionMenu.__init__(QString text, QObject parent)'''
     def __init__(self, icon, text, parent):
         '''void KActionMenu.__init__(KIcon icon, QString text, QObject parent)'''
     def createWidget(self, parent):
         '''QWidget KActionMenu.createWidget(QWidget parent)'''
         return QWidget()
     def setStickyMenu(self, sticky):
         '''void KActionMenu.setStickyMenu(bool sticky)'''
     def stickyMenu(self):
         '''bool KActionMenu.stickyMenu()'''
         return bool()
     def setDelayed(self, delayed):
         '''void KActionMenu.setDelayed(bool delayed)'''
     def delayed(self):
         '''bool KActionMenu.delayed()'''
         return bool()
     def setMenu(self, menu):
         '''void KActionMenu.setMenu(KMenu menu)'''
     def menu(self):
         '''KMenu KActionMenu.menu()'''
         return KMenu()
     def popupMenu(self):
         '''KMenu KActionMenu.popupMenu()'''
         return KMenu()
     def removeAction(self, action):
         '''void KActionMenu.removeAction(QAction action)'''
     def insertSeparator(self, before):
         '''QAction KActionMenu.insertSeparator(QAction before)'''
         return QAction()
     def insertAction(self, before, action):
         '''void KActionMenu.insertAction(QAction before, QAction action)'''
     def addSeparator(self):
         '''QAction KActionMenu.addSeparator()'''
         return QAction()
     def addAction(self, action):
         '''void KActionMenu.addAction(QAction action)'''
     def remove(self):
         '''KAction KActionMenu.remove()'''
         return KAction()
 
 
 class KActionSelector(QWidget):
     """"""
     # Enum KActionSelector.InsertionPolicy
     BelowCurrent = 0
     Sorted = 0
     AtTop = 0
     AtBottom = 0
 
     # Enum KActionSelector.MoveButton
     ButtonAdd = 0
     ButtonRemove = 0
     ButtonUp = 0
     ButtonDown = 0
 
     def __init__(self, parent = None):
         '''void KActionSelector.__init__(QWidget parent = None)'''
     def eventFilter(self):
         '''QEvent KActionSelector.eventFilter()'''
         return QEvent()
     def keyPressEvent(self):
         '''QKeyEvent KActionSelector.keyPressEvent()'''
         return QKeyEvent()
     def polish(self):
         '''void KActionSelector.polish()'''
     movedDown = pyqtSignal() # void movedDown(QListWidgetItem *) - signal
     movedUp = pyqtSignal() # void movedUp(QListWidgetItem *) - signal
     removed = pyqtSignal() # void removed(QListWidgetItem *) - signal
     added = pyqtSignal() # void added(QListWidgetItem *) - signal
     def setButtonsEnabled(self):
         '''void KActionSelector.setButtonsEnabled()'''
     def setButtonWhatsThis(self, text, button):
         '''void KActionSelector.setButtonWhatsThis(QString text, KActionSelector.MoveButton button)'''
     def setButtonTooltip(self, tip, button):
         '''void KActionSelector.setButtonTooltip(QString tip, KActionSelector.MoveButton button)'''
     def setButtonIconSet(self, iconset, button):
         '''void KActionSelector.setButtonIconSet(QIcon iconset, KActionSelector.MoveButton button)'''
     def setButtonIcon(self, icon, button):
         '''void KActionSelector.setButtonIcon(QString icon, KActionSelector.MoveButton button)'''
     def setShowUpDownButtons(self, show):
         '''void KActionSelector.setShowUpDownButtons(bool show)'''
     def showUpDownButtons(self):
         '''bool KActionSelector.showUpDownButtons()'''
         return bool()
     def setSelectedInsertionPolicy(self, policy):
         '''void KActionSelector.setSelectedInsertionPolicy(KActionSelector.InsertionPolicy policy)'''
     def selectedInsertionPolicy(self):
         '''KActionSelector.InsertionPolicy KActionSelector.selectedInsertionPolicy()'''
         return KActionSelector.InsertionPolicy()
     def setAvailableInsertionPolicy(self, policy):
         '''void KActionSelector.setAvailableInsertionPolicy(KActionSelector.InsertionPolicy policy)'''
     def availableInsertionPolicy(self):
         '''KActionSelector.InsertionPolicy KActionSelector.availableInsertionPolicy()'''
         return KActionSelector.InsertionPolicy()
     def setSelectedLabel(self, text):
         '''void KActionSelector.setSelectedLabel(QString text)'''
     def selectedLabel(self):
         '''QString KActionSelector.selectedLabel()'''
         return QString()
     def setAvailableLabel(self, text):
         '''void KActionSelector.setAvailableLabel(QString text)'''
     def availableLabel(self):
         '''QString KActionSelector.availableLabel()'''
         return QString()
     def setKeyboardEnabled(self, enable):
         '''void KActionSelector.setKeyboardEnabled(bool enable)'''
     def keyboardEnabled(self):
         '''bool KActionSelector.keyboardEnabled()'''
         return bool()
     def setMoveOnDoubleClick(self, enable):
         '''void KActionSelector.setMoveOnDoubleClick(bool enable)'''
     def moveOnDoubleClick(self):
         '''bool KActionSelector.moveOnDoubleClick()'''
         return bool()
     def selectedListWidget(self):
         '''QListWidget KActionSelector.selectedListWidget()'''
         return QListWidget()
     def availableListWidget(self):
         '''QListWidget KActionSelector.availableListWidget()'''
         return QListWidget()
 
 
 class KAnimatedButton(QToolButton):
     """"""
     def __init__(self, parent = None):
         '''void KAnimatedButton.__init__(QWidget parent = None)'''
     def slotTimerUpdate(self):
         '''void KAnimatedButton.slotTimerUpdate()'''
     clicked = pyqtSignal() # void clicked() - signal
     def updateIcons(self):
         '''void KAnimatedButton.updateIcons()'''
     def stop(self):
         '''void KAnimatedButton.stop()'''
     def start(self):
         '''void KAnimatedButton.start()'''
     def setIcons(self, icons):
         '''void KAnimatedButton.setIcons(QString icons)'''
     def icons(self):
         '''QString KAnimatedButton.icons()'''
         return QString()
     def iconDimensions(self):
         '''int KAnimatedButton.iconDimensions()'''
         return int()
 
 
 class KApplication(QApplication):
     """"""
     loadedByKdeinit = None # bool - member
     def __init__(self, GUIenabled = True):
         '''void KApplication.__init__(bool GUIenabled = True)'''
     def __init__(self, display, visual = 0, colormap = 0):
         '''void KApplication.__init__(Display display, int visual = 0, int colormap = 0)'''
     def __init__(self, display, list, rAppName, GUIenabled = True):
         '''void KApplication.__init__(Display display, list list, QByteArray rAppName, bool GUIenabled = True)'''
     def __init__(self, GUIenabled, cData):
         '''void KApplication.__init__(bool GUIenabled, KComponentData cData)'''
     def __init__(self, display, visual, colormap, cData):
         '''void KApplication.__init__(Display display, int visual, int colormap, KComponentData cData)'''
     saveYourself = pyqtSignal() # void saveYourself() - signal
     def quit(self):
         '''void KApplication.quit()'''
     def reparseConfiguration(self):
         '''void KApplication.reparseConfiguration()'''
     def updateUserTimestamp(self, time = 0):
         '''void KApplication.updateUserTimestamp(int time = 0)'''
     def xioErrhandler(self):
         '''Display KApplication.xioErrhandler()'''
         return Display()
     def notify(self, receiver, event):
         '''bool KApplication.notify(QObject receiver, QEvent event)'''
         return bool()
     def updateRemoteUserTimestamp(self, service, time = 0):
         '''void KApplication.updateRemoteUserTimestamp(QString service, int time = 0)'''
     def userTimestamp(self):
         '''int KApplication.userTimestamp()'''
         return int()
     def setSynchronizeClipboard(self, synchronize):
         '''void KApplication.setSynchronizeClipboard(bool synchronize)'''
     def clearStartupId(self):
         '''void KApplication.clearStartupId()'''
     def setStartupId(self, startup_id):
         '''void KApplication.setStartupId(QByteArray startup_id)'''
     def startupId(self):
         '''QByteArray KApplication.startupId()'''
         return QByteArray()
     def removeX11EventFilter(self, filter):
         '''void KApplication.removeX11EventFilter(QWidget filter)'''
     def installX11EventFilter(self, filter):
         '''void KApplication.installX11EventFilter(QWidget filter)'''
     def checkRecoverFile(self, pFilename, bRecover):
         '''static QString KApplication.checkRecoverFile(QString pFilename, bool bRecover)'''
         return QString()
     def tempSaveName(self, pFilename):
         '''static QString KApplication.tempSaveName(QString pFilename)'''
         return QString()
     def setTopWidget(self, topWidget):
         '''void KApplication.setTopWidget(QWidget topWidget)'''
     def sessionSaving(self):
         '''bool KApplication.sessionSaving()'''
         return bool()
     def saveState(self, sm):
         '''void KApplication.saveState(QSessionManager sm)'''
     def commitData(self, sm):
         '''void KApplication.commitData(QSessionManager sm)'''
     def enableSessionManagement(self):
         '''void KApplication.enableSessionManagement()'''
     def disableSessionManagement(self):
         '''void KApplication.disableSessionManagement()'''
     def sessionConfig(self):
         '''KConfig KApplication.sessionConfig()'''
         return KConfig()
     def kApplication(self):
         '''static KApplication KApplication.kApplication()'''
         return KApplication()
 
 
 class KArrowButton(QPushButton):
     """"""
     def __init__(self, parent = None, arrow = None):
         '''void KArrowButton.__init__(QWidget parent = None, Qt.ArrowType arrow = Qt.UpArrow)'''
     def paintEvent(self):
         '''QPaintEvent KArrowButton.paintEvent()'''
         return QPaintEvent()
     def setArrowType(self, a):
         '''void KArrowButton.setArrowType(Qt.ArrowType a)'''
     def setArrowTp(self, tp):
         '''void KArrowButton.setArrowTp(int tp)'''
     def arrowTp(self):
         '''int KArrowButton.arrowTp()'''
         return int()
     def arrowType(self):
         '''Qt.ArrowType KArrowButton.arrowType()'''
         return Qt.ArrowType()
     def sizeHint(self):
         '''QSize KArrowButton.sizeHint()'''
         return QSize()
 
 
 class KPageDialog(KDialog):
     """"""
     # Enum KPageDialog.FaceType
     Auto = 0
     Plain = 0
     List = 0
     Tree = 0
     Tabbed = 0
 
     def __init__(self, parent = None, flags = 0):
         '''void KPageDialog.__init__(QWidget parent = None, Qt.WindowFlags flags = 0)'''
     def __init__(self, widget, parent, flags = 0):
         '''void KPageDialog.__init__(KPageWidget widget, QWidget parent, Qt.WindowFlags flags = 0)'''
     def setPageWidget(self, widget):
         '''void KPageDialog.setPageWidget(KPageWidget widget)'''
     def pageWidget(self):
         '''KPageWidget KPageDialog.pageWidget()'''
         return KPageWidget()
     pageRemoved = pyqtSignal() # void pageRemoved(KPageWidgetItem *) - signal
     currentPageChanged = pyqtSignal() # void currentPageChanged(KPageWidgetItem *,KPageWidgetItem *) - signal
     def currentPage(self):
         '''KPageWidgetItem KPageDialog.currentPage()'''
         return KPageWidgetItem()
     def setCurrentPage(self, item):
         '''void KPageDialog.setCurrentPage(KPageWidgetItem item)'''
     def removePage(self, item):
         '''void KPageDialog.removePage(KPageWidgetItem item)'''
     def addSubPage(self, parent, widget, name):
         '''KPageWidgetItem KPageDialog.addSubPage(KPageWidgetItem parent, QWidget widget, QString name)'''
         return KPageWidgetItem()
     def addSubPage(self, parent, item):
         '''void KPageDialog.addSubPage(KPageWidgetItem parent, KPageWidgetItem item)'''
     def insertPage(self, before, widget, name):
         '''KPageWidgetItem KPageDialog.insertPage(KPageWidgetItem before, QWidget widget, QString name)'''
         return KPageWidgetItem()
     def insertPage(self, before, item):
         '''void KPageDialog.insertPage(KPageWidgetItem before, KPageWidgetItem item)'''
     def addPage(self, widget, name):
         '''KPageWidgetItem KPageDialog.addPage(QWidget widget, QString name)'''
         return KPageWidgetItem()
     def addPage(self, item):
         '''void KPageDialog.addPage(KPageWidgetItem item)'''
     def setFaceType(self, faceType):
         '''void KPageDialog.setFaceType(KPageDialog.FaceType faceType)'''
 
 
 class KAssistantDialog(KPageDialog):
     """"""
     def __init__(self, parent = None, flags = 0):
         '''void KAssistantDialog.__init__(QWidget parent = None, Qt.WindowFlags flags = 0)'''
     def __init__(self, widget, parent = None, flags = 0):
         '''void KAssistantDialog.__init__(KPageWidget widget, QWidget parent = None, Qt.WindowFlags flags = 0)'''
     def showEvent(self, event):
         '''void KAssistantDialog.showEvent(QShowEvent event)'''
     def next(self):
         '''void KAssistantDialog.next()'''
     def back(self):
         '''void KAssistantDialog.back()'''
     def isAppropriate(self, page):
         '''bool KAssistantDialog.isAppropriate(KPageWidgetItem page)'''
         return bool()
     def setAppropriate(self, page, appropriate):
         '''void KAssistantDialog.setAppropriate(KPageWidgetItem page, bool appropriate)'''
     def isValid(self, page):
         '''bool KAssistantDialog.isValid(KPageWidgetItem page)'''
         return bool()
     def setValid(self, page, enable):
         '''void KAssistantDialog.setValid(KPageWidgetItem page, bool enable)'''
 
 
 class KBreadcrumbSelectionModel(QItemSelectionModel):
     """"""
     # Enum KBreadcrumbSelectionModel.BreadcrumbTarget
     MakeBreadcrumbSelectionInOther = 0
     MakeBreadcrumbSelectionInSelf = 0
 
     def __init__(self, selectionModel, parent = None):
         '''void KBreadcrumbSelectionModel.__init__(QItemSelectionModel selectionModel, QObject parent = None)'''
     def __init__(self, selectionModel, target, parent = None):
         '''void KBreadcrumbSelectionModel.__init__(QItemSelectionModel selectionModel, KBreadcrumbSelectionModel.BreadcrumbTarget target, QObject parent = None)'''
     def select(self, index, command):
         '''void KBreadcrumbSelectionModel.select(QModelIndex index, QItemSelectionModel.SelectionFlags command)'''
     def select(self, selection, command):
         '''void KBreadcrumbSelectionModel.select(QItemSelection selection, QItemSelectionModel.SelectionFlags command)'''
     def setBreadcrumbLength(self, breadcrumbLength):
         '''void KBreadcrumbSelectionModel.setBreadcrumbLength(int breadcrumbLength)'''
     def breadcrumbLength(self):
         '''int KBreadcrumbSelectionModel.breadcrumbLength()'''
         return int()
     def setActualSelectionIncluded(self, isActualSelectionIncluded):
         '''void KBreadcrumbSelectionModel.setActualSelectionIncluded(bool isActualSelectionIncluded)'''
     def isActualSelectionIncluded(self):
         '''bool KBreadcrumbSelectionModel.isActualSelectionIncluded()'''
         return bool()
 
 
 class KBugReport(KDialog):
     """"""
     def __init__(self, parent = None, modal = True, aboutData = None):
         '''void KBugReport.__init__(QWidget parent = None, bool modal = True, KAboutData aboutData = None)'''
     def closeEvent(self, e):
         '''void KBugReport.closeEvent(QCloseEvent e)'''
     def sendBugReport(self):
         '''bool KBugReport.sendBugReport()'''
         return bool()
     def text(self):
         '''QString KBugReport.text()'''
         return QString()
     def accept(self):
         '''void KBugReport.accept()'''
     def setMessageBody(self, messageBody):
         '''void KBugReport.setMessageBody(QString messageBody)'''
     def messageBody(self):
         '''QString KBugReport.messageBody()'''
         return QString()
 
 
 class KButtonGroup(QGroupBox):
     """"""
     def __init__(self, parent = None):
         '''void KButtonGroup.__init__(QWidget parent = None)'''
     def childEvent(self, event):
         '''void KButtonGroup.childEvent(QChildEvent event)'''
     changed = pyqtSignal() # void changed(int) - signal
     released = pyqtSignal() # void released(int) - signal
     pressed = pyqtSignal() # void pressed(int) - signal
     clicked = pyqtSignal() # void clicked(int) - signal
     def setSelected(self, id):
         '''void KButtonGroup.setSelected(int id)'''
     def id(self, button):
         '''int KButtonGroup.id(QAbstractButton button)'''
         return int()
     def selected(self):
         '''int KButtonGroup.selected()'''
         return int()
 
 
 class KCapacityBar(QWidget):
     """"""
     # Enum KCapacityBar.DrawTextMode
     DrawTextInline = 0
     DrawTextOutline = 0
 
     def __init__(self, drawTextMode = None, parent = None):
         '''void KCapacityBar.__init__(KCapacityBar.DrawTextMode drawTextMode = KCapacityBar.DrawTextOutline, QWidget parent = None)'''
     def drawTextMode(self):
         '''KCapacityBar.DrawTextMode KCapacityBar.drawTextMode()'''
         return KCapacityBar.DrawTextMode()
     def setDrawTextMode(self, mode):
         '''void KCapacityBar.setDrawTextMode(KCapacityBar.DrawTextMode mode)'''
     def changeEvent(self, event):
         '''void KCapacityBar.changeEvent(QEvent event)'''
     def paintEvent(self, event):
         '''void KCapacityBar.paintEvent(QPaintEvent event)'''
     def minimumSizeHint(self):
         '''QSize KCapacityBar.minimumSizeHint()'''
         return QSize()
     def drawCapacityBar(self, p, rect):
         '''void KCapacityBar.drawCapacityBar(QPainter p, QRect rect)'''
     def horizontalTextAlignment(self):
         '''Qt.Alignment KCapacityBar.horizontalTextAlignment()'''
         return Qt.Alignment()
     def setHorizontalTextAlignment(self, textAlignment):
         '''void KCapacityBar.setHorizontalTextAlignment(Qt.Alignment textAlignment)'''
     def barHeight(self):
         '''int KCapacityBar.barHeight()'''
         return int()
     def setBarHeight(self, barHeight):
         '''void KCapacityBar.setBarHeight(int barHeight)'''
     def continuous(self):
         '''bool KCapacityBar.continuous()'''
         return bool()
     def setContinuous(self, continuous):
         '''void KCapacityBar.setContinuous(bool continuous)'''
     def fillFullBlocks(self):
         '''bool KCapacityBar.fillFullBlocks()'''
         return bool()
     def setFillFullBlocks(self, fillFullBlocks):
         '''void KCapacityBar.setFillFullBlocks(bool fillFullBlocks)'''
     def text(self):
         '''QString KCapacityBar.text()'''
         return QString()
     def setText(self, text):
         '''void KCapacityBar.setText(QString text)'''
     def value(self):
         '''int KCapacityBar.value()'''
         return int()
     def setValue(self, value):
         '''void KCapacityBar.setValue(int value)'''
 
 
 class KCategorizedSortFilterProxyModel(QSortFilterProxyModel):
     """"""
     # Enum KCategorizedSortFilterProxyModel.AdditionalRoles
     CategoryDisplayRole = 0
     CategorySortRole = 0
 
     def __init__(self, parent = None):
         '''void KCategorizedSortFilterProxyModel.__init__(QObject parent = None)'''
     def compareCategories(self, left, right):
         '''int KCategorizedSortFilterProxyModel.compareCategories(QModelIndex left, QModelIndex right)'''
         return int()
     def subSortLessThan(self, left, right):
         '''bool KCategorizedSortFilterProxyModel.subSortLessThan(QModelIndex left, QModelIndex right)'''
         return bool()
     def lessThan(self, left, right):
         '''bool KCategorizedSortFilterProxyModel.lessThan(QModelIndex left, QModelIndex right)'''
         return bool()
     def naturalCompare(self, a, b):
         '''static int KCategorizedSortFilterProxyModel.naturalCompare(QString a, QString b)'''
         return int()
     def sortCategoriesByNaturalComparison(self):
         '''bool KCategorizedSortFilterProxyModel.sortCategoriesByNaturalComparison()'''
         return bool()
     def setSortCategoriesByNaturalComparison(self, sortCategoriesByNaturalComparison):
         '''void KCategorizedSortFilterProxyModel.setSortCategoriesByNaturalComparison(bool sortCategoriesByNaturalComparison)'''
     def sortOrder(self):
         '''Qt.SortOrder KCategorizedSortFilterProxyModel.sortOrder()'''
         return Qt.SortOrder()
     def sortColumn(self):
         '''int KCategorizedSortFilterProxyModel.sortColumn()'''
         return int()
     def setCategorizedModel(self, categorizedModel):
         '''void KCategorizedSortFilterProxyModel.setCategorizedModel(bool categorizedModel)'''
     def isCategorizedModel(self):
         '''bool KCategorizedSortFilterProxyModel.isCategorizedModel()'''
         return bool()
     def sort(self, column, order = None):
         '''void KCategorizedSortFilterProxyModel.sort(int column, Qt.SortOrder order = Qt.AscendingOrder)'''
 
 
 class KCategorizedView(QListView):
     """"""
     def __init__(self, parent = None):
         '''void KCategorizedView.__init__(QWidget parent = None)'''
     def block(self, category):
         '''list-of-QModelIndex KCategorizedView.block(QString category)'''
         return [QModelIndex()]
     def block(self, representative):
         '''list-of-QModelIndex KCategorizedView.block(QModelIndex representative)'''
         return [QModelIndex()]
     def rowsAboutToBeRemoved(self, parent, start, end):
         '''void KCategorizedView.rowsAboutToBeRemoved(QModelIndex parent, int start, int end)'''
     def dragEnterEvent(self, event):
         '''void KCategorizedView.dragEnterEvent(QDragEnterEvent event)'''
     def setCollapsibleBlocks(self, enable):
         '''void KCategorizedView.setCollapsibleBlocks(bool enable)'''
     def collapsibleBlocks(self):
         '''bool KCategorizedView.collapsibleBlocks()'''
         return bool()
     def setAlternatingBlockColors(self, enable):
         '''void KCategorizedView.setAlternatingBlockColors(bool enable)'''
     def alternatingBlockColors(self):
         '''bool KCategorizedView.alternatingBlockColors()'''
         return bool()
     def setCategorySpacing(self, categorySpacing):
         '''void KCategorizedView.setCategorySpacing(int categorySpacing)'''
     def categorySpacing(self):
         '''int KCategorizedView.categorySpacing()'''
         return int()
     def setGridSizeOwn(self, size):
         '''void KCategorizedView.setGridSizeOwn(QSize size)'''
     def dataChanged(self, topLeft, bottomRight):
         '''void KCategorizedView.dataChanged(QModelIndex topLeft, QModelIndex bottomRight)'''
     def currentChanged(self, current, previous):
         '''void KCategorizedView.currentChanged(QModelIndex current, QModelIndex previous)'''
     def slotLayoutChanged(self):
         '''void KCategorizedView.slotLayoutChanged()'''
     def updateGeometries(self):
         '''void KCategorizedView.updateGeometries()'''
     def rowsRemoved(self, parent, start, end):
         '''void KCategorizedView.rowsRemoved(QModelIndex parent, int start, int end)'''
     def rowsInsertedArtifficial(self, parent, start, end):
         '''void KCategorizedView.rowsInsertedArtifficial(QModelIndex parent, int start, int end)'''
     def rowsInserted(self, parent, start, end):
         '''void KCategorizedView.rowsInserted(QModelIndex parent, int start, int end)'''
     def moveCursor(self, cursorAction, modifiers):
         '''QModelIndex KCategorizedView.moveCursor(QAbstractItemView.CursorAction cursorAction, Qt.KeyboardModifiers modifiers)'''
         return QModelIndex()
     def dropEvent(self, event):
         '''void KCategorizedView.dropEvent(QDropEvent event)'''
     def dragLeaveEvent(self, event):
         '''void KCategorizedView.dragLeaveEvent(QDragLeaveEvent event)'''
     def dragMoveEvent(self, event):
         '''void KCategorizedView.dragMoveEvent(QDragMoveEvent event)'''
     def startDrag(self, supportedActions):
         '''void KCategorizedView.startDrag(Qt.DropActions supportedActions)'''
     def leaveEvent(self, event):
         '''void KCategorizedView.leaveEvent(QEvent event)'''
     def mouseReleaseEvent(self, event):
         '''void KCategorizedView.mouseReleaseEvent(QMouseEvent event)'''
     def mousePressEvent(self, event):
         '''void KCategorizedView.mousePressEvent(QMouseEvent event)'''
     def mouseMoveEvent(self, event):
         '''void KCategorizedView.mouseMoveEvent(QMouseEvent event)'''
     def setSelection(self, rect, flags):
         '''void KCategorizedView.setSelection(QRect rect, QItemSelectionModel.SelectionFlags flags)'''
     def resizeEvent(self, event):
         '''void KCategorizedView.resizeEvent(QResizeEvent event)'''
     def paintEvent(self, event):
         '''void KCategorizedView.paintEvent(QPaintEvent event)'''
     def reset(self):
         '''void KCategorizedView.reset()'''
     def indexAt(self, point):
         '''QModelIndex KCategorizedView.indexAt(QPoint point)'''
         return QModelIndex()
     def setCategoryDrawer(self, categoryDrawer):
         '''void KCategorizedView.setCategoryDrawer(KCategoryDrawer categoryDrawer)'''
     def categoryDrawer(self):
         '''KCategoryDrawer KCategorizedView.categoryDrawer()'''
         return KCategoryDrawer()
     def visualRect(self, index):
         '''QRect KCategorizedView.visualRect(QModelIndex index)'''
         return QRect()
     def setGridSize(self, size):
         '''void KCategorizedView.setGridSize(QSize size)'''
     def setModel(self, model):
         '''void KCategorizedView.setModel(QAbstractItemModel model)'''
 
 
 class KCategoryDrawer():
     """"""
     def __init__(self):
         '''void KCategoryDrawer.__init__()'''
     def __init__(self):
         '''KCategoryDrawer KCategoryDrawer.__init__()'''
         return KCategoryDrawer()
     def setRightMargin(self, rightMargin):
         '''void KCategoryDrawer.setRightMargin(int rightMargin)'''
     def rightMargin(self):
         '''int KCategoryDrawer.rightMargin()'''
         return int()
     def setLeftMargin(self, leftMargin):
         '''void KCategoryDrawer.setLeftMargin(int leftMargin)'''
     def leftMargin(self):
         '''int KCategoryDrawer.leftMargin()'''
         return int()
     def categoryHeight(self, index, option):
         '''int KCategoryDrawer.categoryHeight(QModelIndex index, QStyleOption option)'''
         return int()
     def drawCategory(self, index, sortRole, option, painter):
         '''void KCategoryDrawer.drawCategory(QModelIndex index, int sortRole, QStyleOption option, QPainter painter)'''
 
 
 class KCategoryDrawerV2(QObject, KCategoryDrawer):
     """"""
     def __init__(self, parent = None):
         '''void KCategoryDrawerV2.__init__(QObject parent = None)'''
     actionRequested = pyqtSignal() # void actionRequested(int,const QModelIndexamp;) - signal
     collapseOrExpandClicked = pyqtSignal() # void collapseOrExpandClicked(const QModelIndexamp;) - signal
     def mouseButtonDoubleClicked(self, index, event):
         '''void KCategoryDrawerV2.mouseButtonDoubleClicked(QModelIndex index, QMouseEvent event)'''
     def mouseButtonMoved(self, index, event):
         '''void KCategoryDrawerV2.mouseButtonMoved(QModelIndex index, QMouseEvent event)'''
     def mouseButtonReleased(self, index, event):
         '''void KCategoryDrawerV2.mouseButtonReleased(QModelIndex index, QMouseEvent event)'''
     def mouseButtonPressed(self, index, event):
         '''void KCategoryDrawerV2.mouseButtonPressed(QModelIndex index, QMouseEvent event)'''
 
 
 class KCategoryDrawerV3(KCategoryDrawerV2):
     """"""
     def __init__(self, view):
         '''void KCategoryDrawerV3.__init__(KCategorizedView view)'''
     def mouseLeft(self, index, blockRect):
         '''void KCategoryDrawerV3.mouseLeft(QModelIndex index, QRect blockRect)'''
     def mouseButtonDoubleClicked(self, index, blockRect, event):
         '''void KCategoryDrawerV3.mouseButtonDoubleClicked(QModelIndex index, QRect blockRect, QMouseEvent event)'''
     def mouseMoved(self, index, blockRect, event):
         '''void KCategoryDrawerV3.mouseMoved(QModelIndex index, QRect blockRect, QMouseEvent event)'''
     def mouseButtonReleased(self, index, blockRect, event):
         '''void KCategoryDrawerV3.mouseButtonReleased(QModelIndex index, QRect blockRect, QMouseEvent event)'''
     def mouseButtonPressed(self, index, blockRect, event):
         '''void KCategoryDrawerV3.mouseButtonPressed(QModelIndex index, QRect blockRect, QMouseEvent event)'''
     def view(self):
         '''KCategorizedView KCategoryDrawerV3.view()'''
         return KCategorizedView()
 
 
 class KCharSelect(QWidget):
     """"""
     # Enum KCharSelect.Control
     SearchLine = 0
     FontCombo = 0
     FontSize = 0
     BlockCombos = 0
     CharacterTable = 0
     DetailBrowser = 0
     HistoryButtons = 0
     AllGuiElements = 0
 
     def __init__(self, parent, controls = None):
         '''void KCharSelect.__init__(QWidget parent, KCharSelect.Controls controls = KCharSelect.AllGuiElements)'''
     def __init__(self, parent, collection, controls = None):
         '''void KCharSelect.__init__(QWidget parent, KActionCollection collection, KCharSelect.Controls controls = KCharSelect.AllGuiElements)'''
     charSelected = pyqtSignal() # void charSelected(const QCharamp;) - signal
     displayedCharsChanged = pyqtSignal() # void displayedCharsChanged() - signal
     currentCharChanged = pyqtSignal() # void currentCharChanged(const QCharamp;) - signal
     currentFontChanged = pyqtSignal() # void currentFontChanged(const QFontamp;) - signal
     def setCurrentFont(self, font):
         '''void KCharSelect.setCurrentFont(QFont font)'''
     def setCurrentChar(self, c):
         '''void KCharSelect.setCurrentChar(QChar c)'''
     def displayedChars(self):
         '''list-of-QChar KCharSelect.displayedChars()'''
         return [QChar()]
     def currentFont(self):
         '''QFont KCharSelect.currentFont()'''
         return QFont()
     def currentChar(self):
         '''QChar KCharSelect.currentChar()'''
         return QChar()
     def sizeHint(self):
         '''QSize KCharSelect.sizeHint()'''
         return QSize()
     class Controls():
         """"""
         def __init__(self):
             '''KCharSelect.Controls KCharSelect.Controls.__init__()'''
             return KCharSelect.Controls()
         def __init__(self):
             '''int KCharSelect.Controls.__init__()'''
             return int()
         def __init__(self):
             '''void KCharSelect.Controls.__init__()'''
         def __bool__(self):
             '''int KCharSelect.Controls.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KCharSelect.Controls.__ne__(KCharSelect.Controls f)'''
             return bool()
         def __eq__(self, f):
             '''bool KCharSelect.Controls.__eq__(KCharSelect.Controls f)'''
             return bool()
         def __invert__(self):
             '''KCharSelect.Controls KCharSelect.Controls.__invert__()'''
             return KCharSelect.Controls()
         def __and__(self, mask):
             '''KCharSelect.Controls KCharSelect.Controls.__and__(int mask)'''
             return KCharSelect.Controls()
         def __xor__(self, f):
             '''KCharSelect.Controls KCharSelect.Controls.__xor__(KCharSelect.Controls f)'''
             return KCharSelect.Controls()
         def __xor__(self, f):
             '''KCharSelect.Controls KCharSelect.Controls.__xor__(int f)'''
             return KCharSelect.Controls()
         def __or__(self, f):
             '''KCharSelect.Controls KCharSelect.Controls.__or__(KCharSelect.Controls f)'''
             return KCharSelect.Controls()
         def __or__(self, f):
             '''KCharSelect.Controls KCharSelect.Controls.__or__(int f)'''
             return KCharSelect.Controls()
         def __int__(self):
             '''int KCharSelect.Controls.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KCharSelect.Controls KCharSelect.Controls.__ixor__(KCharSelect.Controls f)'''
             return KCharSelect.Controls()
         def __ior__(self, f):
             '''KCharSelect.Controls KCharSelect.Controls.__ior__(KCharSelect.Controls f)'''
             return KCharSelect.Controls()
         def __iand__(self, mask):
             '''KCharSelect.Controls KCharSelect.Controls.__iand__(int mask)'''
             return KCharSelect.Controls()
 
 
 class KIdentityProxyModel(QAbstractProxyModel):
     """"""
     def __init__(self, parent = None):
         '''void KIdentityProxyModel.__init__(QObject parent = None)'''
     def supportedDropActions(self):
         '''Qt.DropActions KIdentityProxyModel.supportedDropActions()'''
         return Qt.DropActions()
     def mimeData(self, indexes):
         '''QMimeData KIdentityProxyModel.mimeData(list-of-QModelIndex indexes)'''
         return QMimeData()
     def mimeTypes(self):
         '''QStringList KIdentityProxyModel.mimeTypes()'''
         return QStringList()
     def fetchMore(self, parent):
         '''void KIdentityProxyModel.fetchMore(QModelIndex parent)'''
     def canFetchMore(self, parent):
         '''bool KIdentityProxyModel.canFetchMore(QModelIndex parent)'''
         return bool()
     def resetInternalData(self):
         '''void KIdentityProxyModel.resetInternalData()'''
     def removeRows(self, row, count, parent = QModelIndex()):
         '''bool KIdentityProxyModel.removeRows(int row, int count, QModelIndex parent = QModelIndex())'''
         return bool()
     def removeColumns(self, column, count, parent = QModelIndex()):
         '''bool KIdentityProxyModel.removeColumns(int column, int count, QModelIndex parent = QModelIndex())'''
         return bool()
     def insertRows(self, row, count, parent = QModelIndex()):
         '''bool KIdentityProxyModel.insertRows(int row, int count, QModelIndex parent = QModelIndex())'''
         return bool()
     def insertColumns(self, column, count, parent = QModelIndex()):
         '''bool KIdentityProxyModel.insertColumns(int column, int count, QModelIndex parent = QModelIndex())'''
         return bool()
     def setSourceModel(self, sourceModel):
         '''void KIdentityProxyModel.setSourceModel(QAbstractItemModel sourceModel)'''
     def match(self, start, role, value, hits = 1, flags = None):
         '''list-of-QModelIndex KIdentityProxyModel.match(QModelIndex start, int role, QVariant value, int hits = 1, Qt.MatchFlags flags = Qt.MatchFlags(Qt.MatchStartsWith|Qt.MatchWrap))'''
         return [QModelIndex()]
     def mapSelectionToSource(self, selection):
         '''QItemSelection KIdentityProxyModel.mapSelectionToSource(QItemSelection selection)'''
         return QItemSelection()
     def mapSelectionFromSource(self, selection):
         '''QItemSelection KIdentityProxyModel.mapSelectionFromSource(QItemSelection selection)'''
         return QItemSelection()
     def dropMimeData(self, data, action, row, column, parent):
         '''bool KIdentityProxyModel.dropMimeData(QMimeData data, Qt.DropAction action, int row, int column, QModelIndex parent)'''
         return bool()
     def rowCount(self, parent = QModelIndex()):
         '''int KIdentityProxyModel.rowCount(QModelIndex parent = QModelIndex())'''
         return int()
     def parent(self, child):
         '''QModelIndex KIdentityProxyModel.parent(QModelIndex child)'''
         return QModelIndex()
     def mapToSource(self, proxyIndex):
         '''QModelIndex KIdentityProxyModel.mapToSource(QModelIndex proxyIndex)'''
         return QModelIndex()
     def mapFromSource(self, sourceIndex):
         '''QModelIndex KIdentityProxyModel.mapFromSource(QModelIndex sourceIndex)'''
         return QModelIndex()
     def index(self, row, column, parent = QModelIndex()):
         '''QModelIndex KIdentityProxyModel.index(int row, int column, QModelIndex parent = QModelIndex())'''
         return QModelIndex()
     def columnCount(self, parent = QModelIndex()):
         '''int KIdentityProxyModel.columnCount(QModelIndex parent = QModelIndex())'''
         return int()
 
 
 class KCheckableProxyModel(KIdentityProxyModel):
     """"""
     def __init__(self, parent = None):
         '''void KCheckableProxyModel.__init__(QObject parent = None)'''
     def select(self, selection, command):
         '''bool KCheckableProxyModel.select(QItemSelection selection, QItemSelectionModel.SelectionFlags command)'''
         return bool()
     def setSourceModel(self, sourceModel):
         '''void KCheckableProxyModel.setSourceModel(QAbstractItemModel sourceModel)'''
     def setData(self, index, value, role = None):
         '''bool KCheckableProxyModel.setData(QModelIndex index, QVariant value, int role = Qt.EditRole)'''
         return bool()
     def data(self, index, role = None):
         '''QVariant KCheckableProxyModel.data(QModelIndex index, int role = Qt.DisplayRole)'''
         return QVariant()
     def flags(self, index):
         '''Qt.ItemFlags KCheckableProxyModel.flags(QModelIndex index)'''
         return Qt.ItemFlags()
     def selectionModel(self):
         '''QItemSelectionModel KCheckableProxyModel.selectionModel()'''
         return QItemSelectionModel()
     def setSelectionModel(self, itemSelectionModel):
         '''void KCheckableProxyModel.setSelectionModel(QItemSelectionModel itemSelectionModel)'''
 
 
 class KCModule(QWidget):
     """"""
     # Enum KCModule.Button
     NoAdditionalButton = 0
     Help = 0
     Default = 0
     Apply = 0
     Export = 0
 
     def __init__(self, componentData, parent = None, args = QVariantList()):
         '''void KCModule.__init__(KComponentData componentData, QWidget parent = None, list-of-QVariant args = QVariantList())'''
     def setExportText(self):
         '''QString KCModule.setExportText()'''
         return QString()
     def exportText(self):
         '''QString KCModule.exportText()'''
         return QString()
     def authStatusChanged(self):
         '''int KCModule.authStatusChanged()'''
         return int()
     rootOnlyMessageChanged = pyqtSignal() # void rootOnlyMessageChanged(bool,QString) - signal
     def authAction(self):
         '''KAuth.Action KCModule.authAction()'''
         return KAuth.Action()
     def needsAuthorization(self):
         '''bool KCModule.needsAuthorization()'''
         return bool()
     def setNeedsAuthorization(self, needsAuth):
         '''void KCModule.setNeedsAuthorization(bool needsAuth)'''
     def unmanagedWidgetChangeState(self):
         '''bool KCModule.unmanagedWidgetChangeState()'''
         return bool()
     def managedWidgetChangeState(self):
         '''bool KCModule.managedWidgetChangeState()'''
         return bool()
     def setUseRootOnlyMessage(self, on):
         '''void KCModule.setUseRootOnlyMessage(bool on)'''
     def setRootOnlyMessage(self, message):
         '''void KCModule.setRootOnlyMessage(QString message)'''
     def setButtons(self, btn):
         '''void KCModule.setButtons(KCModule.Buttons btn)'''
     def widgetChanged(self):
         '''void KCModule.widgetChanged()'''
     quickHelpChanged = pyqtSignal() # void quickHelpChanged() - signal
     changed = pyqtSignal() # void changed(bool) - signal
     def changed(self):
         '''void KCModule.changed()'''
     def showEvent(self, ev):
         '''void KCModule.showEvent(QShowEvent ev)'''
     def setQuickHelp(self, help):
         '''void KCModule.setQuickHelp(QString help)'''
     def addConfig(self, config, widget):
         '''KConfigDialogManager KCModule.addConfig(KConfigSkeleton config, QWidget widget)'''
         return KConfigDialogManager()
     def addConfig(self, config, widget):
         '''KConfigDialogManager KCModule.addConfig(KCoreConfigSkeleton config, QWidget widget)'''
         return KConfigDialogManager()
     def defaults(self):
         '''void KCModule.defaults()'''
     def save(self):
         '''void KCModule.save()'''
     def load(self):
         '''void KCModule.load()'''
     def configs(self):
         '''list-of-KConfigDialogManager KCModule.configs()'''
         return [KConfigDialogManager()]
     def componentData(self):
         '''KComponentData KCModule.componentData()'''
         return KComponentData()
     def useRootOnlyMessage(self):
         '''bool KCModule.useRootOnlyMessage()'''
         return bool()
     def rootOnlyMessage(self):
         '''QString KCModule.rootOnlyMessage()'''
         return QString()
     def buttons(self):
         '''KCModule.Buttons KCModule.buttons()'''
         return KCModule.Buttons()
     def setAboutData(self, about):
         '''void KCModule.setAboutData(KAboutData about)'''
     def aboutData(self):
         '''KAboutData KCModule.aboutData()'''
         return KAboutData()
     def quickHelp(self):
         '''QString KCModule.quickHelp()'''
         return QString()
     class Buttons():
         """"""
         def __init__(self):
             '''KCModule.Buttons KCModule.Buttons.__init__()'''
             return KCModule.Buttons()
         def __init__(self):
             '''int KCModule.Buttons.__init__()'''
             return int()
         def __init__(self):
             '''void KCModule.Buttons.__init__()'''
         def __bool__(self):
             '''int KCModule.Buttons.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KCModule.Buttons.__ne__(KCModule.Buttons f)'''
             return bool()
         def __eq__(self, f):
             '''bool KCModule.Buttons.__eq__(KCModule.Buttons f)'''
             return bool()
         def __invert__(self):
             '''KCModule.Buttons KCModule.Buttons.__invert__()'''
             return KCModule.Buttons()
         def __and__(self, mask):
             '''KCModule.Buttons KCModule.Buttons.__and__(int mask)'''
             return KCModule.Buttons()
         def __xor__(self, f):
             '''KCModule.Buttons KCModule.Buttons.__xor__(KCModule.Buttons f)'''
             return KCModule.Buttons()
         def __xor__(self, f):
             '''KCModule.Buttons KCModule.Buttons.__xor__(int f)'''
             return KCModule.Buttons()
         def __or__(self, f):
             '''KCModule.Buttons KCModule.Buttons.__or__(KCModule.Buttons f)'''
             return KCModule.Buttons()
         def __or__(self, f):
             '''KCModule.Buttons KCModule.Buttons.__or__(int f)'''
             return KCModule.Buttons()
         def __int__(self):
             '''int KCModule.Buttons.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KCModule.Buttons KCModule.Buttons.__ixor__(KCModule.Buttons f)'''
             return KCModule.Buttons()
         def __ior__(self, f):
             '''KCModule.Buttons KCModule.Buttons.__ior__(KCModule.Buttons f)'''
             return KCModule.Buttons()
         def __iand__(self, mask):
             '''KCModule.Buttons KCModule.Buttons.__iand__(int mask)'''
             return KCModule.Buttons()
 
 
 class KSelectAction(KAction):
     """"""
     # Enum KSelectAction.ToolBarMode
     MenuMode = 0
     ComboBoxMode = 0
 
     def __init__(self, parent):
         '''void KSelectAction.__init__(QObject parent)'''
     def __init__(self, text, parent):
         '''void KSelectAction.__init__(QString text, QObject parent)'''
     def __init__(self, icon, text, parent):
         '''void KSelectAction.__init__(KIcon icon, QString text, QObject parent)'''
     def event(self, event):
         '''bool KSelectAction.event(QEvent event)'''
         return bool()
     def eventFilter(self, watched, event):
         '''bool KSelectAction.eventFilter(QObject watched, QEvent event)'''
         return bool()
     def deleteWidget(self, widget):
         '''void KSelectAction.deleteWidget(QWidget widget)'''
     def createWidget(self, parent):
         '''QWidget KSelectAction.createWidget(QWidget parent)'''
         return QWidget()
     def slotToggled(self):
         '''bool KSelectAction.slotToggled()'''
         return bool()
     def actionTriggered(self, action):
         '''void KSelectAction.actionTriggered(QAction action)'''
     triggered = pyqtSignal() # void triggered(QAction *) - signal
     triggered = pyqtSignal() # void triggered(int) - signal
     triggered = pyqtSignal() # void triggered(const QStringamp;) - signal
     def changeItem(self, index, text):
         '''void KSelectAction.changeItem(int index, QString text)'''
     def menuAccelsEnabled(self):
         '''bool KSelectAction.menuAccelsEnabled()'''
         return bool()
     def setMenuAccelsEnabled(self, b):
         '''void KSelectAction.setMenuAccelsEnabled(bool b)'''
     def removeAllActions(self):
         '''void KSelectAction.removeAllActions()'''
     def clear(self):
         '''void KSelectAction.clear()'''
     def setMaxComboViewCount(self, n):
         '''void KSelectAction.setMaxComboViewCount(int n)'''
     def setComboWidth(self, width):
         '''void KSelectAction.setComboWidth(int width)'''
     def comboWidth(self):
         '''int KSelectAction.comboWidth()'''
         return int()
     def setEditable(self):
         '''bool KSelectAction.setEditable()'''
         return bool()
     def isEditable(self):
         '''bool KSelectAction.isEditable()'''
         return bool()
     def items(self):
         '''QStringList KSelectAction.items()'''
         return QStringList()
     def setItems(self, lst):
         '''void KSelectAction.setItems(QStringList lst)'''
     def removeAction(self, action):
         '''QAction KSelectAction.removeAction(QAction action)'''
         return QAction()
     def addAction(self, action):
         '''void KSelectAction.addAction(QAction action)'''
     def addAction(self, text):
         '''KAction KSelectAction.addAction(QString text)'''
         return KAction()
     def addAction(self, icon, text):
         '''KAction KSelectAction.addAction(KIcon icon, QString text)'''
         return KAction()
     def setCurrentItem(self, index):
         '''bool KSelectAction.setCurrentItem(int index)'''
         return bool()
     def setCurrentAction(self, action):
         '''bool KSelectAction.setCurrentAction(QAction action)'''
         return bool()
     def setCurrentAction(self, text, cs = None):
         '''bool KSelectAction.setCurrentAction(QString text, Qt.CaseSensitivity cs = Qt.CaseSensitive)'''
         return bool()
     def action(self, index):
         '''QAction KSelectAction.action(int index)'''
         return QAction()
     def action(self, text, cs = None):
         '''QAction KSelectAction.action(QString text, Qt.CaseSensitivity cs = Qt.CaseSensitive)'''
         return QAction()
     def actions(self):
         '''list-of-QAction KSelectAction.actions()'''
         return [QAction()]
     def currentText(self):
         '''QString KSelectAction.currentText()'''
         return QString()
     def currentItem(self):
         '''int KSelectAction.currentItem()'''
         return int()
     def currentAction(self):
         '''QAction KSelectAction.currentAction()'''
         return QAction()
     def selectableActionGroup(self):
         '''QActionGroup KSelectAction.selectableActionGroup()'''
         return QActionGroup()
     def setToolButtonPopupMode(self, mode):
         '''void KSelectAction.setToolButtonPopupMode(QToolButton.ToolButtonPopupMode mode)'''
     def toolButtonPopupMode(self):
         '''QToolButton.ToolButtonPopupMode KSelectAction.toolButtonPopupMode()'''
         return QToolButton.ToolButtonPopupMode()
     def setToolBarMode(self, mode):
         '''void KSelectAction.setToolBarMode(KSelectAction.ToolBarMode mode)'''
     def toolBarMode(self):
         '''KSelectAction.ToolBarMode KSelectAction.toolBarMode()'''
         return KSelectAction.ToolBarMode()
 
 
 class KCodecAction(KSelectAction):
     """"""
     def __init__(self, parent, showAutoOptions = False):
         '''void KCodecAction.__init__(QObject parent, bool showAutoOptions = False)'''
     def __init__(self, text, parent, showAutoOptions = False):
         '''void KCodecAction.__init__(QString text, QObject parent, bool showAutoOptions = False)'''
     def __init__(self, icon, text, parent, showAutoOptions = False):
         '''void KCodecAction.__init__(KIcon icon, QString text, QObject parent, bool showAutoOptions = False)'''
     def actionTriggered(self):
         '''QAction KCodecAction.actionTriggered()'''
         return QAction()
     defaultItemTriggered = pyqtSignal() # void defaultItemTriggered() - signal
     triggered = pyqtSignal() # void triggered(QTextCodec *) - signal
     triggered = pyqtSignal() # void triggered(KEncodingDetector::AutoDetectScript) - signal
     def setCurrentAutoDetectScript(self):
         '''KEncodingDetector.AutoDetectScript KCodecAction.setCurrentAutoDetectScript()'''
         return KEncodingDetector.AutoDetectScript()
     def currentAutoDetectScript(self):
         '''KEncodingDetector.AutoDetectScript KCodecAction.currentAutoDetectScript()'''
         return KEncodingDetector.AutoDetectScript()
     def currentCodecMib(self):
         '''int KCodecAction.currentCodecMib()'''
         return int()
     def currentCodecName(self):
         '''QString KCodecAction.currentCodecName()'''
         return QString()
     def setCurrentCodec(self, codec):
         '''bool KCodecAction.setCurrentCodec(QTextCodec codec)'''
         return bool()
     def setCurrentCodec(self, codecName):
         '''bool KCodecAction.setCurrentCodec(QString codecName)'''
         return bool()
     def setCurrentCodec(self, mib):
         '''bool KCodecAction.setCurrentCodec(int mib)'''
         return bool()
     def currentCodec(self):
         '''QTextCodec KCodecAction.currentCodec()'''
         return QTextCodec()
     def codecForMib(self, mib):
         '''QTextCodec KCodecAction.codecForMib(int mib)'''
         return QTextCodec()
     def mibForName(self, codecName, ok):
         '''int KCodecAction.mibForName(QString codecName, bool ok)'''
         return int()
 
 
 class KColorButton(QPushButton):
     """"""
     def __init__(self, parent = None):
         '''void KColorButton.__init__(QWidget parent = None)'''
     def __init__(self, c, parent = None):
         '''void KColorButton.__init__(QColor c, QWidget parent = None)'''
     def __init__(self, c, defaultColor, parent = None):
         '''void KColorButton.__init__(QColor c, QColor defaultColor, QWidget parent = None)'''
     def isAlphaChannelEnabled(self):
         '''bool KColorButton.isAlphaChannelEnabled()'''
         return bool()
     def setAlphaChannelEnabled(self, alpha):
         '''void KColorButton.setAlphaChannelEnabled(bool alpha)'''
     def keyPressEvent(self, e):
         '''void KColorButton.keyPressEvent(QKeyEvent e)'''
     def mouseMoveEvent(self, e):
         '''void KColorButton.mouseMoveEvent(QMouseEvent e)'''
     def mousePressEvent(self, e):
         '''void KColorButton.mousePressEvent(QMouseEvent e)'''
     def dropEvent(self):
         '''QDropEvent KColorButton.dropEvent()'''
         return QDropEvent()
     def dragEnterEvent(self):
         '''QDragEnterEvent KColorButton.dragEnterEvent()'''
         return QDragEnterEvent()
     def paintEvent(self, pe):
         '''void KColorButton.paintEvent(QPaintEvent pe)'''
     changed = pyqtSignal() # void changed(const QColoramp;) - signal
     def minimumSizeHint(self):
         '''QSize KColorButton.minimumSizeHint()'''
         return QSize()
     def sizeHint(self):
         '''QSize KColorButton.sizeHint()'''
         return QSize()
     def setDefaultColor(self, c):
         '''void KColorButton.setDefaultColor(QColor c)'''
     def defaultColor(self):
         '''QColor KColorButton.defaultColor()'''
         return QColor()
     def setColor(self, c):
         '''void KColorButton.setColor(QColor c)'''
     def color(self):
         '''QColor KColorButton.color()'''
         return QColor()
 
 
 class KColorCollection():
     """"""
     # Enum KColorCollection.Editable
     Yes = 0
     No = 0
     Ask = 0
 
     def __init__(self, name = QString()):
         '''void KColorCollection.__init__(QString name = QString())'''
     def __init__(self):
         '''KColorCollection KColorCollection.__init__()'''
         return KColorCollection()
     def changeColor(self, index, newColor, newColorName = QString()):
         '''int KColorCollection.changeColor(int index, QColor newColor, QString newColorName = QString())'''
         return int()
     def changeColor(self, oldColor, newColor, newColorName = QString()):
         '''int KColorCollection.changeColor(QColor oldColor, QColor newColor, QString newColorName = QString())'''
         return int()
     def addColor(self, newColor, newColorName = QString()):
         '''int KColorCollection.addColor(QColor newColor, QString newColorName = QString())'''
         return int()
     def findColor(self, color):
         '''int KColorCollection.findColor(QColor color)'''
         return int()
     def color(self, index):
         '''QColor KColorCollection.color(int index)'''
         return QColor()
     def count(self):
         '''int KColorCollection.count()'''
         return int()
     def setEditable(self, editable):
         '''void KColorCollection.setEditable(KColorCollection.Editable editable)'''
     def editable(self):
         '''KColorCollection.Editable KColorCollection.editable()'''
         return KColorCollection.Editable()
     def setName(self, name):
         '''void KColorCollection.setName(QString name)'''
     def name(self):
         '''QString KColorCollection.name()'''
         return QString()
     def name(self, index):
         '''QString KColorCollection.name(int index)'''
         return QString()
     def name(self, color):
         '''QString KColorCollection.name(QColor color)'''
         return QString()
     def setDescription(self, desc):
         '''void KColorCollection.setDescription(QString desc)'''
     def description(self):
         '''QString KColorCollection.description()'''
         return QString()
     def save(self):
         '''bool KColorCollection.save()'''
         return bool()
     def installedCollections(self):
         '''static QStringList KColorCollection.installedCollections()'''
         return QStringList()
 
 
 class KColorCombo(QComboBox):
     """"""
     def __init__(self, parent = None):
         '''void KColorCombo.__init__(QWidget parent = None)'''
     def paintEvent(self, event):
         '''void KColorCombo.paintEvent(QPaintEvent event)'''
     highlighted = pyqtSignal() # void highlighted(const QColoramp;) - signal
     activated = pyqtSignal() # void activated(const QColoramp;) - signal
     def showEmptyList(self):
         '''void KColorCombo.showEmptyList()'''
     def colors(self):
         '''list-of-QColor KColorCombo.colors()'''
         return [QColor()]
     def setColors(self, colors):
         '''void KColorCombo.setColors(list-of-QColor colors)'''
     def isCustomColor(self):
         '''bool KColorCombo.isCustomColor()'''
         return bool()
     def color(self):
         '''QColor KColorCombo.color()'''
         return QColor()
     def setColor(self, col):
         '''void KColorCombo.setColor(QColor col)'''
 
 
 class KColorCells(QTableWidget):
     """"""
     def __init__(self, parent, rows, columns):
         '''void KColorCells.__init__(QWidget parent, int rows, int columns)'''
     def positionToCell(self, pos, ignoreBorders = False):
         '''int KColorCells.positionToCell(QPoint pos, bool ignoreBorders = False)'''
         return int()
     def mouseDoubleClickEvent(self):
         '''QMouseEvent KColorCells.mouseDoubleClickEvent()'''
         return QMouseEvent()
     def dropEvent(self):
         '''QDropEvent KColorCells.dropEvent()'''
         return QDropEvent()
     def dragMoveEvent(self):
         '''QDragMoveEvent KColorCells.dragMoveEvent()'''
         return QDragMoveEvent()
     def dragEnterEvent(self):
         '''QDragEnterEvent KColorCells.dragEnterEvent()'''
         return QDragEnterEvent()
     def mouseMoveEvent(self):
         '''QMouseEvent KColorCells.mouseMoveEvent()'''
         return QMouseEvent()
     def mousePressEvent(self):
         '''QMouseEvent KColorCells.mousePressEvent()'''
         return QMouseEvent()
     def mouseReleaseEvent(self):
         '''QMouseEvent KColorCells.mouseReleaseEvent()'''
         return QMouseEvent()
     def resizeEvent(self, event):
         '''void KColorCells.resizeEvent(QResizeEvent event)'''
     def sizeHintForRow(self, column):
         '''int KColorCells.sizeHintForRow(int column)'''
         return int()
     def sizeHintForColumn(self, column):
         '''int KColorCells.sizeHintForColumn(int column)'''
         return int()
     colorDoubleClicked = pyqtSignal() # void colorDoubleClicked(int,const QColoramp;) - signal
     colorSelected = pyqtSignal() # void colorSelected(int,const QColoramp;) - signal
     def selectedIndex(self):
         '''int KColorCells.selectedIndex()'''
         return int()
     def setSelected(self, index):
         '''void KColorCells.setSelected(int index)'''
     def setAcceptDrags(self, acceptDrags):
         '''void KColorCells.setAcceptDrags(bool acceptDrags)'''
     def setShading(self, shade):
         '''void KColorCells.setShading(bool shade)'''
     def count(self):
         '''int KColorCells.count()'''
         return int()
     def color(self, index):
         '''QColor KColorCells.color(int index)'''
         return QColor()
     def setColor(self, index, col):
         '''void KColorCells.setColor(int index, QColor col)'''
 
 
 class KColorPatch(QFrame):
     """"""
     def __init__(self, parent):
         '''void KColorPatch.__init__(QWidget parent)'''
     def color(self):
         '''QColor KColorPatch.color()'''
         return QColor()
     def dropEvent(self):
         '''QDropEvent KColorPatch.dropEvent()'''
         return QDropEvent()
     def dragEnterEvent(self):
         '''QDragEnterEvent KColorPatch.dragEnterEvent()'''
         return QDragEnterEvent()
     def mouseMoveEvent(self):
         '''QMouseEvent KColorPatch.mouseMoveEvent()'''
         return QMouseEvent()
     def paintEvent(self, pe):
         '''void KColorPatch.paintEvent(QPaintEvent pe)'''
     colorChanged = pyqtSignal() # void colorChanged(const QColoramp;) - signal
     def setColor(self, col):
         '''void KColorPatch.setColor(QColor col)'''
 
 
 class KColorDialog(KDialog):
     """"""
     def __init__(self, parent = None, modal = False):
         '''void KColorDialog.__init__(QWidget parent = None, bool modal = False)'''
     def isAlphaChannelEnabled(self):
         '''bool KColorDialog.isAlphaChannelEnabled()'''
         return bool()
     def setAlphaChannelEnabled(self, alpha):
         '''void KColorDialog.setAlphaChannelEnabled(bool alpha)'''
     def eventFilter(self, obj, ev):
         '''bool KColorDialog.eventFilter(QObject obj, QEvent ev)'''
         return bool()
     def keyPressEvent(self):
         '''QKeyEvent KColorDialog.keyPressEvent()'''
         return QKeyEvent()
     def mouseReleaseEvent(self):
         '''QMouseEvent KColorDialog.mouseReleaseEvent()'''
         return QMouseEvent()
     def mouseMoveEvent(self):
         '''QMouseEvent KColorDialog.mouseMoveEvent()'''
         return QMouseEvent()
     colorSelected = pyqtSignal() # void colorSelected(const QColoramp;) - signal
     def setColor(self, col):
         '''void KColorDialog.setColor(QColor col)'''
     def defaultColor(self):
         '''QColor KColorDialog.defaultColor()'''
         return QColor()
     def setDefaultColor(self, defaultCol):
         '''void KColorDialog.setDefaultColor(QColor defaultCol)'''
     def grabColor(self, p):
         '''static QColor KColorDialog.grabColor(QPoint p)'''
         return QColor()
     def getColor(self, theColor, parent = None):
         '''static int KColorDialog.getColor(QColor theColor, QWidget parent = None)'''
         return int()
     def getColor(self, theColor, defaultColor, parent = None):
         '''static int KColorDialog.getColor(QColor theColor, QColor defaultColor, QWidget parent = None)'''
         return int()
     def color(self):
         '''QColor KColorDialog.color()'''
         return QColor()
 
 
 class KColorMimeData():
     """"""
     def createDrag(self, color, dragsource):
         '''static QDrag KColorMimeData.createDrag(QColor color, QWidget dragsource)'''
         return QDrag()
     def fromMimeData(self, mimeData):
         '''static QColor KColorMimeData.fromMimeData(QMimeData mimeData)'''
         return QColor()
     def canDecode(self, mimeData):
         '''static bool KColorMimeData.canDecode(QMimeData mimeData)'''
         return bool()
     def populateMimeData(self, mimeData, color):
         '''static void KColorMimeData.populateMimeData(QMimeData mimeData, QColor color)'''
 
 
 class KColorScheme():
     """"""
     # Enum KColorScheme.ShadeRole
     LightShade = 0
     MidlightShade = 0
     MidShade = 0
     DarkShade = 0
     ShadowShade = 0
 
     # Enum KColorScheme.DecorationRole
     FocusColor = 0
     HoverColor = 0
 
     # Enum KColorScheme.ForegroundRole
     NormalText = 0
     InactiveText = 0
     ActiveText = 0
     LinkText = 0
     VisitedText = 0
     NegativeText = 0
     NeutralText = 0
     PositiveText = 0
 
     # Enum KColorScheme.BackgroundRole
     NormalBackground = 0
     AlternateBackground = 0
     ActiveBackground = 0
     LinkBackground = 0
     VisitedBackground = 0
     NegativeBackground = 0
     NeutralBackground = 0
     PositiveBackground = 0
 
     # Enum KColorScheme.ColorSet
     View = 0
     Window = 0
     Button = 0
     Selection = 0
     Tooltip = 0
 
     def __init__(self):
         '''KColorScheme KColorScheme.__init__()'''
         return KColorScheme()
     def __init__(self):
         '''KSharedConfigPtr KColorScheme.__init__()'''
         return KSharedConfigPtr()
     def adjustForeground(self, newRole = None, color = None, set = None):
         '''static KSharedConfigPtr KColorScheme.adjustForeground(KColorScheme.ForegroundRole newRole = KColorScheme.NormalText, QPalette.ColorRole color = QPalette.Text, KColorScheme.ColorSet set = KColorScheme.View)'''
         return KSharedConfigPtr()
     def adjustBackground(self, newRole = None, color = None, set = None):
         '''static KSharedConfigPtr KColorScheme.adjustBackground(KColorScheme.BackgroundRole newRole = KColorScheme.NormalBackground, QPalette.ColorRole color = QPalette.Base, KColorScheme.ColorSet set = KColorScheme.View)'''
         return KSharedConfigPtr()
     def shade(self):
         '''KColorScheme.ShadeRole KColorScheme.shade()'''
         return KColorScheme.ShadeRole()
     def shade(self):
         '''static KColorScheme.ShadeRole KColorScheme.shade()'''
         return KColorScheme.ShadeRole()
     def shade(self, contrast, chromaAdjust = 0):
         '''static KColorScheme.ShadeRole KColorScheme.shade(float contrast, float chromaAdjust = 0)'''
         return KColorScheme.ShadeRole()
     def decoration(self):
         '''KColorScheme.DecorationRole KColorScheme.decoration()'''
         return KColorScheme.DecorationRole()
     def foreground(self):
         '''KColorScheme.ForegroundRole KColorScheme.foreground()'''
         return KColorScheme.ForegroundRole()
     def background(self):
         '''KColorScheme.BackgroundRole KColorScheme.background()'''
         return KColorScheme.BackgroundRole()
 
 
 class KStatefulBrush():
     """"""
     def __init__(self):
         '''void KStatefulBrush.__init__()'''
     def __init__(self):
         '''KSharedConfigPtr KStatefulBrush.__init__()'''
         return KSharedConfigPtr()
     def __init__(self):
         '''KSharedConfigPtr KStatefulBrush.__init__()'''
         return KSharedConfigPtr()
     def __init__(self):
         '''KSharedConfigPtr KStatefulBrush.__init__()'''
         return KSharedConfigPtr()
     def __init__(self):
         '''KSharedConfigPtr KStatefulBrush.__init__()'''
         return KSharedConfigPtr()
     def __init__(self, background):
         '''KSharedConfigPtr KStatefulBrush.__init__(QBrush background)'''
         return KSharedConfigPtr()
     def __init__(self):
         '''KStatefulBrush KStatefulBrush.__init__()'''
         return KStatefulBrush()
     def brush(self):
         '''QPalette.ColorGroup KStatefulBrush.brush()'''
         return QPalette.ColorGroup()
     def brush(self):
         '''QPalette KStatefulBrush.brush()'''
         return QPalette()
     def brush(self):
         '''QWidget KStatefulBrush.brush()'''
         return QWidget()
 
 
 class KColorUtils():
     """"""
     def overlayColors(self, base, paint, comp = None):
         '''static QColor KColorUtils.overlayColors(QColor base, QColor paint, QPainter.CompositionMode comp = QPainter.CompositionMode_SourceOver)'''
         return QColor()
     def mix(self, c1, c2, bias = None):
         '''static QColor KColorUtils.mix(QColor c1, QColor c2, float bias = 0.5)'''
         return QColor()
     def tint(self, base, color, amount = None):
         '''static QColor KColorUtils.tint(QColor base, QColor color, float amount = 0.3)'''
         return QColor()
     def shade(self, lumaAmount, chromaAmount = 0):
         '''static QColor KColorUtils.shade(float lumaAmount, float chromaAmount = 0)'''
         return QColor()
     def darken(self, amount = None, chromaGain = 1):
         '''static QColor KColorUtils.darken(float amount = 0.5, float chromaGain = 1)'''
         return QColor()
     def lighten(self, amount = None, chromaInverseGain = 1):
         '''static QColor KColorUtils.lighten(float amount = 0.5, float chromaInverseGain = 1)'''
         return QColor()
     def contrastRatio(self):
         '''static QColor KColorUtils.contrastRatio()'''
         return QColor()
     def luma(self):
         '''static QColor KColorUtils.luma()'''
         return QColor()
 
 
 class KSelector(QAbstractSlider):
     """"""
     def __init__(self, parent = None):
         '''void KSelector.__init__(QWidget parent = None)'''
     def __init__(self, o, parent = None):
         '''void KSelector.__init__(Qt.Orientation o, QWidget parent = None)'''
     def wheelEvent(self):
         '''QWheelEvent KSelector.wheelEvent()'''
         return QWheelEvent()
     def mouseReleaseEvent(self, e):
         '''void KSelector.mouseReleaseEvent(QMouseEvent e)'''
     def mouseMoveEvent(self, e):
         '''void KSelector.mouseMoveEvent(QMouseEvent e)'''
     def mousePressEvent(self, e):
         '''void KSelector.mousePressEvent(QMouseEvent e)'''
     def paintEvent(self):
         '''QPaintEvent KSelector.paintEvent()'''
         return QPaintEvent()
     def drawArrow(self, painter, pos):
         '''void KSelector.drawArrow(QPainter painter, QPoint pos)'''
     def drawContents(self):
         '''QPainter KSelector.drawContents()'''
         return QPainter()
     def arrowDirection(self):
         '''Qt.ArrowType KSelector.arrowDirection()'''
         return Qt.ArrowType()
     def setArrowDirection(self, direction):
         '''void KSelector.setArrowDirection(Qt.ArrowType direction)'''
     def indent(self):
         '''bool KSelector.indent()'''
         return bool()
     def setIndent(self, i):
         '''void KSelector.setIndent(bool i)'''
     def contentsRect(self):
         '''QRect KSelector.contentsRect()'''
         return QRect()
 
 
 class KColorValueSelector(KSelector):
     """"""
     def __init__(self, parent = None):
         '''void KColorValueSelector.__init__(QWidget parent = None)'''
     def __init__(self, o, parent = None):
         '''void KColorValueSelector.__init__(Qt.Orientation o, QWidget parent = None)'''
     def drawContents(self, painter):
         '''void KColorValueSelector.drawContents(QPainter painter)'''
     def resizeEvent(self):
         '''QResizeEvent KColorValueSelector.resizeEvent()'''
         return QResizeEvent()
     def drawPalette(self, pixmap):
         '''void KColorValueSelector.drawPalette(QPixmap pixmap)'''
     def chooserMode(self):
         '''KColorChooserMode KColorValueSelector.chooserMode()'''
         return KColorChooserMode()
     def setChooserMode(self, chooserMode):
         '''void KColorValueSelector.setChooserMode(KColorChooserMode chooserMode)'''
     def setColorValue(self, colorValue):
         '''void KColorValueSelector.setColorValue(int colorValue)'''
     def colorValue(self):
         '''int KColorValueSelector.colorValue()'''
         return int()
     def setSaturation(self, saturation):
         '''void KColorValueSelector.setSaturation(int saturation)'''
     def saturation(self):
         '''int KColorValueSelector.saturation()'''
         return int()
     def setHue(self, hue):
         '''void KColorValueSelector.setHue(int hue)'''
     def hue(self):
         '''int KColorValueSelector.hue()'''
         return int()
     def updateContents(self):
         '''void KColorValueSelector.updateContents()'''
 
 
 class KCompletionBase():
     """"""
     # Enum KCompletionBase.KeyBindingType
     TextCompletion = 0
     PrevCompletionMatch = 0
     NextCompletionMatch = 0
     SubstringCompletion = 0
 
     def __init__(self):
         '''void KCompletionBase.__init__()'''
     def delegate(self):
         '''KCompletionBase KCompletionBase.delegate()'''
         return KCompletionBase()
     def setDelegate(self, delegate):
         '''void KCompletionBase.setDelegate(KCompletionBase delegate)'''
     def getKeyBindings(self):
         '''unknown-type KCompletionBase.getKeyBindings()'''
         return unknown-type()
     def compObj(self):
         '''KCompletion KCompletionBase.compObj()'''
         return KCompletion()
     def setCompletedItems(self, items, autoSuggest = True):
         '''abstract void KCompletionBase.setCompletedItems(QStringList items, bool autoSuggest = True)'''
     def setCompletedText(self, text):
         '''abstract void KCompletionBase.setCompletedText(QString text)'''
     def useGlobalKeyBindings(self):
         '''void KCompletionBase.useGlobalKeyBindings()'''
     def getKeyBinding(self, item):
         '''KShortcut KCompletionBase.getKeyBinding(KCompletionBase.KeyBindingType item)'''
         return KShortcut()
     def setKeyBinding(self, item, key):
         '''bool KCompletionBase.setKeyBinding(KCompletionBase.KeyBindingType item, KShortcut key)'''
         return bool()
     def completionMode(self):
         '''KGlobalSettings.Completion KCompletionBase.completionMode()'''
         return KGlobalSettings.Completion()
     def setCompletionMode(self, mode):
         '''void KCompletionBase.setCompletionMode(KGlobalSettings.Completion mode)'''
     def emitSignals(self):
         '''bool KCompletionBase.emitSignals()'''
         return bool()
     def handleSignals(self):
         '''bool KCompletionBase.handleSignals()'''
         return bool()
     def setEnableSignals(self, enable):
         '''void KCompletionBase.setEnableSignals(bool enable)'''
     def setAutoDeleteCompletionObject(self, autoDelete):
         '''void KCompletionBase.setAutoDeleteCompletionObject(bool autoDelete)'''
     def isCompletionObjectAutoDeleted(self):
         '''bool KCompletionBase.isCompletionObjectAutoDeleted()'''
         return bool()
     def setHandleSignals(self, handle):
         '''void KCompletionBase.setHandleSignals(bool handle)'''
     def setCompletionObject(self, compObj, hsig = True):
         '''void KCompletionBase.setCompletionObject(KCompletion compObj, bool hsig = True)'''
     def completionObject(self, hsig = True):
         '''KCompletion KCompletionBase.completionObject(bool hsig = True)'''
         return KCompletion()
 
 
 class KComboBox(QComboBox, KCompletionBase):
     """"""
     def __init__(self, parent = None):
         '''void KComboBox.__init__(QWidget parent = None)'''
     def __init__(self, rw, parent = None):
         '''void KComboBox.__init__(bool rw, QWidget parent = None)'''
     def minimumSizeHint(self):
         '''QSize KComboBox.minimumSizeHint()'''
         return QSize()
     def wheelEvent(self, ev):
         '''void KComboBox.wheelEvent(QWheelEvent ev)'''
     def create(self, initializeWindow = True, destroyOldWindow = True):
         '''int KComboBox.create(bool initializeWindow = True, bool destroyOldWindow = True)'''
         return int()
     def makeCompletion(self):
         '''QString KComboBox.makeCompletion()'''
         return QString()
     def setCurrentItem(self, item, insert = False, index = None):
         '''void KComboBox.setCurrentItem(QString item, bool insert = False, int index = -1)'''
     def setCompletedItems(self, items, autosubject = True):
         '''void KComboBox.setCompletedItems(QStringList items, bool autosubject = True)'''
     def setCompletedText(self):
         '''QString KComboBox.setCompletedText()'''
         return QString()
     def setCompletedText(self):
         '''bool KComboBox.setCompletedText()'''
         return bool()
     def rotateText(self, type):
         '''void KComboBox.rotateText(KCompletionBase.KeyBindingType type)'''
     aboutToShowContextMenu = pyqtSignal() # void aboutToShowContextMenu(QMenu *) - signal
     completionModeChanged = pyqtSignal() # void completionModeChanged(KGlobalSettings::Completion) - signal
     textRotation = pyqtSignal() # void textRotation(KCompletionBase::KeyBindingType) - signal
     substringCompletion = pyqtSignal() # void substringCompletion(const QStringamp;) - signal
     completion = pyqtSignal() # void completion(const QStringamp;) - signal
     returnPressed = pyqtSignal() # void returnPressed() - signal
     returnPressed = pyqtSignal() # void returnPressed(const QStringamp;) - signal
     def setEditable(self, editable):
         '''void KComboBox.setEditable(bool editable)'''
     def setLineEdit(self):
         '''QLineEdit KComboBox.setLineEdit()'''
         return QLineEdit()
     def completionBox(self, create = True):
         '''KCompletionBox KComboBox.completionBox(bool create = True)'''
         return KCompletionBox()
     def eventFilter(self):
         '''QEvent KComboBox.eventFilter()'''
         return QEvent()
     def trapReturnKey(self):
         '''bool KComboBox.trapReturnKey()'''
         return bool()
     def setTrapReturnKey(self, trap):
         '''void KComboBox.setTrapReturnKey(bool trap)'''
     def contains(self, text):
         '''bool KComboBox.contains(QString text)'''
         return bool()
     def urlDropsEnabled(self):
         '''bool KComboBox.urlDropsEnabled()'''
         return bool()
     def setUrlDropsEnabled(self, enable):
         '''void KComboBox.setUrlDropsEnabled(bool enable)'''
     def setContextMenuEnabled(self, showMenu):
         '''void KComboBox.setContextMenuEnabled(bool showMenu)'''
     def autoCompletion(self):
         '''bool KComboBox.autoCompletion()'''
         return bool()
     def setAutoCompletion(self, autocomplete):
         '''void KComboBox.setAutoCompletion(bool autocomplete)'''
     def cursorPosition(self):
         '''int KComboBox.cursorPosition()'''
         return int()
     def changeUrl(self, index, url):
         '''void KComboBox.changeUrl(int index, KUrl url)'''
     def changeUrl(self, index, icon, url):
         '''void KComboBox.changeUrl(int index, QIcon icon, KUrl url)'''
     def insertUrl(self, index, url):
         '''void KComboBox.insertUrl(int index, KUrl url)'''
     def insertUrl(self, index, icon, url):
         '''void KComboBox.insertUrl(int index, QIcon icon, KUrl url)'''
     def addUrl(self, url):
         '''void KComboBox.addUrl(KUrl url)'''
     def addUrl(self, icon, url):
         '''void KComboBox.addUrl(QIcon icon, KUrl url)'''
     def setEditUrl(self, url):
         '''void KComboBox.setEditUrl(KUrl url)'''
     def changeURL(self, url, index):
         '''void KComboBox.changeURL(KUrl url, int index)'''
     def changeURL(self, pixmap, url, index):
         '''void KComboBox.changeURL(QPixmap pixmap, KUrl url, int index)'''
     def insertURL(self, url, index = None):
         '''void KComboBox.insertURL(KUrl url, int index = -1)'''
     def insertURL(self, pixmap, url, index = None):
         '''void KComboBox.insertURL(QPixmap pixmap, KUrl url, int index = -1)'''
 
 
 class KCompletion(QObject):
     """"""
     # Enum KCompletion.CompOrder
     Sorted = 0
     Insertion = 0
     Weighted = 0
 
     def __init__(self):
         '''void KCompletion.__init__()'''
     def postProcessMatches(self, pMatches):
         '''void KCompletion.postProcessMatches(QStringList pMatches)'''
     def postProcessMatch(self, pMatch):
         '''void KCompletion.postProcessMatch(QString pMatch)'''
     multipleMatches = pyqtSignal() # void multipleMatches() - signal
     matches = pyqtSignal() # void matches(const QStringListamp;) - signal
     match = pyqtSignal() # void match(const QStringamp;) - signal
     def clear(self):
         '''void KCompletion.clear()'''
     def removeItem(self, item):
         '''void KCompletion.removeItem(QString item)'''
     def addItem(self, item):
         '''void KCompletion.addItem(QString item)'''
     def addItem(self, item, weight):
         '''void KCompletion.addItem(QString item, int weight)'''
     def setItems(self, list):
         '''void KCompletion.setItems(QStringList list)'''
     def insertItems(self, items):
         '''void KCompletion.insertItems(QStringList items)'''
     def slotNextMatch(self):
         '''void KCompletion.slotNextMatch()'''
     def slotPreviousMatch(self):
         '''void KCompletion.slotPreviousMatch()'''
     def slotMakeCompletion(self, string):
         '''void KCompletion.slotMakeCompletion(QString string)'''
     def hasMultipleMatches(self):
         '''bool KCompletion.hasMultipleMatches()'''
         return bool()
     def soundsEnabled(self):
         '''bool KCompletion.soundsEnabled()'''
         return bool()
     def setSoundsEnabled(self, enable):
         '''void KCompletion.setSoundsEnabled(bool enable)'''
     def allMatches(self):
         '''QStringList KCompletion.allMatches()'''
         return QStringList()
     def allMatches(self, string):
         '''QStringList KCompletion.allMatches(QString string)'''
         return QStringList()
     def ignoreCase(self):
         '''bool KCompletion.ignoreCase()'''
         return bool()
     def setIgnoreCase(self, ignoreCase):
         '''void KCompletion.setIgnoreCase(bool ignoreCase)'''
     def order(self):
         '''KCompletion.CompOrder KCompletion.order()'''
         return KCompletion.CompOrder()
     def setOrder(self, order):
         '''void KCompletion.setOrder(KCompletion.CompOrder order)'''
     def completionMode(self):
         '''KGlobalSettings.Completion KCompletion.completionMode()'''
         return KGlobalSettings.Completion()
     def setCompletionMode(self, mode):
         '''void KCompletion.setCompletionMode(KGlobalSettings.Completion mode)'''
     def isEmpty(self):
         '''bool KCompletion.isEmpty()'''
         return bool()
     def items(self):
         '''QStringList KCompletion.items()'''
         return QStringList()
     def lastMatch(self):
         '''QString KCompletion.lastMatch()'''
         return QString()
     def nextMatch(self):
         '''QString KCompletion.nextMatch()'''
         return QString()
     def previousMatch(self):
         '''QString KCompletion.previousMatch()'''
         return QString()
     def substringCompletion(self, string):
         '''QStringList KCompletion.substringCompletion(QString string)'''
         return QStringList()
     def makeCompletion(self, string):
         '''QString KCompletion.makeCompletion(QString string)'''
         return QString()
 
 
 class KListWidget(QListWidget):
     """"""
     def __init__(self, parent = None):
         '''void KListWidget.__init__(QWidget parent = None)'''
     def mouseDoubleClickEvent(self, e):
         '''void KListWidget.mouseDoubleClickEvent(QMouseEvent e)'''
     def mousePressEvent(self, e):
         '''void KListWidget.mousePressEvent(QMouseEvent e)'''
     def leaveEvent(self, e):
         '''void KListWidget.leaveEvent(QEvent e)'''
     def focusOutEvent(self, e):
         '''void KListWidget.focusOutEvent(QFocusEvent e)'''
     def keyPressEvent(self, e):
         '''void KListWidget.keyPressEvent(QKeyEvent e)'''
     doubleClicked = pyqtSignal() # void doubleClicked(QListWidgetItem *,const QPointamp;) - signal
     executed = pyqtSignal() # void executed(QListWidgetItem *) - signal
     executed = pyqtSignal() # void executed(QListWidgetItem *,const QPointamp;) - signal
 
 
 class KCompletionBox(KListWidget):
     """"""
     def __init__(self, parent = None):
         '''void KCompletionBox.__init__(QWidget parent = None)'''
     def slotActivated(self):
         '''QListWidgetItem KCompletionBox.slotActivated()'''
         return QListWidgetItem()
     def globalPositionHint(self):
         '''QPoint KCompletionBox.globalPositionHint()'''
         return QPoint()
     def eventFilter(self):
         '''QEvent KCompletionBox.eventFilter()'''
         return QEvent()
     def sizeAndPosition(self):
         '''void KCompletionBox.sizeAndPosition()'''
     def calculateGeometry(self):
         '''QRect KCompletionBox.calculateGeometry()'''
         return QRect()
     userCancelled = pyqtSignal() # void userCancelled(const QStringamp;) - signal
     activated = pyqtSignal() # void activated(const QStringamp;) - signal
     def setVisible(self, visible):
         '''void KCompletionBox.setVisible(bool visible)'''
     def end(self):
         '''void KCompletionBox.end()'''
     def home(self):
         '''void KCompletionBox.home()'''
     def pageUp(self):
         '''void KCompletionBox.pageUp()'''
     def pageDown(self):
         '''void KCompletionBox.pageDown()'''
     def up(self):
         '''void KCompletionBox.up()'''
     def down(self):
         '''void KCompletionBox.down()'''
     def setActivateOnSelect(self, state):
         '''void KCompletionBox.setActivateOnSelect(bool state)'''
     def cancelledText(self):
         '''QString KCompletionBox.cancelledText()'''
         return QString()
     def setCancelledText(self, txt):
         '''void KCompletionBox.setCancelledText(QString txt)'''
     def isTabHandling(self):
         '''bool KCompletionBox.isTabHandling()'''
         return bool()
     def setTabHandling(self, enable):
         '''void KCompletionBox.setTabHandling(bool enable)'''
     def popup(self):
         '''void KCompletionBox.popup()'''
     def setItems(self, items):
         '''void KCompletionBox.setItems(QStringList items)'''
     def insertItems(self, items, index = None):
         '''void KCompletionBox.insertItems(QStringList items, int index = -1)'''
     def items(self):
         '''QStringList KCompletionBox.items()'''
         return QStringList()
     def activateOnSelect(self):
         '''bool KCompletionBox.activateOnSelect()'''
         return bool()
     def sizeHint(self):
         '''QSize KCompletionBox.sizeHint()'''
         return QSize()
 
 
 class KConfigDialog(KPageDialog):
     """"""
     def __init__(self, parent, name, config):
         '''void KConfigDialog.__init__(QWidget parent, QString name, KConfigSkeleton config)'''
     def __init__(self, parent, name, config):
         '''void KConfigDialog.__init__(QWidget parent, QString name, KCoreConfigSkeleton config)'''
     def showEvent(self, e):
         '''void KConfigDialog.showEvent(QShowEvent e)'''
     def isDefault(self):
         '''bool KConfigDialog.isDefault()'''
         return bool()
     def hasChanged(self):
         '''bool KConfigDialog.hasChanged()'''
         return bool()
     def settingsChangedSlot(self):
         '''void KConfigDialog.settingsChangedSlot()'''
     def updateButtons(self):
         '''void KConfigDialog.updateButtons()'''
     def updateWidgetsDefault(self):
         '''void KConfigDialog.updateWidgetsDefault()'''
     def updateWidgets(self):
         '''void KConfigDialog.updateWidgets()'''
     def updateSettings(self):
         '''void KConfigDialog.updateSettings()'''
     def showDialog(self, name):
         '''static bool KConfigDialog.showDialog(QString name)'''
         return bool()
     def exists(self, name):
         '''static KConfigDialog KConfigDialog.exists(QString name)'''
         return KConfigDialog()
     def addPage(self, page, itemName, pixmapName = QString(), header = QString(), manage = True):
         '''KPageWidgetItem KConfigDialog.addPage(QWidget page, QString itemName, QString pixmapName = QString(), QString header = QString(), bool manage = True)'''
         return KPageWidgetItem()
     def addPage(self, page, config, itemName, pixmapName = QString(), header = QString()):
         '''KPageWidgetItem KConfigDialog.addPage(QWidget page, KConfigSkeleton config, QString itemName, QString pixmapName = QString(), QString header = QString())'''
         return KPageWidgetItem()
     settingsChanged = pyqtSignal() # void settingsChanged(const QStringamp;) - signal
     widgetModified = pyqtSignal() # void widgetModified() - signal
 
 
 class KConfigDialogManager(QObject):
     """"""
     def __init__(self, parent, conf):
         '''void KConfigDialogManager.__init__(QWidget parent, KConfigSkeleton conf)'''
     def __init__(self, parent, conf):
         '''void KConfigDialogManager.__init__(QWidget parent, KCoreConfigSkeleton conf)'''
     def initMaps(self):
         '''static void KConfigDialogManager.initMaps()'''
     def setupWidget(self, widget, item):
         '''void KConfigDialogManager.setupWidget(QWidget widget, KConfigSkeletonItem item)'''
     def property(self, w):
         '''QVariant KConfigDialogManager.property(QWidget w)'''
         return QVariant()
     def setProperty(self, w, v):
         '''void KConfigDialogManager.setProperty(QWidget w, QVariant v)'''
     def getCustomProperty(self, widget):
         '''QByteArray KConfigDialogManager.getCustomProperty(QWidget widget)'''
         return QByteArray()
     def getUserProperty(self, widget):
         '''QByteArray KConfigDialogManager.getUserProperty(QWidget widget)'''
         return QByteArray()
     def parseChildren(self, widget, trackChanges):
         '''bool KConfigDialogManager.parseChildren(QWidget widget, bool trackChanges)'''
         return bool()
     def init(self, trackChanges):
         '''void KConfigDialogManager.init(bool trackChanges)'''
     def updateWidgetsDefault(self):
         '''void KConfigDialogManager.updateWidgetsDefault()'''
     def updateWidgets(self):
         '''void KConfigDialogManager.updateWidgets()'''
     def updateSettings(self):
         '''void KConfigDialogManager.updateSettings()'''
     def changedMap(self):
         '''static dict-of-QString-QByteArray KConfigDialogManager.changedMap()'''
         return dict-of-QString-QByteArray()
     def propertyMap(self):
         '''static dict-of-QString-QByteArray KConfigDialogManager.propertyMap()'''
         return dict-of-QString-QByteArray()
     def isDefault(self):
         '''bool KConfigDialogManager.isDefault()'''
         return bool()
     def hasChanged(self):
         '''bool KConfigDialogManager.hasChanged()'''
         return bool()
     def addWidget(self, widget):
         '''void KConfigDialogManager.addWidget(QWidget widget)'''
     widgetModified = pyqtSignal() # void widgetModified() - signal
     settingsChanged = pyqtSignal() # void settingsChanged() - signal
     settingsChanged = pyqtSignal() # void settingsChanged(QWidget *) - signal
 
 
 class KConfigSkeleton(KCoreConfigSkeleton):
     """"""
     def __init__(self, configname = QString(), parent = None):
         '''void KConfigSkeleton.__init__(QString configname = QString(), QObject parent = None)'''
     def __init__(self, config, parent = None):
         '''void KConfigSkeleton.__init__(unknown-type config, QObject parent = None)'''
     def addItemFont(self, name, reference, defaultValue = QFont(), key = QString()):
         '''KConfigSkeleton.ItemFont KConfigSkeleton.addItemFont(QString name, QFont reference, QFont defaultValue = QFont(), QString key = QString())'''
         return KConfigSkeleton.ItemFont()
     def addItemColor(self, name, reference, defaultValue = None, key = QString()):
         '''KConfigSkeleton.ItemColor KConfigSkeleton.addItemColor(QString name, QColor reference, QColor defaultValue = QColor(128,128,128), QString key = QString())'''
         return KConfigSkeleton.ItemColor()
     class ItemColor(KConfigSkeletonItem):
         """"""
         def __init__(self, _group, _key, reference, defaultValue = None):
             '''void KConfigSkeleton.ItemColor.__init__(QString _group, QString _key, QColor reference, QColor defaultValue = QColor(128,128,128))'''
         def property(self):
             '''QVariant KConfigSkeleton.ItemColor.property()'''
             return QVariant()
         def isEqual(self, p):
             '''bool KConfigSkeleton.ItemColor.isEqual(QVariant p)'''
             return bool()
         def setProperty(self, p):
             '''void KConfigSkeleton.ItemColor.setProperty(QVariant p)'''
         def readConfig(self, config):
             '''void KConfigSkeleton.ItemColor.readConfig(KConfig config)'''
     class ItemFont(KConfigSkeletonItem):
         """"""
         def __init__(self, _group, _key, reference, defaultValue = QFont()):
             '''void KConfigSkeleton.ItemFont.__init__(QString _group, QString _key, QFont reference, QFont defaultValue = QFont())'''
         def property(self):
             '''QVariant KConfigSkeleton.ItemFont.property()'''
             return QVariant()
         def isEqual(self, p):
             '''bool KConfigSkeleton.ItemFont.isEqual(QVariant p)'''
             return bool()
         def setProperty(self, p):
             '''void KConfigSkeleton.ItemFont.setProperty(QVariant p)'''
         def readConfig(self, config):
             '''void KConfigSkeleton.ItemFont.readConfig(KConfig config)'''
 
 
 class KCrash():
     """"""
     # Enum KCrash.CrashFlag
     KeepFDs = 0
     SaferDialog = 0
     AlwaysDirectly = 0
     AutoRestart = 0
 
     def isDrKonqiEnabled(self):
         '''static bool KCrash.isDrKonqiEnabled()'''
         return bool()
     def setDrKonqiEnabled(self, enabled):
         '''static void KCrash.setDrKonqiEnabled(bool enabled)'''
     def setApplicationName(self, name):
         '''static void KCrash.setApplicationName(QString name)'''
     def setApplicationPath(self, path):
         '''static void KCrash.setApplicationPath(QString path)'''
     def setFlags(self, flags):
         '''static void KCrash.setFlags(KCrash.CrashFlags flags)'''
     def defaultCrashHandler(self, signal):
         '''static void KCrash.defaultCrashHandler(int signal)'''
     class CrashFlags():
         """"""
         def __init__(self):
             '''KCrash.CrashFlags KCrash.CrashFlags.__init__()'''
             return KCrash.CrashFlags()
         def __init__(self):
             '''int KCrash.CrashFlags.__init__()'''
             return int()
         def __init__(self):
             '''void KCrash.CrashFlags.__init__()'''
         def __bool__(self):
             '''int KCrash.CrashFlags.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KCrash.CrashFlags.__ne__(KCrash.CrashFlags f)'''
             return bool()
         def __eq__(self, f):
             '''bool KCrash.CrashFlags.__eq__(KCrash.CrashFlags f)'''
             return bool()
         def __invert__(self):
             '''KCrash.CrashFlags KCrash.CrashFlags.__invert__()'''
             return KCrash.CrashFlags()
         def __and__(self, mask):
             '''KCrash.CrashFlags KCrash.CrashFlags.__and__(int mask)'''
             return KCrash.CrashFlags()
         def __xor__(self, f):
             '''KCrash.CrashFlags KCrash.CrashFlags.__xor__(KCrash.CrashFlags f)'''
             return KCrash.CrashFlags()
         def __xor__(self, f):
             '''KCrash.CrashFlags KCrash.CrashFlags.__xor__(int f)'''
             return KCrash.CrashFlags()
         def __or__(self, f):
             '''KCrash.CrashFlags KCrash.CrashFlags.__or__(KCrash.CrashFlags f)'''
             return KCrash.CrashFlags()
         def __or__(self, f):
             '''KCrash.CrashFlags KCrash.CrashFlags.__or__(int f)'''
             return KCrash.CrashFlags()
         def __int__(self):
             '''int KCrash.CrashFlags.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KCrash.CrashFlags KCrash.CrashFlags.__ixor__(KCrash.CrashFlags f)'''
             return KCrash.CrashFlags()
         def __ior__(self, f):
             '''KCrash.CrashFlags KCrash.CrashFlags.__ior__(KCrash.CrashFlags f)'''
             return KCrash.CrashFlags()
         def __iand__(self, mask):
             '''KCrash.CrashFlags KCrash.CrashFlags.__iand__(int mask)'''
             return KCrash.CrashFlags()
 
 
 class KCursor(QCursor):
     """"""
     def __init__(self, name, fallback = None):
         '''void KCursor.__init__(QString name, Qt.CursorShape fallback = Qt.ArrowCursor)'''
     def __init__(self, cursor):
         '''void KCursor.__init__(QCursor cursor)'''
     def __init__(self):
         '''KCursor KCursor.__init__()'''
         return KCursor()
     def autoHideEventFilter(self):
         '''static QEvent KCursor.autoHideEventFilter()'''
         return QEvent()
     def hideCursorDelay(self):
         '''static int KCursor.hideCursorDelay()'''
         return int()
     def setHideCursorDelay(self, ms):
         '''static void KCursor.setHideCursorDelay(int ms)'''
     def setAutoHideCursor(self, w, enable, customEventFilter = False):
         '''static void KCursor.setAutoHideCursor(QWidget w, bool enable, bool customEventFilter = False)'''
 
 
 class KDateComboBox(KComboBox):
     """"""
     # Enum KDateComboBox.Option
     EditDate = 0
     SelectDate = 0
     DatePicker = 0
     DateKeywords = 0
     WarnOnInvalid = 0
 
     def __init__(self, parent = None):
         '''void KDateComboBox.__init__(QWidget parent = None)'''
     def displayFormat(self):
         '''KLocale.DateFormat KDateComboBox.displayFormat()'''
         return KLocale.DateFormat()
     def isNull(self):
         '''bool KDateComboBox.isNull()'''
         return bool()
     def calendarSystem(self):
         '''KLocale.CalendarSystem KDateComboBox.calendarSystem()'''
         return KLocale.CalendarSystem()
     def dateMap(self):
         '''dict-of-QDate-QString KDateComboBox.dateMap()'''
         return dict-of-QDate-QString()
     def assignCalendarSystem(self, calendarSystem):
         '''void KDateComboBox.assignCalendarSystem(KLocale.CalendarSystem calendarSystem)'''
     def assignDate(self, date):
         '''void KDateComboBox.assignDate(QDate date)'''
     def resizeEvent(self, event):
         '''void KDateComboBox.resizeEvent(QResizeEvent event)'''
     def focusOutEvent(self, event):
         '''void KDateComboBox.focusOutEvent(QFocusEvent event)'''
     def focusInEvent(self, event):
         '''void KDateComboBox.focusInEvent(QFocusEvent event)'''
     def keyPressEvent(self, event):
         '''void KDateComboBox.keyPressEvent(QKeyEvent event)'''
     def wheelEvent(self, event):
         '''void KDateComboBox.wheelEvent(QWheelEvent event)'''
     def mousePressEvent(self, event):
         '''void KDateComboBox.mousePressEvent(QMouseEvent event)'''
     def hidePopup(self):
         '''void KDateComboBox.hidePopup()'''
     def showPopup(self):
         '''void KDateComboBox.showPopup()'''
     def eventFilter(self, object, event):
         '''bool KDateComboBox.eventFilter(QObject object, QEvent event)'''
         return bool()
     def setDateMap(self, dateMap):
         '''void KDateComboBox.setDateMap(dict-of-QDate-QString dateMap)'''
     def setMaximumDate(self, maxDate, maxWarnMsg = QString()):
         '''void KDateComboBox.setMaximumDate(QDate maxDate, QString maxWarnMsg = QString())'''
     def resetMinimumDate(self):
         '''void KDateComboBox.resetMinimumDate()'''
     def setMinimumDate(self, minTime, minWarnMsg = QString()):
         '''void KDateComboBox.setMinimumDate(QDate minTime, QString minWarnMsg = QString())'''
     def setDisplayFormat(self, format):
         '''void KDateComboBox.setDisplayFormat(KLocale.DateFormat format)'''
     def setOptions(self, options):
         '''void KDateComboBox.setOptions(KDateComboBox.Options options)'''
     def setCalendarSystem(self, calendarSystem):
         '''void KDateComboBox.setCalendarSystem(KLocale.CalendarSystem calendarSystem)'''
     def setDate(self, date):
         '''void KDateComboBox.setDate(QDate date)'''
     dateEdited = pyqtSignal() # void dateEdited(const QDateamp;) - signal
     dateChanged = pyqtSignal() # void dateChanged(const QDateamp;) - signal
     dateEntered = pyqtSignal() # void dateEntered(const QDateamp;) - signal
     def setCalendar(self, calendar = None):
         '''void KDateComboBox.setCalendar(KCalendarSystem calendar = None)'''
     def resetDateRange(self):
         '''void KDateComboBox.resetDateRange()'''
     def setDateRange(self, minDate, maxDate, minWarnMsg = QString(), maxWarnMsg = QString()):
         '''void KDateComboBox.setDateRange(QDate minDate, QDate maxDate, QString minWarnMsg = QString(), QString maxWarnMsg = QString())'''
     def resetMaximumDate(self):
         '''void KDateComboBox.resetMaximumDate()'''
     def maximumDate(self):
         '''QDate KDateComboBox.maximumDate()'''
         return QDate()
     def minimumDate(self):
         '''QDate KDateComboBox.minimumDate()'''
         return QDate()
     def options(self):
         '''KDateComboBox.Options KDateComboBox.options()'''
         return KDateComboBox.Options()
     def isValid(self):
         '''bool KDateComboBox.isValid()'''
         return bool()
     def calendar(self):
         '''KCalendarSystem KDateComboBox.calendar()'''
         return KCalendarSystem()
     def date(self):
         '''QDate KDateComboBox.date()'''
         return QDate()
     class Options():
         """"""
         def __init__(self):
             '''KDateComboBox.Options KDateComboBox.Options.__init__()'''
             return KDateComboBox.Options()
         def __init__(self):
             '''int KDateComboBox.Options.__init__()'''
             return int()
         def __init__(self):
             '''void KDateComboBox.Options.__init__()'''
         def __bool__(self):
             '''int KDateComboBox.Options.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KDateComboBox.Options.__ne__(KDateComboBox.Options f)'''
             return bool()
         def __eq__(self, f):
             '''bool KDateComboBox.Options.__eq__(KDateComboBox.Options f)'''
             return bool()
         def __invert__(self):
             '''KDateComboBox.Options KDateComboBox.Options.__invert__()'''
             return KDateComboBox.Options()
         def __and__(self, mask):
             '''KDateComboBox.Options KDateComboBox.Options.__and__(int mask)'''
             return KDateComboBox.Options()
         def __xor__(self, f):
             '''KDateComboBox.Options KDateComboBox.Options.__xor__(KDateComboBox.Options f)'''
             return KDateComboBox.Options()
         def __xor__(self, f):
             '''KDateComboBox.Options KDateComboBox.Options.__xor__(int f)'''
             return KDateComboBox.Options()
         def __or__(self, f):
             '''KDateComboBox.Options KDateComboBox.Options.__or__(KDateComboBox.Options f)'''
             return KDateComboBox.Options()
         def __or__(self, f):
             '''KDateComboBox.Options KDateComboBox.Options.__or__(int f)'''
             return KDateComboBox.Options()
         def __int__(self):
             '''int KDateComboBox.Options.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KDateComboBox.Options KDateComboBox.Options.__ixor__(KDateComboBox.Options f)'''
             return KDateComboBox.Options()
         def __ior__(self, f):
             '''KDateComboBox.Options KDateComboBox.Options.__ior__(KDateComboBox.Options f)'''
             return KDateComboBox.Options()
         def __iand__(self, mask):
             '''KDateComboBox.Options KDateComboBox.Options.__iand__(int mask)'''
             return KDateComboBox.Options()
 
 
 class KDatePicker(QFrame):
     """"""
     def __init__(self, parent = None):
         '''void KDatePicker.__init__(QWidget parent = None)'''
     def __init__(self, dt, parent = None):
         '''void KDatePicker.__init__(QDate dt, QWidget parent = None)'''
     def setCalendarSystem(self, calendarSystem):
         '''bool KDatePicker.setCalendarSystem(KLocale.CalendarSystem calendarSystem)'''
         return bool()
     tableClicked = pyqtSignal() # void tableClicked() - signal
     dateEntered = pyqtSignal() # void dateEntered(const QDateamp;) - signal
     dateSelected = pyqtSignal() # void dateSelected(const QDateamp;) - signal
     dateChanged = pyqtSignal() # void dateChanged(const QDateamp;) - signal
     def weekSelected(self):
         '''int KDatePicker.weekSelected()'''
         return int()
     def todayButtonClicked(self):
         '''void KDatePicker.todayButtonClicked()'''
     def lineEnterPressed(self):
         '''void KDatePicker.lineEnterPressed()'''
     def uncheckYearSelector(self):
         '''void KDatePicker.uncheckYearSelector()'''
     def selectYearClicked(self):
         '''void KDatePicker.selectYearClicked()'''
     def selectMonthClicked(self):
         '''void KDatePicker.selectMonthClicked()'''
     def yearBackwardClicked(self):
         '''void KDatePicker.yearBackwardClicked()'''
     def yearForwardClicked(self):
         '''void KDatePicker.yearForwardClicked()'''
     def monthBackwardClicked(self):
         '''void KDatePicker.monthBackwardClicked()'''
     def monthForwardClicked(self):
         '''void KDatePicker.monthForwardClicked()'''
     def tableClickedSlot(self):
         '''void KDatePicker.tableClickedSlot()'''
     def dateChangedSlot(self, date):
         '''void KDatePicker.dateChangedSlot(QDate date)'''
     def resizeEvent(self):
         '''QResizeEvent KDatePicker.resizeEvent()'''
         return QResizeEvent()
     def eventFilter(self, o, e):
         '''bool KDatePicker.eventFilter(QObject o, QEvent e)'''
         return bool()
     def hasCloseButton(self):
         '''bool KDatePicker.hasCloseButton()'''
         return bool()
     def setCloseButton(self, enable):
         '''void KDatePicker.setCloseButton(bool enable)'''
     def fontSize(self):
         '''int KDatePicker.fontSize()'''
         return int()
     def setFontSize(self):
         '''int KDatePicker.setFontSize()'''
         return int()
     def dateTable(self):
         '''KDateTable KDatePicker.dateTable()'''
         return KDateTable()
     def setEnabled(self, enable):
         '''void KDatePicker.setEnabled(bool enable)'''
     def setCalendar(self, calendar = None):
         '''bool KDatePicker.setCalendar(KCalendarSystem calendar = None)'''
         return bool()
     def setCalendar(self, calendarType):
         '''bool KDatePicker.setCalendar(QString calendarType)'''
         return bool()
     def calendar(self):
         '''KCalendarSystem KDatePicker.calendar()'''
         return KCalendarSystem()
     def date(self):
         '''QDate KDatePicker.date()'''
         return QDate()
     def setDate(self, date):
         '''bool KDatePicker.setDate(QDate date)'''
         return bool()
     def sizeHint(self):
         '''QSize KDatePicker.sizeHint()'''
         return QSize()
 
 
 class KPopupFrame(QFrame):
     """"""
     def __init__(self, parent = None):
         '''void KPopupFrame.__init__(QWidget parent = None)'''
     leaveModality = pyqtSignal() # void leaveModality() - signal
     def exec_(self, p):
         '''int KPopupFrame.exec_(QPoint p)'''
         return int()
     def exec_(self, x, y):
         '''int KPopupFrame.exec_(int x, int y)'''
         return int()
     def popup(self, pos):
         '''void KPopupFrame.popup(QPoint pos)'''
     def resizeEvent(self, resize):
         '''void KPopupFrame.resizeEvent(QResizeEvent resize)'''
     def setMainWidget(self, m):
         '''void KPopupFrame.setMainWidget(QWidget m)'''
     def close(self, r):
         '''void KPopupFrame.close(int r)'''
     def keyPressEvent(self, e):
         '''void KPopupFrame.keyPressEvent(QKeyEvent e)'''
 
 
 class KDateValidator(QValidator):
     """"""
     def __init__(self, parent = None):
         '''void KDateValidator.__init__(QWidget parent = None)'''
     def date(self, text, date):
         '''QValidator.State KDateValidator.date(QString text, QDate date)'''
         return QValidator.State()
     def fixup(self, input):
         '''void KDateValidator.fixup(QString input)'''
     def validate(self, text, e):
         '''QValidator.State KDateValidator.validate(QString text, int e)'''
         return QValidator.State()
 
 
 class KDateTable(QWidget):
     """"""
     # Enum KDateTable.BackgroundMode
     NoBgMode = 0
     RectangleMode = 0
     CircleMode = 0
 
     def __init__(self, parent = None):
         '''void KDateTable.__init__(QWidget parent = None)'''
     def __init__(self, parent = None):
         '''QDate KDateTable.__init__(QWidget parent = None)'''
         return QDate()
     def setCalendarSystem(self, calendarSystem):
         '''bool KDateTable.setCalendarSystem(KLocale.CalendarSystem calendarSystem)'''
         return bool()
     def event(self, e):
         '''bool KDateTable.event(QEvent e)'''
         return bool()
     aboutToShowContextMenu = pyqtSignal() # void aboutToShowContextMenu(KMenu *,const QDateamp;) - signal
     tableClicked = pyqtSignal() # void tableClicked() - signal
     dateChanged = pyqtSignal() # void dateChanged(const QDateamp;) - signal
     dateChanged = pyqtSignal() # void dateChanged(const QDateamp;,const QDateamp;) - signal
     def focusOutEvent(self, e):
         '''void KDateTable.focusOutEvent(QFocusEvent e)'''
     def focusInEvent(self, e):
         '''void KDateTable.focusInEvent(QFocusEvent e)'''
     def keyPressEvent(self, e):
         '''void KDateTable.keyPressEvent(QKeyEvent e)'''
     def wheelEvent(self, e):
         '''void KDateTable.wheelEvent(QWheelEvent e)'''
     def mousePressEvent(self, e):
         '''void KDateTable.mousePressEvent(QMouseEvent e)'''
     def paintEvent(self, e):
         '''void KDateTable.paintEvent(QPaintEvent e)'''
     def dateFromPos(self, pos):
         '''QDate KDateTable.dateFromPos(int pos)'''
         return QDate()
     def posFromDate(self, date):
         '''int KDateTable.posFromDate(QDate date)'''
         return int()
     def unsetCustomDatePainting(self, date):
         '''void KDateTable.unsetCustomDatePainting(QDate date)'''
     def setCustomDatePainting(self, date, fgColor, bgMode = None, bgColor = QColor()):
         '''void KDateTable.setCustomDatePainting(QDate date, QColor fgColor, KDateTable.BackgroundMode bgMode = KDateTable.NoBgMode, QColor bgColor = QColor())'''
     def popupMenuEnabled(self):
         '''bool KDateTable.popupMenuEnabled()'''
         return bool()
     def setPopupMenuEnabled(self, enable):
         '''void KDateTable.setPopupMenuEnabled(bool enable)'''
     def setCalendar(self, calendar = None):
         '''bool KDateTable.setCalendar(KCalendarSystem calendar = None)'''
         return bool()
     def setCalendar(self, calendarType):
         '''bool KDateTable.setCalendar(QString calendarType)'''
         return bool()
     def calendar(self):
         '''KCalendarSystem KDateTable.calendar()'''
         return KCalendarSystem()
     def date(self):
         '''QDate KDateTable.date()'''
         return QDate()
     def setDate(self, date):
         '''bool KDateTable.setDate(QDate date)'''
         return bool()
     def setFontSize(self, size):
         '''void KDateTable.setFontSize(int size)'''
     def sizeHint(self):
         '''QSize KDateTable.sizeHint()'''
         return QSize()
 
 
 class KDateTimeEdit(QWidget):
     """"""
     # Enum KDateTimeEdit.Option
     ShowCalendar = 0
     ShowDate = 0
     ShowTime = 0
     ShowTimeSpec = 0
     EditDate = 0
     EditTime = 0
     SelectCalendar = 0
     SelectDate = 0
     SelectTime = 0
     SelectTimeSpec = 0
     DatePicker = 0
     DateKeywords = 0
     ForceTime = 0
     WarnOnInvalid = 0
 
     def __init__(self, parent = None):
         '''void KDateTimeEdit.__init__(QWidget parent = None)'''
     def isNullTime(self):
         '''bool KDateTimeEdit.isNullTime()'''
         return bool()
     def isNullDate(self):
         '''bool KDateTimeEdit.isNullDate()'''
         return bool()
     def isNull(self):
         '''bool KDateTimeEdit.isNull()'''
         return bool()
     def timeZones(self):
         '''dict-of-QString-KTimeZone KDateTimeEdit.timeZones()'''
         return dict-of-QString-KTimeZone()
     def timeDisplayFormat(self):
         '''KLocale.TimeFormatOptions KDateTimeEdit.timeDisplayFormat()'''
         return KLocale.TimeFormatOptions()
     def dateDisplayFormat(self):
         '''KLocale.DateFormat KDateTimeEdit.dateDisplayFormat()'''
         return KLocale.DateFormat()
     def calendarSystemsList(self):
         '''list-of-KLocale.CalendarSystem KDateTimeEdit.calendarSystemsList()'''
         return [KLocale.CalendarSystem()]
     def calendarSystem(self):
         '''KLocale.CalendarSystem KDateTimeEdit.calendarSystem()'''
         return KLocale.CalendarSystem()
     def setOptions(self, options):
         '''void KDateTimeEdit.setOptions(KDateTimeEdit.Options options)'''
     calendarChanged = pyqtSignal() # void calendarChanged(KLocale::CalendarSystem) - signal
     calendarEntered = pyqtSignal() # void calendarEntered(KLocale::CalendarSystem) - signal
     def setTimeListInterval(self, minutes):
         '''void KDateTimeEdit.setTimeListInterval(int minutes)'''
     def setCalendarSystemsList(self, calendars):
         '''void KDateTimeEdit.setCalendarSystemsList(list-of-KLocale.CalendarSystem calendars)'''
     def isValidTime(self):
         '''bool KDateTimeEdit.isValidTime()'''
         return bool()
     def isValidDate(self):
         '''bool KDateTimeEdit.isValidDate()'''
         return bool()
     def timeListInterval(self):
         '''int KDateTimeEdit.timeListInterval()'''
         return int()
     def assignTime(self, time):
         '''void KDateTimeEdit.assignTime(QTime time)'''
     def assignCalendarSystem(self, calendarSystem):
         '''void KDateTimeEdit.assignCalendarSystem(KLocale.CalendarSystem calendarSystem)'''
     def assignDate(self, date):
         '''void KDateTimeEdit.assignDate(QDate date)'''
     def assignDateTime(self, dateTime):
         '''void KDateTimeEdit.assignDateTime(KDateTime dateTime)'''
     def resizeEvent(self, event):
         '''void KDateTimeEdit.resizeEvent(QResizeEvent event)'''
     def focusOutEvent(self, event):
         '''void KDateTimeEdit.focusOutEvent(QFocusEvent event)'''
     def focusInEvent(self, event):
         '''void KDateTimeEdit.focusInEvent(QFocusEvent event)'''
     def eventFilter(self, object, event):
         '''bool KDateTimeEdit.eventFilter(QObject object, QEvent event)'''
         return bool()
     def setTimeList(self, timeList, minWarnMsg = QString(), maxWarnMsg = QString()):
         '''void KDateTimeEdit.setTimeList(list-of-QTime timeList, QString minWarnMsg = QString(), QString maxWarnMsg = QString())'''
     def setTimeDisplayFormat(self, formatOptions):
         '''void KDateTimeEdit.setTimeDisplayFormat(KLocale.TimeFormatOptions formatOptions)'''
     def setDateMap(self, dateMap):
         '''void KDateTimeEdit.setDateMap(dict-of-QDate-QString dateMap)'''
     def setDateDisplayFormat(self, format):
         '''void KDateTimeEdit.setDateDisplayFormat(KLocale.DateFormat format)'''
     def setMaximumDateTime(self, maxDateTime, maxWarnMsg = QString()):
         '''void KDateTimeEdit.setMaximumDateTime(KDateTime maxDateTime, QString maxWarnMsg = QString())'''
     def setMinimumDateTime(self, minDateTime, minWarnMsg = QString()):
         '''void KDateTimeEdit.setMinimumDateTime(KDateTime minDateTime, QString minWarnMsg = QString())'''
     def setDateTimeRange(self, minDateTime, maxDateTime, minWarnMsg = QString(), maxWarnMsg = QString()):
         '''void KDateTimeEdit.setDateTimeRange(KDateTime minDateTime, KDateTime maxDateTime, QString minWarnMsg = QString(), QString maxWarnMsg = QString())'''
     def setTimeSpec(self, spec):
         '''void KDateTimeEdit.setTimeSpec(KDateTime.Spec spec)'''
     def setTime(self, time):
         '''void KDateTimeEdit.setTime(QTime time)'''
     def setCalendarSystem(self, calendarSystem):
         '''void KDateTimeEdit.setCalendarSystem(KLocale.CalendarSystem calendarSystem)'''
     def setDate(self, date):
         '''void KDateTimeEdit.setDate(QDate date)'''
     def setDateTime(self, dateTime):
         '''void KDateTimeEdit.setDateTime(KDateTime dateTime)'''
     timeSpecChanged = pyqtSignal() # void timeSpecChanged(const KDateTime::Specamp;) - signal
     timeSpecEntered = pyqtSignal() # void timeSpecEntered(const KDateTime::Specamp;) - signal
     timeEdited = pyqtSignal() # void timeEdited(const QTimeamp;) - signal
     timeChanged = pyqtSignal() # void timeChanged(const QTimeamp;) - signal
     timeEntered = pyqtSignal() # void timeEntered(const QTimeamp;) - signal
     dateEdited = pyqtSignal() # void dateEdited(const QDateamp;) - signal
     dateChanged = pyqtSignal() # void dateChanged(const QDateamp;) - signal
     dateEntered = pyqtSignal() # void dateEntered(const QDateamp;) - signal
     dateTimeEdited = pyqtSignal() # void dateTimeEdited(const KDateTimeamp;) - signal
     dateTimeChanged = pyqtSignal() # void dateTimeChanged(const KDateTimeamp;) - signal
     dateTimeEntered = pyqtSignal() # void dateTimeEntered(const KDateTimeamp;) - signal
     def setTimeZones(self, zones):
         '''void KDateTimeEdit.setTimeZones(dict-of-QString-KTimeZone zones)'''
     def setCalendar(self, calendar = None):
         '''void KDateTimeEdit.setCalendar(KCalendarSystem calendar = None)'''
     def resetDateTimeRange(self):
         '''void KDateTimeEdit.resetDateTimeRange()'''
     def resetMaximumDateTime(self):
         '''void KDateTimeEdit.resetMaximumDateTime()'''
     def resetMinimumDateTime(self):
         '''void KDateTimeEdit.resetMinimumDateTime()'''
     def options(self):
         '''KDateTimeEdit.Options KDateTimeEdit.options()'''
         return KDateTimeEdit.Options()
     def isValid(self):
         '''bool KDateTimeEdit.isValid()'''
         return bool()
     def timeList(self):
         '''list-of-QTime KDateTimeEdit.timeList()'''
         return [QTime()]
     def dateMap(self):
         '''dict-of-QDate-QString KDateTimeEdit.dateMap()'''
         return dict-of-QDate-QString()
     def maximumDateTime(self):
         '''KDateTime KDateTimeEdit.maximumDateTime()'''
         return KDateTime()
     def minimumDateTime(self):
         '''KDateTime KDateTimeEdit.minimumDateTime()'''
         return KDateTime()
     def timeSpec(self):
         '''KDateTime.Spec KDateTimeEdit.timeSpec()'''
         return KDateTime.Spec()
     def time(self):
         '''QTime KDateTimeEdit.time()'''
         return QTime()
     def date(self):
         '''QDate KDateTimeEdit.date()'''
         return QDate()
     def dateTime(self):
         '''KDateTime KDateTimeEdit.dateTime()'''
         return KDateTime()
     class Options():
         """"""
         def __init__(self):
             '''KDateTimeEdit.Options KDateTimeEdit.Options.__init__()'''
             return KDateTimeEdit.Options()
         def __init__(self):
             '''int KDateTimeEdit.Options.__init__()'''
             return int()
         def __init__(self):
             '''void KDateTimeEdit.Options.__init__()'''
         def __bool__(self):
             '''int KDateTimeEdit.Options.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KDateTimeEdit.Options.__ne__(KDateTimeEdit.Options f)'''
             return bool()
         def __eq__(self, f):
             '''bool KDateTimeEdit.Options.__eq__(KDateTimeEdit.Options f)'''
             return bool()
         def __invert__(self):
             '''KDateTimeEdit.Options KDateTimeEdit.Options.__invert__()'''
             return KDateTimeEdit.Options()
         def __and__(self, mask):
             '''KDateTimeEdit.Options KDateTimeEdit.Options.__and__(int mask)'''
             return KDateTimeEdit.Options()
         def __xor__(self, f):
             '''KDateTimeEdit.Options KDateTimeEdit.Options.__xor__(KDateTimeEdit.Options f)'''
             return KDateTimeEdit.Options()
         def __xor__(self, f):
             '''KDateTimeEdit.Options KDateTimeEdit.Options.__xor__(int f)'''
             return KDateTimeEdit.Options()
         def __or__(self, f):
             '''KDateTimeEdit.Options KDateTimeEdit.Options.__or__(KDateTimeEdit.Options f)'''
             return KDateTimeEdit.Options()
         def __or__(self, f):
             '''KDateTimeEdit.Options KDateTimeEdit.Options.__or__(int f)'''
             return KDateTimeEdit.Options()
         def __int__(self):
             '''int KDateTimeEdit.Options.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KDateTimeEdit.Options KDateTimeEdit.Options.__ixor__(KDateTimeEdit.Options f)'''
             return KDateTimeEdit.Options()
         def __ior__(self, f):
             '''KDateTimeEdit.Options KDateTimeEdit.Options.__ior__(KDateTimeEdit.Options f)'''
             return KDateTimeEdit.Options()
         def __iand__(self, mask):
             '''KDateTimeEdit.Options KDateTimeEdit.Options.__iand__(int mask)'''
             return KDateTimeEdit.Options()
 
 
 class KDateTimeWidget(QWidget):
     """"""
     def __init__(self, parent = None):
         '''void KDateTimeWidget.__init__(QWidget parent = None)'''
     def __init__(self, datetime, parent = None):
         '''void KDateTimeWidget.__init__(QDateTime datetime, QWidget parent = None)'''
     valueChanged = pyqtSignal() # void valueChanged(const QDateTimeamp;) - signal
     def setDateTime(self, datetime):
         '''void KDateTimeWidget.setDateTime(QDateTime datetime)'''
     def dateTime(self):
         '''QDateTime KDateTimeWidget.dateTime()'''
         return QDateTime()
 
 
 class KDateWidget(QWidget):
     """"""
     def __init__(self, parent = None):
         '''void KDateWidget.__init__(QWidget parent = None)'''
     def __init__(self, date, parent = None):
         '''void KDateWidget.__init__(QDate date, QWidget parent = None)'''
     def setCalendarSystem(self, calendarSystem):
         '''bool KDateWidget.setCalendarSystem(KLocale.CalendarSystem calendarSystem)'''
         return bool()
     def slotDateChanged(self):
         '''void KDateWidget.slotDateChanged()'''
     def init(self, date):
         '''void KDateWidget.init(QDate date)'''
     changed = pyqtSignal() # void changed(const QDateamp;) - signal
     def setCalendar(self, calendar = None):
         '''bool KDateWidget.setCalendar(KCalendarSystem calendar = None)'''
         return bool()
     def setCalendar(self, calendarType):
         '''bool KDateWidget.setCalendar(QString calendarType)'''
         return bool()
     def calendar(self):
         '''KCalendarSystem KDateWidget.calendar()'''
         return KCalendarSystem()
     def setDate(self, date):
         '''bool KDateWidget.setDate(QDate date)'''
         return bool()
     def date(self):
         '''QDate KDateWidget.date()'''
         return QDate()
 
 
 class KdePrint():
     """"""
     # Enum KdePrint.PageSelectPolicy
     ApplicationSelectsPages = 0
     SystemSelectsPages = 0
 
     def createPrintDialog(self, printer, customTabs, parent = None):
         '''static QPrintDialog KdePrint.createPrintDialog(QPrinter printer, list-of-QWidget customTabs, QWidget parent = None)'''
         return QPrintDialog()
     def createPrintDialog(self, printer, parent = None):
         '''static QPrintDialog KdePrint.createPrintDialog(QPrinter printer, QWidget parent = None)'''
         return QPrintDialog()
     def createPrintDialog(self, printer, pageSelectPolicy, customTabs, parent = None):
         '''static QPrintDialog KdePrint.createPrintDialog(QPrinter printer, KdePrint.PageSelectPolicy pageSelectPolicy, list-of-QWidget customTabs, QWidget parent = None)'''
         return QPrintDialog()
     def createPrintDialog(self, printer, pageSelectPolicy, parent = None):
         '''static QPrintDialog KdePrint.createPrintDialog(QPrinter printer, KdePrint.PageSelectPolicy pageSelectPolicy, QWidget parent = None)'''
         return QPrintDialog()
 
 
 class KDescendantsProxyModel(QAbstractProxyModel):
     """"""
     def __init__(self, parent = None):
         '''void KDescendantsProxyModel.__init__(QObject parent = None)'''
     def match(self, start, role, value, hits = 1, flags = None):
         '''list-of-QModelIndex KDescendantsProxyModel.match(QModelIndex start, int role, QVariant value, int hits = 1, Qt.MatchFlags flags = Qt.MatchFlags(Qt.MatchStartsWith|Qt.MatchWrap))'''
         return [QModelIndex()]
     def supportedDropActions(self):
         '''Qt.DropActions KDescendantsProxyModel.supportedDropActions()'''
         return Qt.DropActions()
     def columnCount(self, index = QModelIndex()):
         '''int KDescendantsProxyModel.columnCount(QModelIndex index = QModelIndex())'''
         return int()
     def parent(self):
         '''QModelIndex KDescendantsProxyModel.parent()'''
         return QModelIndex()
     def index(self, parent = QModelIndex()):
         '''int KDescendantsProxyModel.index(QModelIndex parent = QModelIndex())'''
         return int()
     def hasChildren(self, parent = QModelIndex()):
         '''bool KDescendantsProxyModel.hasChildren(QModelIndex parent = QModelIndex())'''
         return bool()
     def mimeTypes(self):
         '''QStringList KDescendantsProxyModel.mimeTypes()'''
         return QStringList()
     def mimeData(self, indexes):
         '''QMimeData KDescendantsProxyModel.mimeData(list-of-QModelIndex indexes)'''
         return QMimeData()
     def headerData(self, section, orientation, role):
         '''QVariant KDescendantsProxyModel.headerData(int section, Qt.Orientation orientation, int role)'''
         return QVariant()
     def rowCount(self, parent = QModelIndex()):
         '''int KDescendantsProxyModel.rowCount(QModelIndex parent = QModelIndex())'''
         return int()
     def data(self, index, role = None):
         '''QVariant KDescendantsProxyModel.data(QModelIndex index, int role = Qt.DisplayRole)'''
         return QVariant()
     def flags(self, index):
         '''Qt.ItemFlags KDescendantsProxyModel.flags(QModelIndex index)'''
         return Qt.ItemFlags()
     def mapToSource(self, proxyIndex):
         '''QModelIndex KDescendantsProxyModel.mapToSource(QModelIndex proxyIndex)'''
         return QModelIndex()
     def mapFromSource(self, sourceIndex):
         '''QModelIndex KDescendantsProxyModel.mapFromSource(QModelIndex sourceIndex)'''
         return QModelIndex()
     def ancestorSeparator(self):
         '''QString KDescendantsProxyModel.ancestorSeparator()'''
         return QString()
     def setAncestorSeparator(self, separator):
         '''void KDescendantsProxyModel.setAncestorSeparator(QString separator)'''
     def displayAncestorData(self):
         '''bool KDescendantsProxyModel.displayAncestorData()'''
         return bool()
     def setDisplayAncestorData(self, display):
         '''void KDescendantsProxyModel.setDisplayAncestorData(bool display)'''
     def setRootIndex(self, index):
         '''void KDescendantsProxyModel.setRootIndex(QModelIndex index)'''
     def setSourceModel(self, model):
         '''void KDescendantsProxyModel.setSourceModel(QAbstractItemModel model)'''
 
 
 class KDialogButtonBox(QDialogButtonBox):
     """"""
     def __init__(self, parent, _orientation = None):
         '''void KDialogButtonBox.__init__(QWidget parent, Qt.Orientation _orientation = Qt.Horizontal)'''
     def addButton(self, text, role):
         '''SLOT() KDialogButtonBox.addButton(QString text, QDialogButtonBox.ButtonRole role)'''
         return SLOT()()
     def addButton(self, text, role):
         '''callable KDialogButtonBox.addButton(QString text, QDialogButtonBox.ButtonRole role)'''
         return callable()
     def addButton(self, guiitem, role):
         '''SLOT() KDialogButtonBox.addButton(KGuiItem guiitem, QDialogButtonBox.ButtonRole role)'''
         return SLOT()()
     def addButton(self, guiitem, role):
         '''callable KDialogButtonBox.addButton(KGuiItem guiitem, QDialogButtonBox.ButtonRole role)'''
         return callable()
 
 
 class KDialogJobUiDelegate(KJobUiDelegate):
     """"""
     def __init__(self):
         '''void KDialogJobUiDelegate.__init__()'''
     def slotWarning(self, job, plain, rich):
         '''void KDialogJobUiDelegate.slotWarning(KJob job, QString plain, QString rich)'''
     def showErrorMessage(self):
         '''void KDialogJobUiDelegate.showErrorMessage()'''
     def userTimestamp(self):
         '''int KDialogJobUiDelegate.userTimestamp()'''
         return int()
     def updateUserTimestamp(self, time):
         '''void KDialogJobUiDelegate.updateUserTimestamp(int time)'''
     def window(self):
         '''QWidget KDialogJobUiDelegate.window()'''
         return QWidget()
     def setWindow(self, window):
         '''void KDialogJobUiDelegate.setWindow(QWidget window)'''
 
 
 class KDualAction(KAction):
     """"""
     def __init__(self, parent):
         '''void KDualAction.__init__(QObject parent)'''
     def __init__(self, inactiveText, activeText, parent):
         '''void KDualAction.__init__(QString inactiveText, QString activeText, QObject parent)'''
     activeChangedByUser = pyqtSignal() # void activeChangedByUser(bool) - signal
     activeChanged = pyqtSignal() # void activeChanged(bool) - signal
     def setActive(self, state):
         '''void KDualAction.setActive(bool state)'''
     def autoToggle(self):
         '''bool KDualAction.autoToggle()'''
         return bool()
     def setAutoToggle(self):
         '''bool KDualAction.setAutoToggle()'''
         return bool()
     def isActive(self):
         '''bool KDualAction.isActive()'''
         return bool()
     def setIconForStates(self, icon):
         '''void KDualAction.setIconForStates(QIcon icon)'''
     def inactiveToolTip(self):
         '''QString KDualAction.inactiveToolTip()'''
         return QString()
     def setInactiveToolTip(self):
         '''QString KDualAction.setInactiveToolTip()'''
         return QString()
     def activeToolTip(self):
         '''QString KDualAction.activeToolTip()'''
         return QString()
     def setActiveToolTip(self):
         '''QString KDualAction.setActiveToolTip()'''
         return QString()
     def inactiveText(self):
         '''QString KDualAction.inactiveText()'''
         return QString()
     def setInactiveText(self):
         '''QString KDualAction.setInactiveText()'''
         return QString()
     def activeText(self):
         '''QString KDualAction.activeText()'''
         return QString()
     def setActiveText(self):
         '''QString KDualAction.setActiveText()'''
         return QString()
     def inactiveIcon(self):
         '''QIcon KDualAction.inactiveIcon()'''
         return QIcon()
     def setInactiveIcon(self):
         '''QIcon KDualAction.setInactiveIcon()'''
         return QIcon()
     def activeIcon(self):
         '''QIcon KDualAction.activeIcon()'''
         return QIcon()
     def setActiveIcon(self):
         '''QIcon KDualAction.setActiveIcon()'''
         return QIcon()
     def inactiveGuiItem(self):
         '''KGuiItem KDualAction.inactiveGuiItem()'''
         return KGuiItem()
     def setInactiveGuiItem(self):
         '''KGuiItem KDualAction.setInactiveGuiItem()'''
         return KGuiItem()
     def activeGuiItem(self):
         '''KGuiItem KDualAction.activeGuiItem()'''
         return KGuiItem()
     def setActiveGuiItem(self):
         '''KGuiItem KDualAction.setActiveGuiItem()'''
         return KGuiItem()
 
 
 class KEditListBox(QGroupBox):
     """"""
     # Enum KEditListBox.Button
     Add = 0
     Remove = 0
     UpDown = 0
     All = 0
 
     def __init__(self, parent = None):
         '''void KEditListBox.__init__(QWidget parent = None)'''
     def __init__(self, title, parent = None):
         '''void KEditListBox.__init__(QString title, QWidget parent = None)'''
     def __init__(self, parent, name, checkAtEntering = False, buttons = None):
         '''void KEditListBox.__init__(QWidget parent, str name, bool checkAtEntering = False, KEditListBox.Buttons buttons = KEditListBox.All)'''
     def __init__(self, title, parent, name, checkAtEntering = False, buttons = None):
         '''void KEditListBox.__init__(QString title, QWidget parent, str name, bool checkAtEntering = False, KEditListBox.Buttons buttons = KEditListBox.All)'''
     def __init__(self, title, customEditor, parent = None, name = None, checkAtEntering = False, buttons = None):
         '''void KEditListBox.__init__(QString title, KEditListBox.CustomEditor customEditor, QWidget parent = None, str name = None, bool checkAtEntering = False, KEditListBox.Buttons buttons = KEditListBox.All)'''
     def typedSomething(self, text):
         '''void KEditListBox.typedSomething(QString text)'''
     def enableMoveButtons(self):
         '''QModelIndex KEditListBox.enableMoveButtons()'''
         return QModelIndex()
     def removeItem(self):
         '''void KEditListBox.removeItem()'''
     def addItem(self):
         '''void KEditListBox.addItem()'''
     def moveItemDown(self):
         '''void KEditListBox.moveItemDown()'''
     def moveItemUp(self):
         '''void KEditListBox.moveItemUp()'''
     removed = pyqtSignal() # void removed(const QStringamp;) - signal
     added = pyqtSignal() # void added(const QStringamp;) - signal
     changed = pyqtSignal() # void changed() - signal
     def eventFilter(self, o, e):
         '''bool KEditListBox.eventFilter(QObject o, QEvent e)'''
         return bool()
     def setCustomEditor(self, editor):
         '''void KEditListBox.setCustomEditor(KEditListBox.CustomEditor editor)'''
     def checkAtEntering(self):
         '''bool KEditListBox.checkAtEntering()'''
         return bool()
     def setCheckAtEntering(self, check):
         '''void KEditListBox.setCheckAtEntering(bool check)'''
     def setButtons(self, buttons):
         '''void KEditListBox.setButtons(KEditListBox.Buttons buttons)'''
     def buttons(self):
         '''KEditListBox.Buttons KEditListBox.buttons()'''
         return KEditListBox.Buttons()
     def setItems(self, items):
         '''void KEditListBox.setItems(QStringList items)'''
     def items(self):
         '''QStringList KEditListBox.items()'''
         return QStringList()
     def currentText(self):
         '''QString KEditListBox.currentText()'''
         return QString()
     def currentItem(self):
         '''int KEditListBox.currentItem()'''
         return int()
     def text(self, index):
         '''QString KEditListBox.text(int index)'''
         return QString()
     def clear(self):
         '''void KEditListBox.clear()'''
     def insertItem(self, text, index = None):
         '''void KEditListBox.insertItem(QString text, int index = -1)'''
     def insertStringList(self, list, index = None):
         '''void KEditListBox.insertStringList(QStringList list, int index = -1)'''
     def count(self):
         '''int KEditListBox.count()'''
         return int()
     def downButton(self):
         '''QPushButton KEditListBox.downButton()'''
         return QPushButton()
     def upButton(self):
         '''QPushButton KEditListBox.upButton()'''
         return QPushButton()
     def removeButton(self):
         '''QPushButton KEditListBox.removeButton()'''
         return QPushButton()
     def addButton(self):
         '''QPushButton KEditListBox.addButton()'''
         return QPushButton()
     def lineEdit(self):
         '''KLineEdit KEditListBox.lineEdit()'''
         return KLineEdit()
     def listView(self):
         '''QListView KEditListBox.listView()'''
         return QListView()
     class Buttons():
         """"""
         def __init__(self):
             '''KEditListBox.Buttons KEditListBox.Buttons.__init__()'''
             return KEditListBox.Buttons()
         def __init__(self):
             '''int KEditListBox.Buttons.__init__()'''
             return int()
         def __init__(self):
             '''void KEditListBox.Buttons.__init__()'''
         def __bool__(self):
             '''int KEditListBox.Buttons.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KEditListBox.Buttons.__ne__(KEditListBox.Buttons f)'''
             return bool()
         def __eq__(self, f):
             '''bool KEditListBox.Buttons.__eq__(KEditListBox.Buttons f)'''
             return bool()
         def __invert__(self):
             '''KEditListBox.Buttons KEditListBox.Buttons.__invert__()'''
             return KEditListBox.Buttons()
         def __and__(self, mask):
             '''KEditListBox.Buttons KEditListBox.Buttons.__and__(int mask)'''
             return KEditListBox.Buttons()
         def __xor__(self, f):
             '''KEditListBox.Buttons KEditListBox.Buttons.__xor__(KEditListBox.Buttons f)'''
             return KEditListBox.Buttons()
         def __xor__(self, f):
             '''KEditListBox.Buttons KEditListBox.Buttons.__xor__(int f)'''
             return KEditListBox.Buttons()
         def __or__(self, f):
             '''KEditListBox.Buttons KEditListBox.Buttons.__or__(KEditListBox.Buttons f)'''
             return KEditListBox.Buttons()
         def __or__(self, f):
             '''KEditListBox.Buttons KEditListBox.Buttons.__or__(int f)'''
             return KEditListBox.Buttons()
         def __int__(self):
             '''int KEditListBox.Buttons.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KEditListBox.Buttons KEditListBox.Buttons.__ixor__(KEditListBox.Buttons f)'''
             return KEditListBox.Buttons()
         def __ior__(self, f):
             '''KEditListBox.Buttons KEditListBox.Buttons.__ior__(KEditListBox.Buttons f)'''
             return KEditListBox.Buttons()
         def __iand__(self, mask):
             '''KEditListBox.Buttons KEditListBox.Buttons.__iand__(int mask)'''
             return KEditListBox.Buttons()
     class CustomEditor():
         """"""
         def __init__(self):
             '''void KEditListBox.CustomEditor.__init__()'''
         def __init__(self, repWidget, edit):
             '''void KEditListBox.CustomEditor.__init__(QWidget repWidget, KLineEdit edit)'''
         def __init__(self, combo):
             '''void KEditListBox.CustomEditor.__init__(KComboBox combo)'''
         def lineEdit(self):
             '''KLineEdit KEditListBox.CustomEditor.lineEdit()'''
             return KLineEdit()
         def representationWidget(self):
             '''QWidget KEditListBox.CustomEditor.representationWidget()'''
             return QWidget()
         def setLineEdit(self, edit):
             '''void KEditListBox.CustomEditor.setLineEdit(KLineEdit edit)'''
         def setRepresentationWidget(self, repWidget):
             '''void KEditListBox.CustomEditor.setRepresentationWidget(QWidget repWidget)'''
 
 
 class KEditListWidget(QWidget):
     """"""
     # Enum KEditListWidget.Button
     Add = 0
     Remove = 0
     UpDown = 0
     All = 0
 
     def __init__(self, parent = None):
         '''void KEditListWidget.__init__(QWidget parent = None)'''
     def __init__(self, customEditor, parent = None, checkAtEntering = False, buttons = None):
         '''void KEditListWidget.__init__(KEditListWidget.CustomEditor customEditor, QWidget parent = None, bool checkAtEntering = False, KEditListWidget.Buttons buttons = KEditListWidget.All)'''
     removed = pyqtSignal() # void removed(const QStringamp;) - signal
     added = pyqtSignal() # void added(const QStringamp;) - signal
     changed = pyqtSignal() # void changed() - signal
     def eventFilter(self, o, e):
         '''bool KEditListWidget.eventFilter(QObject o, QEvent e)'''
         return bool()
     def setCustomEditor(self, editor):
         '''void KEditListWidget.setCustomEditor(KEditListWidget.CustomEditor editor)'''
     def checkAtEntering(self):
         '''bool KEditListWidget.checkAtEntering()'''
         return bool()
     def setCheckAtEntering(self, check):
         '''void KEditListWidget.setCheckAtEntering(bool check)'''
     def setButtons(self, buttons):
         '''void KEditListWidget.setButtons(KEditListWidget.Buttons buttons)'''
     def buttons(self):
         '''KEditListWidget.Buttons KEditListWidget.buttons()'''
         return KEditListWidget.Buttons()
     def setItems(self, items):
         '''void KEditListWidget.setItems(QStringList items)'''
     def items(self):
         '''QStringList KEditListWidget.items()'''
         return QStringList()
     def currentText(self):
         '''QString KEditListWidget.currentText()'''
         return QString()
     def currentItem(self):
         '''int KEditListWidget.currentItem()'''
         return int()
     def text(self, index):
         '''QString KEditListWidget.text(int index)'''
         return QString()
     def clear(self):
         '''void KEditListWidget.clear()'''
     def insertItem(self, text, index = None):
         '''void KEditListWidget.insertItem(QString text, int index = -1)'''
     def insertStringList(self, list, index = None):
         '''void KEditListWidget.insertStringList(QStringList list, int index = -1)'''
     def count(self):
         '''int KEditListWidget.count()'''
         return int()
     def downButton(self):
         '''QPushButton KEditListWidget.downButton()'''
         return QPushButton()
     def upButton(self):
         '''QPushButton KEditListWidget.upButton()'''
         return QPushButton()
     def removeButton(self):
         '''QPushButton KEditListWidget.removeButton()'''
         return QPushButton()
     def addButton(self):
         '''QPushButton KEditListWidget.addButton()'''
         return QPushButton()
     def lineEdit(self):
         '''KLineEdit KEditListWidget.lineEdit()'''
         return KLineEdit()
     def listView(self):
         '''QListView KEditListWidget.listView()'''
         return QListView()
     class CustomEditor():
         """"""
         def __init__(self):
             '''void KEditListWidget.CustomEditor.__init__()'''
         def __init__(self, repWidget, edit):
             '''void KEditListWidget.CustomEditor.__init__(QWidget repWidget, KLineEdit edit)'''
         def __init__(self, combo):
             '''void KEditListWidget.CustomEditor.__init__(KComboBox combo)'''
         def lineEdit(self):
             '''KLineEdit KEditListWidget.CustomEditor.lineEdit()'''
             return KLineEdit()
         def representationWidget(self):
             '''QWidget KEditListWidget.CustomEditor.representationWidget()'''
             return QWidget()
         def setLineEdit(self, edit):
             '''void KEditListWidget.CustomEditor.setLineEdit(KLineEdit edit)'''
         def setRepresentationWidget(self, repWidget):
             '''void KEditListWidget.CustomEditor.setRepresentationWidget(QWidget repWidget)'''
     class Buttons():
         """"""
         def __init__(self):
             '''KEditListWidget.Buttons KEditListWidget.Buttons.__init__()'''
             return KEditListWidget.Buttons()
         def __init__(self):
             '''int KEditListWidget.Buttons.__init__()'''
             return int()
         def __init__(self):
             '''void KEditListWidget.Buttons.__init__()'''
         def __bool__(self):
             '''int KEditListWidget.Buttons.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KEditListWidget.Buttons.__ne__(KEditListWidget.Buttons f)'''
             return bool()
         def __eq__(self, f):
             '''bool KEditListWidget.Buttons.__eq__(KEditListWidget.Buttons f)'''
             return bool()
         def __invert__(self):
             '''KEditListWidget.Buttons KEditListWidget.Buttons.__invert__()'''
             return KEditListWidget.Buttons()
         def __and__(self, mask):
             '''KEditListWidget.Buttons KEditListWidget.Buttons.__and__(int mask)'''
             return KEditListWidget.Buttons()
         def __xor__(self, f):
             '''KEditListWidget.Buttons KEditListWidget.Buttons.__xor__(KEditListWidget.Buttons f)'''
             return KEditListWidget.Buttons()
         def __xor__(self, f):
             '''KEditListWidget.Buttons KEditListWidget.Buttons.__xor__(int f)'''
             return KEditListWidget.Buttons()
         def __or__(self, f):
             '''KEditListWidget.Buttons KEditListWidget.Buttons.__or__(KEditListWidget.Buttons f)'''
             return KEditListWidget.Buttons()
         def __or__(self, f):
             '''KEditListWidget.Buttons KEditListWidget.Buttons.__or__(int f)'''
             return KEditListWidget.Buttons()
         def __int__(self):
             '''int KEditListWidget.Buttons.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KEditListWidget.Buttons KEditListWidget.Buttons.__ixor__(KEditListWidget.Buttons f)'''
             return KEditListWidget.Buttons()
         def __ior__(self, f):
             '''KEditListWidget.Buttons KEditListWidget.Buttons.__ior__(KEditListWidget.Buttons f)'''
             return KEditListWidget.Buttons()
         def __iand__(self, mask):
             '''KEditListWidget.Buttons KEditListWidget.Buttons.__iand__(int mask)'''
             return KEditListWidget.Buttons()
 
 
 class KEditToolBar(KDialog):
     """"""
     def __init__(self, collection, parent = None):
         '''void KEditToolBar.__init__(KActionCollection collection, QWidget parent = None)'''
     def __init__(self, factory, parent = None):
         '''void KEditToolBar.__init__(KXMLGUIFactory factory, QWidget parent = None)'''
     def hideEvent(self, event):
         '''void KEditToolBar.hideEvent(QHideEvent event)'''
     def showEvent(self, event):
         '''void KEditToolBar.showEvent(QShowEvent event)'''
     newToolbarConfig = pyqtSignal() # void newToolbarConfig() - signal
     newToolBarConfig = pyqtSignal() # void newToolBarConfig() - signal
     def setGlobalDefaultToolBar(self, toolBarName):
         '''static void KEditToolBar.setGlobalDefaultToolBar(str toolBarName)'''
     def setResourceFile(self, file, global_ = True):
         '''void KEditToolBar.setResourceFile(QString file, bool global = True)'''
     def setDefaultToolBar(self, toolBarName):
         '''void KEditToolBar.setDefaultToolBar(QString toolBarName)'''
 
 
 class KExtendableItemDelegate(QStyledItemDelegate):
     """"""
     # Enum KExtendableItemDelegate.auxDataRoles
     ShowExtensionIndicatorRole = 0
 
     def __init__(self, parent):
         '''void KExtendableItemDelegate.__init__(QAbstractItemView parent)'''
     def contractPixmap(self):
         '''QPixmap KExtendableItemDelegate.contractPixmap()'''
         return QPixmap()
     def extendPixmap(self):
         '''QPixmap KExtendableItemDelegate.extendPixmap()'''
         return QPixmap()
     def setContractPixmap(self, pixmap):
         '''void KExtendableItemDelegate.setContractPixmap(QPixmap pixmap)'''
     def setExtendPixmap(self, pixmap):
         '''void KExtendableItemDelegate.setExtendPixmap(QPixmap pixmap)'''
     def extenderRect(self, extender, option, index):
         '''QRect KExtendableItemDelegate.extenderRect(QWidget extender, QStyleOptionViewItem option, QModelIndex index)'''
         return QRect()
     extenderDestroyed = pyqtSignal() # void extenderDestroyed(QWidget *,const QModelIndexamp;) - signal
     extenderCreated = pyqtSignal() # void extenderCreated(QWidget *,const QModelIndexamp;) - signal
     def updateExtenderGeometry(self, extender, option, index):
         '''void KExtendableItemDelegate.updateExtenderGeometry(QWidget extender, QStyleOptionViewItem option, QModelIndex index)'''
     def isExtended(self, index):
         '''bool KExtendableItemDelegate.isExtended(QModelIndex index)'''
         return bool()
     def contractAll(self):
         '''void KExtendableItemDelegate.contractAll()'''
     def contractItem(self, index):
         '''void KExtendableItemDelegate.contractItem(QModelIndex index)'''
     def extendItem(self, extender, index):
         '''void KExtendableItemDelegate.extendItem(QWidget extender, QModelIndex index)'''
     def paint(self, painter, option, index):
         '''void KExtendableItemDelegate.paint(QPainter painter, QStyleOptionViewItem option, QModelIndex index)'''
     def sizeHint(self, option, index):
         '''QSize KExtendableItemDelegate.sizeHint(QStyleOptionViewItem option, QModelIndex index)'''
         return QSize()
 
 
 class KFadeWidgetEffect(QWidget):
     """"""
     def __init__(self, destWidget):
         '''void KFadeWidgetEffect.__init__(QWidget destWidget)'''
     def paintEvent(self):
         '''QPaintEvent KFadeWidgetEffect.paintEvent()'''
         return QPaintEvent()
     def start(self, duration = 250):
         '''void KFadeWidgetEffect.start(int duration = 250)'''
 
 
 class KFilterProxySearchLine(QWidget):
     """"""
     def __init__(self, parent = None):
         '''void KFilterProxySearchLine.__init__(QWidget parent = None)'''
     def lineEdit(self):
         '''KLineEdit KFilterProxySearchLine.lineEdit()'''
         return KLineEdit()
     def setText(self, text):
         '''void KFilterProxySearchLine.setText(QString text)'''
     def setProxy(self, proxy):
         '''void KFilterProxySearchLine.setProxy(QSortFilterProxyModel proxy)'''
 
 
 class KFind(QObject):
     """"""
     # Enum KFind.Result
     NoMatch = 0
     Match = 0
 
     # Enum KFind.Options
     WholeWordsOnly = 0
     FromCursor = 0
     SelectedText = 0
     CaseSensitive = 0
     FindBackwards = 0
     RegularExpression = 0
     FindIncremental = 0
     MinimumUserOption = 0
 
     def __init__(self, pattern, options, parent):
         '''void KFind.__init__(QString pattern, int options, QWidget parent)'''
     def __init__(self, pattern, options, parent, findDialog):
         '''void KFind.__init__(QString pattern, int options, QWidget parent, QWidget findDialog)'''
     def dialogsParent(self):
         '''QWidget KFind.dialogsParent()'''
         return QWidget()
     def parentWidget(self):
         '''QWidget KFind.parentWidget()'''
         return QWidget()
     dialogClosed = pyqtSignal() # void dialogClosed() - signal
     optionsChanged = pyqtSignal() # void optionsChanged() - signal
     findNext = pyqtSignal() # void findNext() - signal
     highlight = pyqtSignal() # void highlight(const QStringamp;,int,int) - signal
     highlight = pyqtSignal() # void highlight(int,int,int) - signal
     def index(self):
         '''int KFind.index()'''
         return int()
     def closeFindNextDialog(self):
         '''void KFind.closeFindNextDialog()'''
     def findNextDialog(self, create = False):
         '''KDialog KFind.findNextDialog(bool create = False)'''
         return KDialog()
     def displayFinalDialog(self):
         '''void KFind.displayFinalDialog()'''
     def shouldRestart(self, forceAsking = False, showNumMatches = True):
         '''bool KFind.shouldRestart(bool forceAsking = False, bool showNumMatches = True)'''
         return bool()
     def validateMatch(self, text, index, matchedlength):
         '''bool KFind.validateMatch(QString text, int index, int matchedlength)'''
         return bool()
     def resetCounts(self):
         '''void KFind.resetCounts()'''
     def numMatches(self):
         '''int KFind.numMatches()'''
         return int()
     def setPattern(self, pattern):
         '''void KFind.setPattern(QString pattern)'''
     def pattern(self):
         '''QString KFind.pattern()'''
         return QString()
     def setOptions(self, options):
         '''void KFind.setOptions(int options)'''
     def options(self):
         '''int KFind.options()'''
         return int()
     def find(self):
         '''KFind.Result KFind.find()'''
         return KFind.Result()
     def find(self, text, pattern, index, options, matchedlength):
         '''static int KFind.find(QString text, QString pattern, int index, int options, int matchedlength)'''
         return int()
     def find(self, text, pattern, index, options, matchedlength):
         '''static int KFind.find(QString text, QRegExp pattern, int index, int options, int matchedlength)'''
         return int()
     def setData(self, data, startPos = None):
         '''void KFind.setData(QString data, int startPos = -1)'''
     def setData(self, id, data, startPos = None):
         '''void KFind.setData(int id, QString data, int startPos = -1)'''
     def needData(self):
         '''bool KFind.needData()'''
         return bool()
     class SearchOptions():
         """"""
         def __init__(self):
             '''KFind.SearchOptions KFind.SearchOptions.__init__()'''
             return KFind.SearchOptions()
         def __init__(self):
             '''int KFind.SearchOptions.__init__()'''
             return int()
         def __init__(self):
             '''void KFind.SearchOptions.__init__()'''
         def __bool__(self):
             '''int KFind.SearchOptions.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KFind.SearchOptions.__ne__(KFind.SearchOptions f)'''
             return bool()
         def __eq__(self, f):
             '''bool KFind.SearchOptions.__eq__(KFind.SearchOptions f)'''
             return bool()
         def __invert__(self):
             '''KFind.SearchOptions KFind.SearchOptions.__invert__()'''
             return KFind.SearchOptions()
         def __and__(self, mask):
             '''KFind.SearchOptions KFind.SearchOptions.__and__(int mask)'''
             return KFind.SearchOptions()
         def __xor__(self, f):
             '''KFind.SearchOptions KFind.SearchOptions.__xor__(KFind.SearchOptions f)'''
             return KFind.SearchOptions()
         def __xor__(self, f):
             '''KFind.SearchOptions KFind.SearchOptions.__xor__(int f)'''
             return KFind.SearchOptions()
         def __or__(self, f):
             '''KFind.SearchOptions KFind.SearchOptions.__or__(KFind.SearchOptions f)'''
             return KFind.SearchOptions()
         def __or__(self, f):
             '''KFind.SearchOptions KFind.SearchOptions.__or__(int f)'''
             return KFind.SearchOptions()
         def __int__(self):
             '''int KFind.SearchOptions.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KFind.SearchOptions KFind.SearchOptions.__ixor__(KFind.SearchOptions f)'''
             return KFind.SearchOptions()
         def __ior__(self, f):
             '''KFind.SearchOptions KFind.SearchOptions.__ior__(KFind.SearchOptions f)'''
             return KFind.SearchOptions()
         def __iand__(self, mask):
             '''KFind.SearchOptions KFind.SearchOptions.__iand__(int mask)'''
             return KFind.SearchOptions()
 
 
 class KFindDialog(KDialog):
     """"""
     def __init__(self, parent = None, options = 0, findStrings = QStringList(), hasSelection = False, replaceDialog = False):
         '''void KFindDialog.__init__(QWidget parent = None, int options = 0, QStringList findStrings = QStringList(), bool hasSelection = False, bool replaceDialog = False)'''
     def showEvent(self):
         '''QShowEvent KFindDialog.showEvent()'''
         return QShowEvent()
     optionsChanged = pyqtSignal() # void optionsChanged() - signal
     def findExtension(self):
         '''QWidget KFindDialog.findExtension()'''
         return QWidget()
     def setPattern(self, pattern):
         '''void KFindDialog.setPattern(QString pattern)'''
     def pattern(self):
         '''QString KFindDialog.pattern()'''
         return QString()
     def options(self):
         '''int KFindDialog.options()'''
         return int()
     def setOptions(self, options):
         '''void KFindDialog.setOptions(int options)'''
     def setSupportsRegularExpressionFind(self, supports):
         '''void KFindDialog.setSupportsRegularExpressionFind(bool supports)'''
     def setSupportsWholeWordsFind(self, supports):
         '''void KFindDialog.setSupportsWholeWordsFind(bool supports)'''
     def setSupportsCaseSensitiveFind(self, supports):
         '''void KFindDialog.setSupportsCaseSensitiveFind(bool supports)'''
     def setSupportsBackwardsFind(self, supports):
         '''void KFindDialog.setSupportsBackwardsFind(bool supports)'''
     def setHasCursor(self, hasCursor):
         '''void KFindDialog.setHasCursor(bool hasCursor)'''
     def setHasSelection(self, hasSelection):
         '''void KFindDialog.setHasSelection(bool hasSelection)'''
     def findHistory(self):
         '''QStringList KFindDialog.findHistory()'''
         return QStringList()
     def setFindHistory(self, history):
         '''void KFindDialog.setFindHistory(QStringList history)'''
 
 
 class KFontAction(KSelectAction):
     """"""
     def __init__(self, fontListCriteria, parent):
         '''void KFontAction.__init__(int fontListCriteria, QObject parent)'''
     def __init__(self, parent):
         '''void KFontAction.__init__(QObject parent)'''
     def __init__(self, text, parent):
         '''void KFontAction.__init__(QString text, QObject parent)'''
     def __init__(self, icon, text, parent):
         '''void KFontAction.__init__(KIcon icon, QString text, QObject parent)'''
     def createWidget(self, parent):
         '''QWidget KFontAction.createWidget(QWidget parent)'''
         return QWidget()
     def setFont(self, family):
         '''void KFontAction.setFont(QString family)'''
     def font(self):
         '''QString KFontAction.font()'''
         return QString()
 
 
 class KFontChooser(QWidget):
     """"""
     # Enum KFontChooser.FontListCriteria
     FixedWidthFonts = 0
     ScalableFonts = 0
     SmoothScalableFonts = 0
 
     # Enum KFontChooser.DisplayFlag
     NoDisplayFlags = 0
     FixedFontsOnly = 0
     DisplayFrame = 0
     ShowDifferences = 0
 
     # Enum KFontChooser.FontDiff
     NoFontDiffFlags = 0
     FontDiffFamily = 0
     FontDiffStyle = 0
     FontDiffSize = 0
     AllFontDiffs = 0
 
     # Enum KFontChooser.FontColumn
     FamilyList = 0
     StyleList = 0
     SizeList = 0
 
     def __init__(self, parent = None, flags = None, fontList = QStringList(), visibleListSize = 8, sizeIsRelativeState = None):
         '''void KFontChooser.__init__(QWidget parent = None, KFontChooser.DisplayFlags flags = KFontChooser.DisplayFrame, QStringList fontList = QStringList(), int visibleListSize = 8, Qt.CheckState sizeIsRelativeState)'''
     fontSelected = pyqtSignal() # void fontSelected(const QFontamp;) - signal
     def sizeHint(self):
         '''QSize KFontChooser.sizeHint()'''
         return QSize()
     def getFontList(self, list, fontListCriteria):
         '''static void KFontChooser.getFontList(QStringList list, int fontListCriteria)'''
     def setSampleBoxVisible(self, visible):
         '''void KFontChooser.setSampleBoxVisible(bool visible)'''
     def setSampleText(self, text):
         '''void KFontChooser.setSampleText(QString text)'''
     def sampleText(self):
         '''QString KFontChooser.sampleText()'''
         return QString()
     def sizeIsRelative(self):
         '''Qt.CheckState KFontChooser.sizeIsRelative()'''
         return Qt.CheckState()
     def setSizeIsRelative(self, relative):
         '''void KFontChooser.setSizeIsRelative(Qt.CheckState relative)'''
     def backgroundColor(self):
         '''QColor KFontChooser.backgroundColor()'''
         return QColor()
     def setBackgroundColor(self, col):
         '''void KFontChooser.setBackgroundColor(QColor col)'''
     def color(self):
         '''QColor KFontChooser.color()'''
         return QColor()
     def setColor(self, col):
         '''void KFontChooser.setColor(QColor col)'''
     def font(self):
         '''QFont KFontChooser.font()'''
         return QFont()
     def fontDiffFlags(self):
         '''KFontChooser.FontDiffFlags KFontChooser.fontDiffFlags()'''
         return KFontChooser.FontDiffFlags()
     def setFont(self, font, onlyFixed = False):
         '''void KFontChooser.setFont(QFont font, bool onlyFixed = False)'''
     def enableColumn(self, column, state):
         '''void KFontChooser.enableColumn(int column, bool state)'''
     class DisplayFlags():
         """"""
         def __init__(self):
             '''KFontChooser.DisplayFlags KFontChooser.DisplayFlags.__init__()'''
             return KFontChooser.DisplayFlags()
         def __init__(self):
             '''int KFontChooser.DisplayFlags.__init__()'''
             return int()
         def __init__(self):
             '''void KFontChooser.DisplayFlags.__init__()'''
         def __bool__(self):
             '''int KFontChooser.DisplayFlags.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KFontChooser.DisplayFlags.__ne__(KFontChooser.DisplayFlags f)'''
             return bool()
         def __eq__(self, f):
             '''bool KFontChooser.DisplayFlags.__eq__(KFontChooser.DisplayFlags f)'''
             return bool()
         def __invert__(self):
             '''KFontChooser.DisplayFlags KFontChooser.DisplayFlags.__invert__()'''
             return KFontChooser.DisplayFlags()
         def __and__(self, mask):
             '''KFontChooser.DisplayFlags KFontChooser.DisplayFlags.__and__(int mask)'''
             return KFontChooser.DisplayFlags()
         def __xor__(self, f):
             '''KFontChooser.DisplayFlags KFontChooser.DisplayFlags.__xor__(KFontChooser.DisplayFlags f)'''
             return KFontChooser.DisplayFlags()
         def __xor__(self, f):
             '''KFontChooser.DisplayFlags KFontChooser.DisplayFlags.__xor__(int f)'''
             return KFontChooser.DisplayFlags()
         def __or__(self, f):
             '''KFontChooser.DisplayFlags KFontChooser.DisplayFlags.__or__(KFontChooser.DisplayFlags f)'''
             return KFontChooser.DisplayFlags()
         def __or__(self, f):
             '''KFontChooser.DisplayFlags KFontChooser.DisplayFlags.__or__(int f)'''
             return KFontChooser.DisplayFlags()
         def __int__(self):
             '''int KFontChooser.DisplayFlags.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KFontChooser.DisplayFlags KFontChooser.DisplayFlags.__ixor__(KFontChooser.DisplayFlags f)'''
             return KFontChooser.DisplayFlags()
         def __ior__(self, f):
             '''KFontChooser.DisplayFlags KFontChooser.DisplayFlags.__ior__(KFontChooser.DisplayFlags f)'''
             return KFontChooser.DisplayFlags()
         def __iand__(self, mask):
             '''KFontChooser.DisplayFlags KFontChooser.DisplayFlags.__iand__(int mask)'''
             return KFontChooser.DisplayFlags()
     class FontDiffFlags():
         """"""
         def __init__(self):
             '''KFontChooser.FontDiffFlags KFontChooser.FontDiffFlags.__init__()'''
             return KFontChooser.FontDiffFlags()
         def __init__(self):
             '''int KFontChooser.FontDiffFlags.__init__()'''
             return int()
         def __init__(self):
             '''void KFontChooser.FontDiffFlags.__init__()'''
         def __bool__(self):
             '''int KFontChooser.FontDiffFlags.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KFontChooser.FontDiffFlags.__ne__(KFontChooser.FontDiffFlags f)'''
             return bool()
         def __eq__(self, f):
             '''bool KFontChooser.FontDiffFlags.__eq__(KFontChooser.FontDiffFlags f)'''
             return bool()
         def __invert__(self):
             '''KFontChooser.FontDiffFlags KFontChooser.FontDiffFlags.__invert__()'''
             return KFontChooser.FontDiffFlags()
         def __and__(self, mask):
             '''KFontChooser.FontDiffFlags KFontChooser.FontDiffFlags.__and__(int mask)'''
             return KFontChooser.FontDiffFlags()
         def __xor__(self, f):
             '''KFontChooser.FontDiffFlags KFontChooser.FontDiffFlags.__xor__(KFontChooser.FontDiffFlags f)'''
             return KFontChooser.FontDiffFlags()
         def __xor__(self, f):
             '''KFontChooser.FontDiffFlags KFontChooser.FontDiffFlags.__xor__(int f)'''
             return KFontChooser.FontDiffFlags()
         def __or__(self, f):
             '''KFontChooser.FontDiffFlags KFontChooser.FontDiffFlags.__or__(KFontChooser.FontDiffFlags f)'''
             return KFontChooser.FontDiffFlags()
         def __or__(self, f):
             '''KFontChooser.FontDiffFlags KFontChooser.FontDiffFlags.__or__(int f)'''
             return KFontChooser.FontDiffFlags()
         def __int__(self):
             '''int KFontChooser.FontDiffFlags.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KFontChooser.FontDiffFlags KFontChooser.FontDiffFlags.__ixor__(KFontChooser.FontDiffFlags f)'''
             return KFontChooser.FontDiffFlags()
         def __ior__(self, f):
             '''KFontChooser.FontDiffFlags KFontChooser.FontDiffFlags.__ior__(KFontChooser.FontDiffFlags f)'''
             return KFontChooser.FontDiffFlags()
         def __iand__(self, mask):
             '''KFontChooser.FontDiffFlags KFontChooser.FontDiffFlags.__iand__(int mask)'''
             return KFontChooser.FontDiffFlags()
 
 
 class KFontComboBox(KComboBox):
     """"""
     def __init__(self, parent = None):
         '''void KFontComboBox.__init__(QWidget parent = None)'''
     def event(self, e):
         '''bool KFontComboBox.event(QEvent e)'''
         return bool()
     currentFontChanged = pyqtSignal() # void currentFontChanged(const QFontamp;) - signal
     def setCurrentFont(self, font):
         '''void KFontComboBox.setCurrentFont(QFont font)'''
     def sizeHint(self):
         '''QSize KFontComboBox.sizeHint()'''
         return QSize()
     def currentFont(self):
         '''QFont KFontComboBox.currentFont()'''
         return QFont()
     def setOnlyFixed(self, onlyFixed):
         '''void KFontComboBox.setOnlyFixed(bool onlyFixed)'''
 
 
 class KFontDialog(KDialog):
     """"""
     def __init__(self, parent = None, flags = None, fontlist = QStringList(), sizeIsRelativeState = None):
         '''void KFontDialog.__init__(QWidget parent = None, KFontChooser.DisplayFlags flags = KFontChooser.NoDisplayFlags, QStringList fontlist = QStringList(), Qt.CheckState sizeIsRelativeState)'''
     fontSelected = pyqtSignal() # void fontSelected(const QFontamp;) - signal
     def getFontAndText(self, theFont, theString, flags = None, parent = None, sizeIsRelativeState = None):
         '''static tuple KFontDialog.getFontAndText(QFont theFont, QString theString, KFontChooser.DisplayFlags flags = KFontChooser.NoDisplayFlags, QWidget parent = None, Qt.CheckState sizeIsRelativeState = Qt.Unchecked)'''
         return tuple()
     def getFontDiff(self, theFont, diffFlags, flags = None, parent = None, sizeIsRelativeState = None):
         '''static tuple KFontDialog.getFontDiff(QFont theFont, KFontChooser.FontDiffFlags diffFlags, KFontChooser.DisplayFlags flags = KFontChooser.NoDisplayFlags, QWidget parent = None, Qt.CheckState sizeIsRelativeState = Qt.Unchecked)'''
         return tuple()
     def getFont(self, theFont, flags = None, parent = None, sizeIsRelativeState = None):
         '''static tuple KFontDialog.getFont(QFont theFont, KFontChooser.DisplayFlags flags = KFontChooser.NoDisplayFlags, QWidget parent = None, Qt.CheckState sizeIsRelativeState)'''
         return tuple()
     def sizeIsRelative(self):
         '''Qt.CheckState KFontDialog.sizeIsRelative()'''
         return Qt.CheckState()
     def setSizeIsRelative(self, relative):
         '''void KFontDialog.setSizeIsRelative(Qt.CheckState relative)'''
     def font(self):
         '''QFont KFontDialog.font()'''
         return QFont()
     def setFont(self, font, onlyFixed = False):
         '''void KFontDialog.setFont(QFont font, bool onlyFixed = False)'''
 
 
 class KFontRequester(QWidget):
     """"""
     def __init__(self, parent = None, onlyFixed = False):
         '''void KFontRequester.__init__(QWidget parent = None, bool onlyFixed = False)'''
     fontSelected = pyqtSignal() # void fontSelected(const QFontamp;) - signal
     def setTitle(self, title):
         '''void KFontRequester.setTitle(QString title)'''
     def setSampleText(self, text):
         '''void KFontRequester.setSampleText(QString text)'''
     def setFont(self, font, onlyFixed = False):
         '''void KFontRequester.setFont(QFont font, bool onlyFixed = False)'''
     def button(self):
         '''QPushButton KFontRequester.button()'''
         return QPushButton()
     def label(self):
         '''QLabel KFontRequester.label()'''
         return QLabel()
     def title(self):
         '''QString KFontRequester.title()'''
         return QString()
     def sampleText(self):
         '''QString KFontRequester.sampleText()'''
         return QString()
     def isFixedOnly(self):
         '''bool KFontRequester.isFixedOnly()'''
         return bool()
     def font(self):
         '''QFont KFontRequester.font()'''
         return QFont()
 
 
 class KFontSizeAction(KSelectAction):
     """"""
     def __init__(self, parent):
         '''void KFontSizeAction.__init__(QObject parent)'''
     def __init__(self, text, parent):
         '''void KFontSizeAction.__init__(QString text, QObject parent)'''
     def __init__(self, icon, text, parent):
         '''void KFontSizeAction.__init__(KIcon icon, QString text, QObject parent)'''
     def actionTriggered(self, action):
         '''void KFontSizeAction.actionTriggered(QAction action)'''
     fontSizeChanged = pyqtSignal() # void fontSizeChanged(int) - signal
     def setFontSize(self, size):
         '''void KFontSizeAction.setFontSize(int size)'''
     def fontSize(self):
         '''int KFontSizeAction.fontSize()'''
         return int()
 
 
 class KFontUtils():
     """"""
     # Enum KFontUtils.AdaptFontSizeOption
     NoFlags = 0
     DoNotAllowWordWrap = 0
 
     def adaptFontSize(self, painter, text, width, height, maxFontSize = 28, minFontSize = 1, flags = None):
         '''static float KFontUtils.adaptFontSize(QPainter painter, QString text, float width, float height, float maxFontSize = 28, float minFontSize = 1, KFontUtils.AdaptFontSizeOptions flags = KFontUtils.NoFlags)'''
         return float()
     def adaptFontSize(self, painter, text, availableSize, maxFontSize = 28, minFontSize = 1, flags = None):
         '''static float KFontUtils.adaptFontSize(QPainter painter, QString text, QSizeF availableSize, float maxFontSize = 28, float minFontSize = 1, KFontUtils.AdaptFontSizeOptions flags = KFontUtils.NoFlags)'''
         return float()
     class AdaptFontSizeOptions():
         """"""
         def __init__(self):
             '''KFontUtils.AdaptFontSizeOptions KFontUtils.AdaptFontSizeOptions.__init__()'''
             return KFontUtils.AdaptFontSizeOptions()
         def __init__(self):
             '''int KFontUtils.AdaptFontSizeOptions.__init__()'''
             return int()
         def __init__(self):
             '''void KFontUtils.AdaptFontSizeOptions.__init__()'''
         def __bool__(self):
             '''int KFontUtils.AdaptFontSizeOptions.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KFontUtils.AdaptFontSizeOptions.__ne__(KFontUtils.AdaptFontSizeOptions f)'''
             return bool()
         def __eq__(self, f):
             '''bool KFontUtils.AdaptFontSizeOptions.__eq__(KFontUtils.AdaptFontSizeOptions f)'''
             return bool()
         def __invert__(self):
             '''KFontUtils.AdaptFontSizeOptions KFontUtils.AdaptFontSizeOptions.__invert__()'''
             return KFontUtils.AdaptFontSizeOptions()
         def __and__(self, mask):
             '''KFontUtils.AdaptFontSizeOptions KFontUtils.AdaptFontSizeOptions.__and__(int mask)'''
             return KFontUtils.AdaptFontSizeOptions()
         def __xor__(self, f):
             '''KFontUtils.AdaptFontSizeOptions KFontUtils.AdaptFontSizeOptions.__xor__(KFontUtils.AdaptFontSizeOptions f)'''
             return KFontUtils.AdaptFontSizeOptions()
         def __xor__(self, f):
             '''KFontUtils.AdaptFontSizeOptions KFontUtils.AdaptFontSizeOptions.__xor__(int f)'''
             return KFontUtils.AdaptFontSizeOptions()
         def __or__(self, f):
             '''KFontUtils.AdaptFontSizeOptions KFontUtils.AdaptFontSizeOptions.__or__(KFontUtils.AdaptFontSizeOptions f)'''
             return KFontUtils.AdaptFontSizeOptions()
         def __or__(self, f):
             '''KFontUtils.AdaptFontSizeOptions KFontUtils.AdaptFontSizeOptions.__or__(int f)'''
             return KFontUtils.AdaptFontSizeOptions()
         def __int__(self):
             '''int KFontUtils.AdaptFontSizeOptions.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KFontUtils.AdaptFontSizeOptions KFontUtils.AdaptFontSizeOptions.__ixor__(KFontUtils.AdaptFontSizeOptions f)'''
             return KFontUtils.AdaptFontSizeOptions()
         def __ior__(self, f):
             '''KFontUtils.AdaptFontSizeOptions KFontUtils.AdaptFontSizeOptions.__ior__(KFontUtils.AdaptFontSizeOptions f)'''
             return KFontUtils.AdaptFontSizeOptions()
         def __iand__(self, mask):
             '''KFontUtils.AdaptFontSizeOptions KFontUtils.AdaptFontSizeOptions.__iand__(int mask)'''
             return KFontUtils.AdaptFontSizeOptions()
 
 
 class KShapeGesture():
     """"""
     def __init__(self):
         '''void KShapeGesture.__init__()'''
     def __init__(self, shape):
         '''void KShapeGesture.__init__(QPolygon shape)'''
     def __init__(self, description):
         '''void KShapeGesture.__init__(QString description)'''
     def __init__(self, other):
         '''void KShapeGesture.__init__(KShapeGesture other)'''
     def hashable(self):
         '''int KShapeGesture.hashable()'''
         return int()
     def __ne__(self, other):
         '''bool KShapeGesture.__ne__(KShapeGesture other)'''
         return bool()
     def __eq__(self, other):
         '''bool KShapeGesture.__eq__(KShapeGesture other)'''
         return bool()
     def distance(self, other, abortThreshold):
         '''float KShapeGesture.distance(KShapeGesture other, float abortThreshold)'''
         return float()
     def toSvg(self, attributes = QString()):
         '''QByteArray KShapeGesture.toSvg(QString attributes = QString())'''
         return QByteArray()
     def toString(self):
         '''QString KShapeGesture.toString()'''
         return QString()
     def isValid(self):
         '''bool KShapeGesture.isValid()'''
         return bool()
     def shapeName(self):
         '''QString KShapeGesture.shapeName()'''
         return QString()
     def setShapeName(self, friendlyName):
         '''void KShapeGesture.setShapeName(QString friendlyName)'''
     def setShape(self, shape):
         '''void KShapeGesture.setShape(QPolygon shape)'''
 
 
 class KRockerGesture():
     """"""
     def __init__(self):
         '''void KRockerGesture.__init__()'''
     def __init__(self, hold, thenPush):
         '''void KRockerGesture.__init__(Qt.MouseButton hold, Qt.MouseButton thenPush)'''
     def __init__(self, description):
         '''void KRockerGesture.__init__(QString description)'''
     def __init__(self, other):
         '''void KRockerGesture.__init__(KRockerGesture other)'''
     def hashable(self):
         '''int KRockerGesture.hashable()'''
         return int()
     def __ne__(self, other):
         '''bool KRockerGesture.__ne__(KRockerGesture other)'''
         return bool()
     def __eq__(self, other):
         '''bool KRockerGesture.__eq__(KRockerGesture other)'''
         return bool()
     def toString(self):
         '''QString KRockerGesture.toString()'''
         return QString()
     def isValid(self):
         '''bool KRockerGesture.isValid()'''
         return bool()
     def mouseButtonName(self, button):
         '''static QString KRockerGesture.mouseButtonName(Qt.MouseButton button)'''
         return QString()
     def rockerName(self):
         '''QString KRockerGesture.rockerName()'''
         return QString()
     def getButtons(self, hold, thenPush):
         '''void KRockerGesture.getButtons(Qt.MouseButton hold, Qt.MouseButton thenPush)'''
     def setButtons(self, hold, thenPush):
         '''void KRockerGesture.setButtons(Qt.MouseButton hold, Qt.MouseButton thenPush)'''
 
 
 class KGlobalAccel(QObject):
     """"""
     # Enum KGlobalAccel.actionIdFields
     ComponentUnique = 0
     ActionUnique = 0
     ComponentFriendly = 0
     ActionFriendly = 0
 
     def findActionNameSystemwide(self, seq):
         '''static QStringList KGlobalAccel.findActionNameSystemwide(QKeySequence seq)'''
         return QStringList()
     def allActionsForComponent(self, actionId):
         '''list-of-QStringList KGlobalAccel.allActionsForComponent(QStringList actionId)'''
         return [QStringList()]
     def allMainComponents(self):
         '''list-of-QStringList KGlobalAccel.allMainComponents()'''
         return [QStringList()]
     def overrideMainComponentData(self, componentData):
         '''void KGlobalAccel.overrideMainComponentData(KComponentData componentData)'''
     def setEnabled(self, enabled):
         '''void KGlobalAccel.setEnabled(bool enabled)'''
     def isEnabled(self):
         '''bool KGlobalAccel.isEnabled()'''
         return bool()
     def promptStealShortcutSystemwide(self, parent, shortcuts, seq):
         '''static bool KGlobalAccel.promptStealShortcutSystemwide(QWidget parent, list-of-KGlobalShortcutInfo shortcuts, QKeySequence seq)'''
         return bool()
     def promptStealShortcutSystemwide(self, parent, actionIdentifier, seq):
         '''static bool KGlobalAccel.promptStealShortcutSystemwide(QWidget parent, QStringList actionIdentifier, QKeySequence seq)'''
         return bool()
     def isGlobalShortcutAvailable(self, seq, component = QString()):
         '''static bool KGlobalAccel.isGlobalShortcutAvailable(QKeySequence seq, QString component = QString())'''
         return bool()
     def getGlobalShortcutsByKey(self, seq):
         '''static list-of-KGlobalShortcutInfo KGlobalAccel.getGlobalShortcutsByKey(QKeySequence seq)'''
         return [KGlobalShortcutInfo()]
     def isComponentActive(self, componentName):
         '''static bool KGlobalAccel.isComponentActive(QString componentName)'''
         return bool()
     def cleanComponent(self, componentUnique):
         '''static bool KGlobalAccel.cleanComponent(QString componentUnique)'''
         return bool()
     def activateGlobalShortcutContext(self, contextUnique, contextFriendly, component = None):
         '''static void KGlobalAccel.activateGlobalShortcutContext(QString contextUnique, QString contextFriendly, KComponentData component = KGlobal.mainComponent())'''
     def stealShortcutSystemwide(self, seq):
         '''static void KGlobalAccel.stealShortcutSystemwide(QKeySequence seq)'''
     def self(self):
         '''static KGlobalAccel KGlobalAccel.self()'''
         return KGlobalAccel()
 
 
 class KGlobalSettings(QObject):
     """"""
     # Enum KGlobalSettings.ActivateOption
     ApplySettings = 0
     ListenForChanges = 0
 
     # Enum KGlobalSettings.SettingsCategory
     SETTINGS_MOUSE = 0
     SETTINGS_COMPLETION = 0
     SETTINGS_PATHS = 0
     SETTINGS_POPUPMENU = 0
     SETTINGS_QT = 0
     SETTINGS_SHORTCUTS = 0
     SETTINGS_LOCALE = 0
     SETTINGS_STYLE = 0
 
     # Enum KGlobalSettings.ChangeType
     PaletteChanged = 0
     FontChanged = 0
     StyleChanged = 0
     SettingsChanged = 0
     IconChanged = 0
     CursorChanged = 0
     ToolbarStyleChanged = 0
     ClipboardConfigChanged = 0
     BlockShortcuts = 0
     NaturalSortingChanged = 0
 
     # Enum KGlobalSettings.GraphicEffect
     NoEffects = 0
     GradientEffects = 0
     SimpleAnimationEffects = 0
     ComplexAnimationEffects = 0
 
     # Enum KGlobalSettings.Completion
     CompletionNone = 0
     CompletionAuto = 0
     CompletionMan = 0
     CompletionShell = 0
     CompletionPopup = 0
     CompletionPopupAuto = 0
 
     # Enum KGlobalSettings.TearOffHandle
     Disable = 0
     ApplicationLevel = 0
     Enable = 0
 
     def createNewApplicationPalette(self, config = KSharedConfigPtr()):
         '''static QPalette KGlobalSettings.createNewApplicationPalette(KSharedConfigPtr config = KSharedConfigPtr())'''
         return QPalette()
     naturalSortingChanged = pyqtSignal() # void naturalSortingChanged() - signal
     def naturalSorting(self):
         '''static bool KGlobalSettings.naturalSorting()'''
         return bool()
     def activate(self):
         '''void KGlobalSettings.activate()'''
     def activate(self, options):
         '''void KGlobalSettings.activate(KGlobalSettings.ActivateOptions options)'''
     blockShortcuts = pyqtSignal() # void blockShortcuts(int) - signal
     cursorChanged = pyqtSignal() # void cursorChanged() - signal
     iconChanged = pyqtSignal() # void iconChanged(int) - signal
     settingsChanged = pyqtSignal() # void settingsChanged(int) - signal
     toolbarAppearanceChanged = pyqtSignal() # void toolbarAppearanceChanged(int) - signal
     appearanceChanged = pyqtSignal() # void appearanceChanged() - signal
     kdisplayFontChanged = pyqtSignal() # void kdisplayFontChanged() - signal
     kdisplayStyleChanged = pyqtSignal() # void kdisplayStyleChanged() - signal
     kdisplayPaletteChanged = pyqtSignal() # void kdisplayPaletteChanged() - signal
     def self(self):
         '''static KGlobalSettings KGlobalSettings.self()'''
         return KGlobalSettings()
     def emitChange(self, changeType, arg = 0):
         '''static void KGlobalSettings.emitChange(KGlobalSettings.ChangeType changeType, int arg = 0)'''
     def createApplicationPalette(self, config = KSharedConfigPtr()):
         '''static QPalette KGlobalSettings.createApplicationPalette(KSharedConfigPtr config = KSharedConfigPtr())'''
         return QPalette()
     def buttonLayout(self):
         '''static int KGlobalSettings.buttonLayout()'''
         return int()
     def opaqueResize(self):
         '''static bool KGlobalSettings.opaqueResize()'''
         return bool()
     def showFilePreview(self):
         '''static KUrl KGlobalSettings.showFilePreview()'''
         return KUrl()
     def graphicEffectsLevelDefault(self):
         '''static KGlobalSettings.GraphicEffects KGlobalSettings.graphicEffectsLevelDefault()'''
         return KGlobalSettings.GraphicEffects()
     def graphicEffectsLevel(self):
         '''static KGlobalSettings.GraphicEffects KGlobalSettings.graphicEffectsLevel()'''
         return KGlobalSettings.GraphicEffects()
     def showIconsOnPushButtons(self):
         '''static bool KGlobalSettings.showIconsOnPushButtons()'''
         return bool()
     def desktopGeometry(self, point):
         '''static QRect KGlobalSettings.desktopGeometry(QPoint point)'''
         return QRect()
     def desktopGeometry(self, w):
         '''static QRect KGlobalSettings.desktopGeometry(QWidget w)'''
         return QRect()
     def splashScreenDesktopGeometry(self):
         '''static QRect KGlobalSettings.splashScreenDesktopGeometry()'''
         return QRect()
     def wheelMouseZooms(self):
         '''static bool KGlobalSettings.wheelMouseZooms()'''
         return bool()
     def isMultiHead(self):
         '''static bool KGlobalSettings.isMultiHead()'''
         return bool()
     def smallestReadableFont(self):
         '''static QFont KGlobalSettings.smallestReadableFont()'''
         return QFont()
     def largeFont(self, text = QString()):
         '''static QFont KGlobalSettings.largeFont(QString text = QString())'''
         return QFont()
     def taskbarFont(self):
         '''static QFont KGlobalSettings.taskbarFont()'''
         return QFont()
     def windowTitleFont(self):
         '''static QFont KGlobalSettings.windowTitleFont()'''
         return QFont()
     def menuFont(self):
         '''static QFont KGlobalSettings.menuFont()'''
         return QFont()
     def toolBarFont(self):
         '''static QFont KGlobalSettings.toolBarFont()'''
         return QFont()
     def fixedFont(self):
         '''static QFont KGlobalSettings.fixedFont()'''
         return QFont()
     def generalFont(self):
         '''static QFont KGlobalSettings.generalFont()'''
         return QFont()
     def allowDefaultBackgroundImages(self):
         '''static bool KGlobalSettings.allowDefaultBackgroundImages()'''
         return bool()
     def shadeSortColumn(self):
         '''static bool KGlobalSettings.shadeSortColumn()'''
         return bool()
     def contrastF(self, config = KSharedConfigPtr()):
         '''static float KGlobalSettings.contrastF(KSharedConfigPtr config = KSharedConfigPtr())'''
         return float()
     def contrast(self):
         '''static int KGlobalSettings.contrast()'''
         return int()
     def activeTextColor(self):
         '''static QColor KGlobalSettings.activeTextColor()'''
         return QColor()
     def activeTitleColor(self):
         '''static QColor KGlobalSettings.activeTitleColor()'''
         return QColor()
     def inactiveTextColor(self):
         '''static QColor KGlobalSettings.inactiveTextColor()'''
         return QColor()
     def inactiveTitleColor(self):
         '''static QColor KGlobalSettings.inactiveTitleColor()'''
         return QColor()
     def picturesPath(self):
         '''static QString KGlobalSettings.picturesPath()'''
         return QString()
     def downloadPath(self):
         '''static QString KGlobalSettings.downloadPath()'''
         return QString()
     def videosPath(self):
         '''static QString KGlobalSettings.videosPath()'''
         return QString()
     def musicPath(self):
         '''static QString KGlobalSettings.musicPath()'''
         return QString()
     def documentPath(self):
         '''static QString KGlobalSettings.documentPath()'''
         return QString()
     def autostartPath(self):
         '''static QString KGlobalSettings.autostartPath()'''
         return QString()
     def desktopPath(self):
         '''static QString KGlobalSettings.desktopPath()'''
         return QString()
     def mouseSettings(self):
         '''static KGlobalSettings.KMouseSettings KGlobalSettings.mouseSettings()'''
         return KGlobalSettings.KMouseSettings()
     def completionMode(self):
         '''static KGlobalSettings.Completion KGlobalSettings.completionMode()'''
         return KGlobalSettings.Completion()
     def showContextMenusOnPress(self):
         '''static bool KGlobalSettings.showContextMenusOnPress()'''
         return bool()
     def contextMenuKey(self):
         '''static int KGlobalSettings.contextMenuKey()'''
         return int()
     def autoSelectDelay(self):
         '''static int KGlobalSettings.autoSelectDelay()'''
         return int()
     def changeCursorOverIcon(self):
         '''static bool KGlobalSettings.changeCursorOverIcon()'''
         return bool()
     def insertTearOffHandle(self):
         '''static KGlobalSettings.TearOffHandle KGlobalSettings.insertTearOffHandle()'''
         return KGlobalSettings.TearOffHandle()
     def smoothScroll(self):
         '''static bool KGlobalSettings.smoothScroll()'''
         return bool()
     def singleClick(self):
         '''static bool KGlobalSettings.singleClick()'''
         return bool()
     def dndEventDelay(self):
         '''static int KGlobalSettings.dndEventDelay()'''
         return int()
     class GraphicEffects():
         """"""
         def __init__(self):
             '''KGlobalSettings.GraphicEffects KGlobalSettings.GraphicEffects.__init__()'''
             return KGlobalSettings.GraphicEffects()
         def __init__(self):
             '''int KGlobalSettings.GraphicEffects.__init__()'''
             return int()
         def __init__(self):
             '''void KGlobalSettings.GraphicEffects.__init__()'''
         def __bool__(self):
             '''int KGlobalSettings.GraphicEffects.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KGlobalSettings.GraphicEffects.__ne__(KGlobalSettings.GraphicEffects f)'''
             return bool()
         def __eq__(self, f):
             '''bool KGlobalSettings.GraphicEffects.__eq__(KGlobalSettings.GraphicEffects f)'''
             return bool()
         def __invert__(self):
             '''KGlobalSettings.GraphicEffects KGlobalSettings.GraphicEffects.__invert__()'''
             return KGlobalSettings.GraphicEffects()
         def __and__(self, mask):
             '''KGlobalSettings.GraphicEffects KGlobalSettings.GraphicEffects.__and__(int mask)'''
             return KGlobalSettings.GraphicEffects()
         def __xor__(self, f):
             '''KGlobalSettings.GraphicEffects KGlobalSettings.GraphicEffects.__xor__(KGlobalSettings.GraphicEffects f)'''
             return KGlobalSettings.GraphicEffects()
         def __xor__(self, f):
             '''KGlobalSettings.GraphicEffects KGlobalSettings.GraphicEffects.__xor__(int f)'''
             return KGlobalSettings.GraphicEffects()
         def __or__(self, f):
             '''KGlobalSettings.GraphicEffects KGlobalSettings.GraphicEffects.__or__(KGlobalSettings.GraphicEffects f)'''
             return KGlobalSettings.GraphicEffects()
         def __or__(self, f):
             '''KGlobalSettings.GraphicEffects KGlobalSettings.GraphicEffects.__or__(int f)'''
             return KGlobalSettings.GraphicEffects()
         def __int__(self):
             '''int KGlobalSettings.GraphicEffects.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KGlobalSettings.GraphicEffects KGlobalSettings.GraphicEffects.__ixor__(KGlobalSettings.GraphicEffects f)'''
             return KGlobalSettings.GraphicEffects()
         def __ior__(self, f):
             '''KGlobalSettings.GraphicEffects KGlobalSettings.GraphicEffects.__ior__(KGlobalSettings.GraphicEffects f)'''
             return KGlobalSettings.GraphicEffects()
         def __iand__(self, mask):
             '''KGlobalSettings.GraphicEffects KGlobalSettings.GraphicEffects.__iand__(int mask)'''
             return KGlobalSettings.GraphicEffects()
     class ActivateOptions():
         """"""
         def __init__(self):
             '''KGlobalSettings.ActivateOptions KGlobalSettings.ActivateOptions.__init__()'''
             return KGlobalSettings.ActivateOptions()
         def __init__(self):
             '''int KGlobalSettings.ActivateOptions.__init__()'''
             return int()
         def __init__(self):
             '''void KGlobalSettings.ActivateOptions.__init__()'''
         def __bool__(self):
             '''int KGlobalSettings.ActivateOptions.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KGlobalSettings.ActivateOptions.__ne__(KGlobalSettings.ActivateOptions f)'''
             return bool()
         def __eq__(self, f):
             '''bool KGlobalSettings.ActivateOptions.__eq__(KGlobalSettings.ActivateOptions f)'''
             return bool()
         def __invert__(self):
             '''KGlobalSettings.ActivateOptions KGlobalSettings.ActivateOptions.__invert__()'''
             return KGlobalSettings.ActivateOptions()
         def __and__(self, mask):
             '''KGlobalSettings.ActivateOptions KGlobalSettings.ActivateOptions.__and__(int mask)'''
             return KGlobalSettings.ActivateOptions()
         def __xor__(self, f):
             '''KGlobalSettings.ActivateOptions KGlobalSettings.ActivateOptions.__xor__(KGlobalSettings.ActivateOptions f)'''
             return KGlobalSettings.ActivateOptions()
         def __xor__(self, f):
             '''KGlobalSettings.ActivateOptions KGlobalSettings.ActivateOptions.__xor__(int f)'''
             return KGlobalSettings.ActivateOptions()
         def __or__(self, f):
             '''KGlobalSettings.ActivateOptions KGlobalSettings.ActivateOptions.__or__(KGlobalSettings.ActivateOptions f)'''
             return KGlobalSettings.ActivateOptions()
         def __or__(self, f):
             '''KGlobalSettings.ActivateOptions KGlobalSettings.ActivateOptions.__or__(int f)'''
             return KGlobalSettings.ActivateOptions()
         def __int__(self):
             '''int KGlobalSettings.ActivateOptions.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KGlobalSettings.ActivateOptions KGlobalSettings.ActivateOptions.__ixor__(KGlobalSettings.ActivateOptions f)'''
             return KGlobalSettings.ActivateOptions()
         def __ior__(self, f):
             '''KGlobalSettings.ActivateOptions KGlobalSettings.ActivateOptions.__ior__(KGlobalSettings.ActivateOptions f)'''
             return KGlobalSettings.ActivateOptions()
         def __iand__(self, mask):
             '''KGlobalSettings.ActivateOptions KGlobalSettings.ActivateOptions.__iand__(int mask)'''
             return KGlobalSettings.ActivateOptions()
     class KMouseSettings():
         """"""
         RightHanded = None # int - member
         LeftHanded = None # int - member
         handed = None # int - member
         def __init__(self):
             '''void KGlobalSettings.KMouseSettings.__init__()'''
         def __init__(self):
             '''KGlobalSettings.KMouseSettings KGlobalSettings.KMouseSettings.__init__()'''
             return KGlobalSettings.KMouseSettings()
 
 
 class KGlobalShortcutInfo(QObject):
     """"""
     def __init__(self):
         '''void KGlobalShortcutInfo.__init__()'''
     def __init__(self, rhs):
         '''void KGlobalShortcutInfo.__init__(KGlobalShortcutInfo rhs)'''
     def uniqueName(self):
         '''QString KGlobalShortcutInfo.uniqueName()'''
         return QString()
     def keys(self):
         '''list-of-QKeySequence KGlobalShortcutInfo.keys()'''
         return [QKeySequence()]
     def friendlyName(self):
         '''QString KGlobalShortcutInfo.friendlyName()'''
         return QString()
     def defaultKeys(self):
         '''list-of-QKeySequence KGlobalShortcutInfo.defaultKeys()'''
         return [QKeySequence()]
     def componentUniqueName(self):
         '''QString KGlobalShortcutInfo.componentUniqueName()'''
         return QString()
     def componentFriendlyName(self):
         '''QString KGlobalShortcutInfo.componentFriendlyName()'''
         return QString()
     def contextUniqueName(self):
         '''QString KGlobalShortcutInfo.contextUniqueName()'''
         return QString()
     def contextFriendlyName(self):
         '''QString KGlobalShortcutInfo.contextFriendlyName()'''
         return QString()
 
 
 class KGuiItem():
     """"""
     def __init__(self):
         '''void KGuiItem.__init__()'''
     def __init__(self, text, iconName = QString(), toolTip = QString(), whatsThis = QString()):
         '''void KGuiItem.__init__(QString text, QString iconName = QString(), QString toolTip = QString(), QString whatsThis = QString())'''
     def __init__(self, text, icon, toolTip = QString(), whatsThis = QString()):
         '''void KGuiItem.__init__(QString text, KIcon icon, QString toolTip = QString(), QString whatsThis = QString())'''
     def __init__(self, rhs):
         '''void KGuiItem.__init__(KGuiItem rhs)'''
     def setEnabled(self, enable):
         '''void KGuiItem.setEnabled(bool enable)'''
     def setWhatsThis(self, whatsThis):
         '''void KGuiItem.setWhatsThis(QString whatsThis)'''
     def setToolTip(self, tooltip):
         '''void KGuiItem.setToolTip(QString tooltip)'''
     def setIconName(self, iconName):
         '''void KGuiItem.setIconName(QString iconName)'''
     def setIcon(self, iconset):
         '''void KGuiItem.setIcon(KIcon iconset)'''
     def setText(self, text):
         '''void KGuiItem.setText(QString text)'''
     def hasIconSet(self):
         '''bool KGuiItem.hasIconSet()'''
         return bool()
     def hasIcon(self):
         '''bool KGuiItem.hasIcon()'''
         return bool()
     def isEnabled(self):
         '''bool KGuiItem.isEnabled()'''
         return bool()
     def whatsThis(self):
         '''QString KGuiItem.whatsThis()'''
         return QString()
     def toolTip(self):
         '''QString KGuiItem.toolTip()'''
         return QString()
     def iconName(self):
         '''QString KGuiItem.iconName()'''
         return QString()
     def icon(self):
         '''KIcon KGuiItem.icon()'''
         return KIcon()
     def plainText(self):
         '''QString KGuiItem.plainText()'''
         return QString()
     def text(self):
         '''QString KGuiItem.text()'''
         return QString()
 
 
 class KHBox(QFrame):
     """"""
     def __init__(self, parent = None):
         '''void KHBox.__init__(QWidget parent = None)'''
     def __init__(self, vertical, parent):
         '''void KHBox.__init__(bool vertical, QWidget parent)'''
     def childEvent(self, ev):
         '''void KHBox.childEvent(QChildEvent ev)'''
     def minimumSizeHint(self):
         '''QSize KHBox.minimumSizeHint()'''
         return QSize()
     def sizeHint(self):
         '''QSize KHBox.sizeHint()'''
         return QSize()
     def setStretchFactor(self, widget, stretch):
         '''void KHBox.setStretchFactor(QWidget widget, int stretch)'''
     def setSpacing(self, space):
         '''void KHBox.setSpacing(int space)'''
     def setMargin(self, margin):
         '''void KHBox.setMargin(int margin)'''
 
 
 class KHelpMenu(QObject):
     """"""
     # Enum KHelpMenu.MenuId
     menuHelpContents = 0
     menuWhatsThis = 0
     menuAboutApp = 0
     menuAboutKDE = 0
     menuReportBug = 0
     menuSwitchLanguage = 0
 
     def __init__(self, parent = None, aboutAppText = QString(), showWhatsThis = True):
         '''void KHelpMenu.__init__(QWidget parent = None, QString aboutAppText = QString(), bool showWhatsThis = True)'''
     def __init__(self, parent, aboutData, showWhatsThis = True, actions = None):
         '''void KHelpMenu.__init__(QWidget parent, KAboutData aboutData, bool showWhatsThis = True, KActionCollection actions = None)'''
     showAboutApplication = pyqtSignal() # void showAboutApplication() - signal
     def switchApplicationLanguage(self):
         '''void KHelpMenu.switchApplicationLanguage()'''
     def reportBug(self):
         '''void KHelpMenu.reportBug()'''
     def aboutKDE(self):
         '''void KHelpMenu.aboutKDE()'''
     def aboutApplication(self):
         '''void KHelpMenu.aboutApplication()'''
     def contextHelpActivated(self):
         '''void KHelpMenu.contextHelpActivated()'''
     def appHelpActivated(self):
         '''void KHelpMenu.appHelpActivated()'''
     def action(self, id):
         '''QAction KHelpMenu.action(KHelpMenu.MenuId id)'''
         return QAction()
     def menu(self):
         '''KMenu KHelpMenu.menu()'''
         return KMenu()
 
 
 class KHistoryComboBox(KComboBox):
     """"""
     def __init__(self, parent = None):
         '''void KHistoryComboBox.__init__(QWidget parent = None)'''
     def __init__(self, useCompletion, parent = None):
         '''void KHistoryComboBox.__init__(bool useCompletion, QWidget parent = None)'''
     def useCompletion(self):
         '''bool KHistoryComboBox.useCompletion()'''
         return bool()
     def insertItems(self, items):
         '''void KHistoryComboBox.insertItems(QStringList items)'''
     def wheelEvent(self, ev):
         '''void KHistoryComboBox.wheelEvent(QWheelEvent ev)'''
     def keyPressEvent(self):
         '''QKeyEvent KHistoryComboBox.keyPressEvent()'''
         return QKeyEvent()
     cleared = pyqtSignal() # void cleared() - signal
     def clearHistory(self):
         '''void KHistoryComboBox.clearHistory()'''
     def addToHistory(self, item):
         '''void KHistoryComboBox.addToHistory(QString item)'''
     def reset(self):
         '''void KHistoryComboBox.reset()'''
     def pixmapProvider(self):
         '''KPixmapProvider KHistoryComboBox.pixmapProvider()'''
         return KPixmapProvider()
     def setPixmapProvider(self, prov):
         '''void KHistoryComboBox.setPixmapProvider(KPixmapProvider prov)'''
     def removeFromHistory(self, item):
         '''bool KHistoryComboBox.removeFromHistory(QString item)'''
         return bool()
     def historyItems(self):
         '''QStringList KHistoryComboBox.historyItems()'''
         return QStringList()
     def setHistoryItems(self, items):
         '''void KHistoryComboBox.setHistoryItems(QStringList items)'''
     def setHistoryItems(self, items, setCompletionList):
         '''void KHistoryComboBox.setHistoryItems(QStringList items, bool setCompletionList)'''
 
 
 class KXYSelector(QWidget):
     """"""
     def __init__(self, parent = None):
         '''void KXYSelector.__init__(QWidget parent = None)'''
     def valuesFromPosition(self, x, y, xVal, yVal):
         '''void KXYSelector.valuesFromPosition(int x, int y, int xVal, int yVal)'''
     def wheelEvent(self):
         '''QWheelEvent KXYSelector.wheelEvent()'''
         return QWheelEvent()
     def mouseMoveEvent(self, e):
         '''void KXYSelector.mouseMoveEvent(QMouseEvent e)'''
     def mousePressEvent(self, e):
         '''void KXYSelector.mousePressEvent(QMouseEvent e)'''
     def paintEvent(self, e):
         '''void KXYSelector.paintEvent(QPaintEvent e)'''
     def drawMarker(self, p, xp, yp):
         '''void KXYSelector.drawMarker(QPainter p, int xp, int yp)'''
     def drawContents(self):
         '''QPainter KXYSelector.drawContents()'''
         return QPainter()
     valueChanged = pyqtSignal() # void valueChanged(int,int) - signal
     def minimumSizeHint(self):
         '''QSize KXYSelector.minimumSizeHint()'''
         return QSize()
     def contentsRect(self):
         '''QRect KXYSelector.contentsRect()'''
         return QRect()
     def yValue(self):
         '''int KXYSelector.yValue()'''
         return int()
     def xValue(self):
         '''int KXYSelector.xValue()'''
         return int()
     def setMarkerColor(self, col):
         '''void KXYSelector.setMarkerColor(QColor col)'''
     def setRange(self, minX, minY, maxX, maxY):
         '''void KXYSelector.setRange(int minX, int minY, int maxX, int maxY)'''
     def setYValue(self, yPos):
         '''void KXYSelector.setYValue(int yPos)'''
     def setXValue(self, xPos):
         '''void KXYSelector.setXValue(int xPos)'''
     def setValues(self, xPos, yPos):
         '''void KXYSelector.setValues(int xPos, int yPos)'''
 
 
 class KHueSaturationSelector(KXYSelector):
     """"""
     def __init__(self, parent = None):
         '''void KHueSaturationSelector.__init__(QWidget parent = None)'''
     def drawContents(self, painter):
         '''void KHueSaturationSelector.drawContents(QPainter painter)'''
     def resizeEvent(self):
         '''QResizeEvent KHueSaturationSelector.resizeEvent()'''
         return QResizeEvent()
     def drawPalette(self, pixmap):
         '''void KHueSaturationSelector.drawPalette(QPixmap pixmap)'''
     def updateContents(self):
         '''void KHueSaturationSelector.updateContents()'''
     def setColorValue(self, colorValue):
         '''void KHueSaturationSelector.setColorValue(int colorValue)'''
     def colorValue(self):
         '''int KHueSaturationSelector.colorValue()'''
         return int()
     def setSaturation(self, saturation):
         '''void KHueSaturationSelector.setSaturation(int saturation)'''
     def saturation(self):
         '''int KHueSaturationSelector.saturation()'''
         return int()
     def setHue(self, hue):
         '''void KHueSaturationSelector.setHue(int hue)'''
     def hue(self):
         '''int KHueSaturationSelector.hue()'''
         return int()
     def chooserMode(self):
         '''KColorChooserMode KHueSaturationSelector.chooserMode()'''
         return KColorChooserMode()
     def setChooserMode(self, chooserMode):
         '''void KHueSaturationSelector.setChooserMode(KColorChooserMode chooserMode)'''
 
 
 class KIcon(QIcon):
     """"""
     def __init__(self, iconName, iconLoader, overlays):
         '''void KIcon.__init__(QString iconName, KIconLoader iconLoader, QStringList overlays)'''
     def __init__(self, iconName, iconLoader):
         '''void KIcon.__init__(QString iconName, KIconLoader iconLoader)'''
     def __init__(self, iconName):
         '''void KIcon.__init__(QString iconName)'''
     def __init__(self, copy):
         '''void KIcon.__init__(QIcon copy)'''
     def __init__(self):
         '''void KIcon.__init__()'''
     def __init__(self):
         '''KIcon KIcon.__init__()'''
         return KIcon()
 
 
 class KPixmapCache():
     """"""
     # Enum KPixmapCache.RemoveStrategy
     RemoveOldest = 0
     RemoveSeldomUsed = 0
     RemoveLeastRecentlyUsed = 0
 
     def __init__(self, name):
         '''void KPixmapCache.__init__(QString name)'''
     def recreateCacheFiles(self):
         '''bool KPixmapCache.recreateCacheFiles()'''
         return bool()
     def setValid(self, valid):
         '''void KPixmapCache.setValid(bool valid)'''
     def writeCustomIndexHeader(self, stream):
         '''void KPixmapCache.writeCustomIndexHeader(QDataStream stream)'''
     def loadCustomIndexHeader(self, stream):
         '''bool KPixmapCache.loadCustomIndexHeader(QDataStream stream)'''
         return bool()
     def writeCustomData(self, stream):
         '''bool KPixmapCache.writeCustomData(QDataStream stream)'''
         return bool()
     def loadCustomData(self, stream):
         '''bool KPixmapCache.loadCustomData(QDataStream stream)'''
         return bool()
     def ensureInited(self):
         '''void KPixmapCache.ensureInited()'''
     def removeEntries(self, newsize = 0):
         '''void KPixmapCache.removeEntries(int newsize = 0)'''
     def discard(self):
         '''void KPixmapCache.discard()'''
     def deleteCache(self, name):
         '''static void KPixmapCache.deleteCache(QString name)'''
     def isValid(self):
         '''bool KPixmapCache.isValid()'''
         return bool()
     def isEnabled(self):
         '''bool KPixmapCache.isEnabled()'''
         return bool()
     def setRemoveEntryStrategy(self, strategy):
         '''void KPixmapCache.setRemoveEntryStrategy(KPixmapCache.RemoveStrategy strategy)'''
     def removeEntryStrategy(self):
         '''KPixmapCache.RemoveStrategy KPixmapCache.removeEntryStrategy()'''
         return KPixmapCache.RemoveStrategy()
     def setCacheLimit(self, kbytes):
         '''void KPixmapCache.setCacheLimit(int kbytes)'''
     def cacheLimit(self):
         '''int KPixmapCache.cacheLimit()'''
         return int()
     def size(self):
         '''int KPixmapCache.size()'''
         return int()
     def useQPixmapCache(self):
         '''bool KPixmapCache.useQPixmapCache()'''
         return bool()
     def setUseQPixmapCache(self, use):
         '''void KPixmapCache.setUseQPixmapCache(bool use)'''
     def setTimestamp(self, time):
         '''void KPixmapCache.setTimestamp(int time)'''
     def timestamp(self):
         '''int KPixmapCache.timestamp()'''
         return int()
     def loadFromSvg(self, filename, size = QSize()):
         '''QPixmap KPixmapCache.loadFromSvg(QString filename, QSize size = QSize())'''
         return QPixmap()
     def loadFromFile(self, filename):
         '''QPixmap KPixmapCache.loadFromFile(QString filename)'''
         return QPixmap()
     def insert(self, key, pix):
         '''void KPixmapCache.insert(QString key, QPixmap pix)'''
     def find(self, key, pix):
         '''bool KPixmapCache.find(QString key, QPixmap pix)'''
         return bool()
 
 
 class KIconCache(KPixmapCache):
     """"""
     def __init__(self):
         '''void KIconCache.__init__()'''
     def mostRecentMTime(self, dirNames):
         '''int KIconCache.mostRecentMTime(list-of-QString dirNames)'''
         return int()
     def existingIconThemeDirs(self, themeNames):
         '''list-of-QString KIconCache.existingIconThemeDirs(QStringList themeNames)'''
         return [QString()]
     def writeCustomData(self, stream):
         '''bool KIconCache.writeCustomData(QDataStream stream)'''
         return bool()
     def loadCustomData(self, stream):
         '''bool KIconCache.loadCustomData(QDataStream stream)'''
         return bool()
     def writeCustomIndexHeader(self, stream):
         '''void KIconCache.writeCustomIndexHeader(QDataStream stream)'''
     def loadCustomIndexHeader(self, stream):
         '''bool KIconCache.loadCustomIndexHeader(QDataStream stream)'''
         return bool()
     def setThemeInfo(self, themes):
         '''void KIconCache.setThemeInfo(list-of-KIconTheme themes)'''
     def defaultIconSize(self, group):
         '''int KIconCache.defaultIconSize(KIconLoader.Group group)'''
         return int()
     def deleteCache(self):
         '''static void KIconCache.deleteCache()'''
     def insert(self, key, pix, path):
         '''void KIconCache.insert(QString key, QPixmap pix, QString path)'''
     def insert(self, key, pix):
         '''void KIconCache.insert(QString key, QPixmap pix)'''
     def find(self, key, pix, path):
         '''bool KIconCache.find(QString key, QPixmap pix, QString path)'''
         return bool()
     def find(self, key, pix):
         '''bool KIconCache.find(QString key, QPixmap pix)'''
         return bool()
 
 
 class KIconEffect():
     """"""
     # Enum KIconEffect.Effects
     NoEffect = 0
     ToGray = 0
     Colorize = 0
     ToGamma = 0
     DeSaturate = 0
     ToMonochrome = 0
     LastEffect = 0
 
     def __init__(self):
         '''void KIconEffect.__init__()'''
     def overlay(self, src, overlay):
         '''static void KIconEffect.overlay(QImage src, QImage overlay)'''
     def semiTransparent(self, image):
         '''static void KIconEffect.semiTransparent(QImage image)'''
     def semiTransparent(self, pixmap):
         '''static void KIconEffect.semiTransparent(QPixmap pixmap)'''
     def toGamma(self, image, value):
         '''static void KIconEffect.toGamma(QImage image, float value)'''
     def deSaturate(self, image, value):
         '''static void KIconEffect.deSaturate(QImage image, float value)'''
     def toMonochrome(self, image, black, white, value):
         '''static void KIconEffect.toMonochrome(QImage image, QColor black, QColor white, float value)'''
     def colorize(self, image, col, value):
         '''static void KIconEffect.colorize(QImage image, QColor col, float value)'''
     def toGray(self, image, value):
         '''static void KIconEffect.toGray(QImage image, float value)'''
     def doublePixels(self, src):
         '''QImage KIconEffect.doublePixels(QImage src)'''
         return QImage()
     def apply(self, src, group, state):
         '''QImage KIconEffect.apply(QImage src, int group, int state)'''
         return QImage()
     def apply(self, src, effect, value, rgb, trans):
         '''QImage KIconEffect.apply(QImage src, int effect, float value, QColor rgb, bool trans)'''
         return QImage()
     def apply(self, src, effect, value, rgb, rgb2, trans):
         '''QImage KIconEffect.apply(QImage src, int effect, float value, QColor rgb, QColor rgb2, bool trans)'''
         return QImage()
     def apply(self, src, group, state):
         '''QPixmap KIconEffect.apply(QPixmap src, int group, int state)'''
         return QPixmap()
     def apply(self, src, effect, value, rgb, trans):
         '''QPixmap KIconEffect.apply(QPixmap src, int effect, float value, QColor rgb, bool trans)'''
         return QPixmap()
     def apply(self, src, effect, value, rgb, rgb2, trans):
         '''QPixmap KIconEffect.apply(QPixmap src, int effect, float value, QColor rgb, QColor rgb2, bool trans)'''
         return QPixmap()
     def fingerprint(self, group, state):
         '''QString KIconEffect.fingerprint(int group, int state)'''
         return QString()
     def hasEffect(self, group, state):
         '''bool KIconEffect.hasEffect(int group, int state)'''
         return bool()
     def init(self):
         '''void KIconEffect.init()'''
 
 
 class KIconLoader(QObject):
     """"""
     # Enum KIconLoader.States
     DefaultState = 0
     ActiveState = 0
     DisabledState = 0
     LastState = 0
 
     # Enum KIconLoader.StdSizes
     SizeSmall = 0
     SizeSmallMedium = 0
     SizeMedium = 0
     SizeLarge = 0
     SizeHuge = 0
     SizeEnormous = 0
 
     # Enum KIconLoader.Group
     NoGroup = 0
     Desktop = 0
     FirstGroup = 0
     Toolbar = 0
     MainToolbar = 0
     Small = 0
     Panel = 0
     Dialog = 0
     LastGroup = 0
     User = 0
 
     # Enum KIconLoader.MatchType
     MatchExact = 0
     MatchBest = 0
 
     # Enum KIconLoader.Type
     Fixed = 0
     Scalable = 0
     Threshold = 0
 
     # Enum KIconLoader.Context
     Any = 0
     Action = 0
     Application = 0
     Device = 0
     FileSystem = 0
     MimeType = 0
     Animation = 0
     Category = 0
     Emblem = 0
     Emote = 0
     International = 0
     Place = 0
     StatusIcon = 0
 
     def __init__(self, appname = QString(), dirs = None, parent = None):
         '''void KIconLoader.__init__(QString appname = QString(), KStandardDirs dirs = None, QObject parent = None)'''
     def __init__(self, componentData, parent = None):
         '''void KIconLoader.__init__(KComponentData componentData, QObject parent = None)'''
     def drawOverlays(self, overlays, pixmap, group, state = None):
         '''void KIconLoader.drawOverlays(QStringList overlays, QPixmap pixmap, KIconLoader.Group group, int state = KIconLoader.DefaultState)'''
     iconLoaderSettingsChanged = pyqtSignal() # void iconLoaderSettingsChanged() - signal
     def newIconLoader(self):
         '''void KIconLoader.newIconLoader()'''
     def extraDesktopThemesAdded(self):
         '''bool KIconLoader.extraDesktopThemesAdded()'''
         return bool()
     def addExtraDesktopThemes(self):
         '''void KIconLoader.addExtraDesktopThemes()'''
     def unknown(self):
         '''static QPixmap KIconLoader.unknown()'''
         return QPixmap()
     def reconfigure(self, _appname, _dirs):
         '''void KIconLoader.reconfigure(QString _appname, KStandardDirs _dirs)'''
     def iconEffect(self):
         '''KIconEffect KIconLoader.iconEffect()'''
         return KIconEffect()
     def theme(self):
         '''KIconTheme KIconLoader.theme()'''
         return KIconTheme()
     def queryIconsByDir(self, iconsDir):
         '''QStringList KIconLoader.queryIconsByDir(QString iconsDir)'''
         return QStringList()
     def iconPath(self, name, group_or_size, canReturnNull = False):
         '''QString KIconLoader.iconPath(QString name, int group_or_size, bool canReturnNull = False)'''
         return QString()
     def loadMimeTypeIcon(self, iconName, group, size = 0, state = None, overlays = QStringList(), path_store = None):
         '''QPixmap KIconLoader.loadMimeTypeIcon(QString iconName, KIconLoader.Group group, int size = 0, int state = KIconLoader.DefaultState, QStringList overlays = QStringList(), QString path_store = None)'''
         return QPixmap()
     def loadIcon(self, name, group, size = 0, state = None, overlays = QStringList(), path_store = None, canReturnNull = False):
         '''QPixmap KIconLoader.loadIcon(QString name, KIconLoader.Group group, int size = 0, int state = KIconLoader.DefaultState, QStringList overlays = QStringList(), QString path_store = None, bool canReturnNull = False)'''
         return QPixmap()
     def addAppDir(self, appname):
         '''void KIconLoader.addAppDir(QString appname)'''
     def global_(self):
         '''static KIconLoader KIconLoader.global_()'''
         return KIconLoader()
 
 
 class KIconTheme():
     """"""
     # Enum KIconTheme.ContextMenus
     TextEditor = 0
     ReadOnlyText = 0
 
     def __init__(self, name, appName = QString()):
         '''void KIconTheme.__init__(QString name, QString appName = QString())'''
     def assignIconsToContextMenu(self, type, actions):
         '''static void KIconTheme.assignIconsToContextMenu(KIconTheme.ContextMenus type, list-of-QAction actions)'''
     def defaultThemeName(self):
         '''static QString KIconTheme.defaultThemeName()'''
         return QString()
     def reconfigure(self):
         '''static void KIconTheme.reconfigure()'''
     def current(self):
         '''static QString KIconTheme.current()'''
         return QString()
     def list(self):
         '''static QStringList KIconTheme.list()'''
         return QStringList()
     def depth(self):
         '''int KIconTheme.depth()'''
         return int()
     def isHidden(self):
         '''bool KIconTheme.isHidden()'''
         return bool()
     def isValid(self):
         '''bool KIconTheme.isValid()'''
         return bool()
     def inherits(self):
         '''QStringList KIconTheme.inherits()'''
         return QStringList()
     def dir(self):
         '''QString KIconTheme.dir()'''
         return QString()
     def screenshot(self):
         '''QString KIconTheme.screenshot()'''
         return QString()
     def example(self):
         '''QString KIconTheme.example()'''
         return QString()
     def description(self):
         '''QString KIconTheme.description()'''
         return QString()
     def internalName(self):
         '''QString KIconTheme.internalName()'''
         return QString()
     def name(self):
         '''QString KIconTheme.name()'''
         return QString()
 
 
 class KInputDialog():
     """"""
     def getDouble(self, caption, label, value = 0, minValue = None, maxValue = None, step = None, decimals = 1, ok = None, parent = None):
         '''static float KInputDialog.getDouble(QString caption, QString label, float value = 0, float minValue = -DBL_MAX, float maxValue = DBL_MAX, float step = 0.1, int decimals = 1, bool ok, QWidget parent = None)'''
         return float()
     def getItemList(self, caption, label, list = QStringList(), select = QStringList(), multiple = False, ok = None, parent = None):
         '''static QStringList KInputDialog.getItemList(QString caption, QString label, QStringList list = QStringList(), QStringList select = QStringList(), bool multiple = False, bool ok, QWidget parent = None)'''
         return QStringList()
     def getItem(self, caption, label, list, current = 0, editable = False, ok = None, parent = None):
         '''static QString KInputDialog.getItem(QString caption, QString label, QStringList list, int current = 0, bool editable = False, bool ok, QWidget parent = None)'''
         return QString()
     def getInteger(self, caption, label, value = 0, minValue = None, maxValue = None, step = 1, base = 10, ok = None, parent = None):
         '''static int KInputDialog.getInteger(QString caption, QString label, int value = 0, int minValue = INT_MIN, int maxValue = INT_MAX, int step = 1, int base = 10, bool ok, QWidget parent = None)'''
         return int()
     def getMultiLineText(self, caption, label, value = QString(), ok = None, parent = None):
         '''static QString KInputDialog.getMultiLineText(QString caption, QString label, QString value = QString(), bool ok, QWidget parent = None)'''
         return QString()
     def getText(self, caption, label, value = QString(), ok = None, parent = None, validator = None, mask = QString(), whatsThis = QString(), completionList = QStringList()):
         '''static QString KInputDialog.getText(QString caption, QString label, QString value = QString(), bool ok, QWidget parent = None, QValidator validator = None, QString mask = QString(), QString whatsThis = QString(), QStringList completionList = QStringList())'''
         return QString()
 
 
 class KKeySequenceWidget(QWidget):
     """"""
     # Enum KKeySequenceWidget.ShortcutType
     __kdevpythondocumentation_builtin_None = 0
     LocalShortcuts = 0
     StandardShortcuts = 0
     GlobalShortcuts = 0
 
     # Enum KKeySequenceWidget.Validation
     Validate = 0
     NoValidate = 0
 
     def __init__(self, parent = None):
         '''void KKeySequenceWidget.__init__(QWidget parent = None)'''
     def applyStealShortcut(self):
         '''void KKeySequenceWidget.applyStealShortcut()'''
     def clearKeySequence(self):
         '''void KKeySequenceWidget.clearKeySequence()'''
     def setKeySequence(self, seq, val = None):
         '''void KKeySequenceWidget.setKeySequence(QKeySequence seq, KKeySequenceWidget.Validation val = KKeySequenceWidget.NoValidate)'''
     def captureKeySequence(self):
         '''void KKeySequenceWidget.captureKeySequence()'''
     stealShortcut = pyqtSignal() # void stealShortcut(const QKeySequenceamp;,KAction *) - signal
     keySequenceChanged = pyqtSignal() # void keySequenceChanged(const QKeySequenceamp;) - signal
     def setComponentName(self, componentName):
         '''void KKeySequenceWidget.setComponentName(QString componentName)'''
     def setCheckActionList(self, checkList):
         '''void KKeySequenceWidget.setCheckActionList(list-of-QAction checkList)'''
     def setCheckActionCollections(self, actionCollections):
         '''void KKeySequenceWidget.setCheckActionCollections(list-of-KActionCollection actionCollections)'''
     def keySequence(self):
         '''QKeySequence KKeySequenceWidget.keySequence()'''
         return QKeySequence()
     def isKeySequenceAvailable(self, seq):
         '''bool KKeySequenceWidget.isKeySequenceAvailable(QKeySequence seq)'''
         return bool()
     def setClearButtonShown(self, show):
         '''void KKeySequenceWidget.setClearButtonShown(bool show)'''
     def isModifierlessAllowed(self):
         '''bool KKeySequenceWidget.isModifierlessAllowed()'''
         return bool()
     def setModifierlessAllowed(self, allow):
         '''void KKeySequenceWidget.setModifierlessAllowed(bool allow)'''
     def multiKeyShortcutsAllowed(self):
         '''bool KKeySequenceWidget.multiKeyShortcutsAllowed()'''
         return bool()
     def setMultiKeyShortcutsAllowed(self):
         '''bool KKeySequenceWidget.setMultiKeyShortcutsAllowed()'''
         return bool()
     def checkForConflictsAgainst(self):
         '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.checkForConflictsAgainst()'''
         return KKeySequenceWidget.ShortcutTypes()
     def setCheckForConflictsAgainst(self, types):
         '''void KKeySequenceWidget.setCheckForConflictsAgainst(KKeySequenceWidget.ShortcutTypes types)'''
     class ShortcutTypes():
         """"""
         def __init__(self):
             '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.ShortcutTypes.__init__()'''
             return KKeySequenceWidget.ShortcutTypes()
         def __init__(self):
             '''int KKeySequenceWidget.ShortcutTypes.__init__()'''
             return int()
         def __init__(self):
             '''void KKeySequenceWidget.ShortcutTypes.__init__()'''
         def __bool__(self):
             '''int KKeySequenceWidget.ShortcutTypes.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KKeySequenceWidget.ShortcutTypes.__ne__(KKeySequenceWidget.ShortcutTypes f)'''
             return bool()
         def __eq__(self, f):
             '''bool KKeySequenceWidget.ShortcutTypes.__eq__(KKeySequenceWidget.ShortcutTypes f)'''
             return bool()
         def __invert__(self):
             '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.ShortcutTypes.__invert__()'''
             return KKeySequenceWidget.ShortcutTypes()
         def __and__(self, mask):
             '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.ShortcutTypes.__and__(int mask)'''
             return KKeySequenceWidget.ShortcutTypes()
         def __xor__(self, f):
             '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.ShortcutTypes.__xor__(KKeySequenceWidget.ShortcutTypes f)'''
             return KKeySequenceWidget.ShortcutTypes()
         def __xor__(self, f):
             '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.ShortcutTypes.__xor__(int f)'''
             return KKeySequenceWidget.ShortcutTypes()
         def __or__(self, f):
             '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.ShortcutTypes.__or__(KKeySequenceWidget.ShortcutTypes f)'''
             return KKeySequenceWidget.ShortcutTypes()
         def __or__(self, f):
             '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.ShortcutTypes.__or__(int f)'''
             return KKeySequenceWidget.ShortcutTypes()
         def __int__(self):
             '''int KKeySequenceWidget.ShortcutTypes.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.ShortcutTypes.__ixor__(KKeySequenceWidget.ShortcutTypes f)'''
             return KKeySequenceWidget.ShortcutTypes()
         def __ior__(self, f):
             '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.ShortcutTypes.__ior__(KKeySequenceWidget.ShortcutTypes f)'''
             return KKeySequenceWidget.ShortcutTypes()
         def __iand__(self, mask):
             '''KKeySequenceWidget.ShortcutTypes KKeySequenceWidget.ShortcutTypes.__iand__(int mask)'''
             return KKeySequenceWidget.ShortcutTypes()
 
 
 class KKeyServer():
     """"""
     def modXToQt(self, modX, modQt):
         '''static bool KKeyServer.modXToQt(int modX, int modQt)'''
         return bool()
     def symXToKeyQt(self, sym, keyQt):
         '''static bool KKeyServer.symXToKeyQt(int sym, int keyQt)'''
         return bool()
     def keyQtToModX(self, keyQt, mod):
         '''static bool KKeyServer.keyQtToModX(int keyQt, int mod)'''
         return bool()
     def keyQtToCodeX(self, keyQt, keyCode):
         '''static bool KKeyServer.keyQtToCodeX(int keyQt, int keyCode)'''
         return bool()
     def keyQtToSymX(self, keyQt, sym):
         '''static bool KKeyServer.keyQtToSymX(int keyQt, int sym)'''
         return bool()
     def accelModMaskX(self):
         '''static int KKeyServer.accelModMaskX()'''
         return int()
     def modXModeSwitch(self):
         '''static int KKeyServer.modXModeSwitch()'''
         return int()
     def modXScrollLock(self):
         '''static int KKeyServer.modXScrollLock()'''
         return int()
     def modXNumLock(self):
         '''static int KKeyServer.modXNumLock()'''
         return int()
     def modXMeta(self):
         '''static int KKeyServer.modXMeta()'''
         return int()
     def modXAlt(self):
         '''static int KKeyServer.modXAlt()'''
         return int()
     def modXCtrl(self):
         '''static int KKeyServer.modXCtrl()'''
         return int()
     def modXLock(self):
         '''static int KKeyServer.modXLock()'''
         return int()
     def modXShift(self):
         '''static int KKeyServer.modXShift()'''
         return int()
     def keyboardHasMetaKey(self):
         '''static bool KKeyServer.keyboardHasMetaKey()'''
         return bool()
     def initializeMods(self):
         '''static bool KKeyServer.initializeMods()'''
         return bool()
     def isShiftAsModifierAllowed(self, keyQt):
         '''static bool KKeyServer.isShiftAsModifierAllowed(int keyQt)'''
         return bool()
     def stringUserToMod(self, mod):
         '''static int KKeyServer.stringUserToMod(QString mod)'''
         return int()
     def modToStringUser(self, mod):
         '''static QString KKeyServer.modToStringUser(int mod)'''
         return QString()
 
 
 class KLanguageButton(QWidget):
     """"""
     def __init__(self, parent = None):
         '''void KLanguageButton.__init__(QWidget parent = None)'''
     def __init__(self, text, parent = None):
         '''void KLanguageButton.__init__(QString text, QWidget parent = None)'''
     highlighted = pyqtSignal() # void highlighted(const QStringamp;) - signal
     activated = pyqtSignal() # void activated(const QStringamp;) - signal
     def setCurrentItem(self, languageCode):
         '''void KLanguageButton.setCurrentItem(QString languageCode)'''
     def contains(self, languageCode):
         '''bool KLanguageButton.contains(QString languageCode)'''
         return bool()
     def current(self):
         '''QString KLanguageButton.current()'''
         return QString()
     def clear(self):
         '''void KLanguageButton.clear()'''
     def count(self):
         '''int KLanguageButton.count()'''
         return int()
     def insertSeparator(self, index = None):
         '''void KLanguageButton.insertSeparator(int index = -1)'''
     def insertLanguage(self, languageCode, name = QString(), index = None):
         '''void KLanguageButton.insertLanguage(QString languageCode, QString name = QString(), int index = -1)'''
     def loadAllLanguages(self):
         '''void KLanguageButton.loadAllLanguages()'''
     def showLanguageCodes(self, show):
         '''void KLanguageButton.showLanguageCodes(bool show)'''
     def setText(self, text):
         '''void KLanguageButton.setText(QString text)'''
     def setLocale(self, locale):
         '''void KLanguageButton.setLocale(KLocale locale)'''
 
 
 class KLed(QWidget):
     """"""
     # Enum KLed.Look
     Flat = 0
     Raised = 0
     Sunken = 0
 
     # Enum KLed.Shape
     Rectangular = 0
     Circular = 0
 
     # Enum KLed.State
     Off = 0
     On = 0
 
     def __init__(self, parent = None):
         '''void KLed.__init__(QWidget parent = None)'''
     def __init__(self, color, parent = None):
         '''void KLed.__init__(QColor color, QWidget parent = None)'''
     def __init__(self, color, state, look, shape, parent = None):
         '''void KLed.__init__(QColor color, KLed.State state, KLed.Look look, KLed.Shape shape, QWidget parent = None)'''
     def paintLed(self, shape, look):
         '''void KLed.paintLed(KLed.Shape shape, KLed.Look look)'''
     def updateCachedPixmap(self):
         '''void KLed.updateCachedPixmap()'''
     def resizeEvent(self):
         '''QResizeEvent KLed.resizeEvent()'''
         return QResizeEvent()
     def paintCachedPixmap(self):
         '''bool KLed.paintCachedPixmap()'''
         return bool()
     def paintEvent(self):
         '''QPaintEvent KLed.paintEvent()'''
         return QPaintEvent()
     def paintRectFrame(self, raised):
         '''void KLed.paintRectFrame(bool raised)'''
     def paintRect(self):
         '''void KLed.paintRect()'''
     def paintSunken(self):
         '''void KLed.paintSunken()'''
     def paintRaised(self):
         '''void KLed.paintRaised()'''
     def paintFlat(self):
         '''void KLed.paintFlat()'''
     def ledWidth(self):
         '''int KLed.ledWidth()'''
         return int()
     def off(self):
         '''void KLed.off()'''
     def on(self):
         '''void KLed.on()'''
     def toggle(self):
         '''void KLed.toggle()'''
     def minimumSizeHint(self):
         '''QSize KLed.minimumSizeHint()'''
         return QSize()
     def sizeHint(self):
         '''QSize KLed.sizeHint()'''
         return QSize()
     def setDarkFactor(self, darkFactor):
         '''void KLed.setDarkFactor(int darkFactor)'''
     def setShape(self, shape):
         '''void KLed.setShape(KLed.Shape shape)'''
     def setLook(self, look):
         '''void KLed.setLook(KLed.Look look)'''
     def setState(self, state):
         '''void KLed.setState(KLed.State state)'''
     def setColor(self, color):
         '''void KLed.setColor(QColor color)'''
     def darkFactor(self):
         '''int KLed.darkFactor()'''
         return int()
     def shape(self):
         '''KLed.Shape KLed.shape()'''
         return KLed.Shape()
     def look(self):
         '''KLed.Look KLed.look()'''
         return KLed.Look()
     def state(self):
         '''KLed.State KLed.state()'''
         return KLed.State()
     def color(self):
         '''QColor KLed.color()'''
         return QColor()
 
 
 class KLineEdit(QLineEdit, KCompletionBase):
     """"""
     def __init__(self, string, parent = None):
         '''void KLineEdit.__init__(QString string, QWidget parent = None)'''
     def __init__(self, parent = None):
         '''void KLineEdit.__init__(QWidget parent = None)'''
     def focusOutEvent(self, ev):
         '''void KLineEdit.focusOutEvent(QFocusEvent ev)'''
     def focusInEvent(self, ev):
         '''void KLineEdit.focusInEvent(QFocusEvent ev)'''
     def paintEvent(self, ev):
         '''void KLineEdit.paintEvent(QPaintEvent ev)'''
     def autoSuggest(self):
         '''bool KLineEdit.autoSuggest()'''
         return bool()
     def create(self, initializeWindow = True, destroyOldWindow = True):
         '''int KLineEdit.create(bool initializeWindow = True, bool destroyOldWindow = True)'''
         return int()
     def setUserSelection(self, userSelection):
         '''void KLineEdit.setUserSelection(bool userSelection)'''
     def dropEvent(self):
         '''QDropEvent KLineEdit.dropEvent()'''
         return QDropEvent()
     def createStandardContextMenu(self):
         '''QMenu KLineEdit.createStandardContextMenu()'''
         return QMenu()
     def contextMenuEvent(self):
         '''QContextMenuEvent KLineEdit.contextMenuEvent()'''
         return QContextMenuEvent()
     def mouseDoubleClickEvent(self):
         '''QMouseEvent KLineEdit.mouseDoubleClickEvent()'''
         return QMouseEvent()
     def mouseReleaseEvent(self):
         '''QMouseEvent KLineEdit.mouseReleaseEvent()'''
         return QMouseEvent()
     def mousePressEvent(self):
         '''QMouseEvent KLineEdit.mousePressEvent()'''
         return QMouseEvent()
     def keyPressEvent(self):
         '''QKeyEvent KLineEdit.keyPressEvent()'''
         return QKeyEvent()
     def resizeEvent(self):
         '''QResizeEvent KLineEdit.resizeEvent()'''
         return QResizeEvent()
     def event(self):
         '''QEvent KLineEdit.event()'''
         return QEvent()
     def userCancelled(self, cancelText):
         '''void KLineEdit.userCancelled(QString cancelText)'''
     def makeCompletion(self):
         '''QString KLineEdit.makeCompletion()'''
         return QString()
     def passwordMode(self):
         '''bool KLineEdit.passwordMode()'''
         return bool()
     def setPasswordMode(self, b = True):
         '''void KLineEdit.setPasswordMode(bool b = True)'''
     def setText(self):
         '''QString KLineEdit.setText()'''
         return QString()
     def setSqueezedText(self, text):
         '''void KLineEdit.setSqueezedText(QString text)'''
     def clear(self):
         '''void KLineEdit.clear()'''
     def setCompletedItems(self, items, autoSuggest = True):
         '''void KLineEdit.setCompletedItems(QStringList items, bool autoSuggest = True)'''
     def setCompletedText(self):
         '''QString KLineEdit.setCompletedText()'''
         return QString()
     def setCompletedText(self):
         '''bool KLineEdit.setCompletedText()'''
         return bool()
     def rotateText(self, type):
         '''void KLineEdit.rotateText(KCompletionBase.KeyBindingType type)'''
     def setReadOnly(self):
         '''bool KLineEdit.setReadOnly()'''
         return bool()
     clearButtonClicked = pyqtSignal() # void clearButtonClicked() - signal
     aboutToShowContextMenu = pyqtSignal() # void aboutToShowContextMenu(QMenu *) - signal
     completionModeChanged = pyqtSignal() # void completionModeChanged(KGlobalSettings::Completion) - signal
     textRotation = pyqtSignal() # void textRotation(KCompletionBase::KeyBindingType) - signal
     userTextChanged = pyqtSignal() # void userTextChanged(const QStringamp;) - signal
     substringCompletion = pyqtSignal() # void substringCompletion(const QStringamp;) - signal
     completion = pyqtSignal() # void completion(const QStringamp;) - signal
     returnPressed = pyqtSignal() # void returnPressed(const QStringamp;) - signal
     completionBoxActivated = pyqtSignal() # void completionBoxActivated(const QStringamp;) - signal
     def doCompletion(self, txt):
         '''void KLineEdit.doCompletion(QString txt)'''
     def clearButtonUsedSize(self):
         '''QSize KLineEdit.clearButtonUsedSize()'''
         return QSize()
     def isClearButtonShown(self):
         '''bool KLineEdit.isClearButtonShown()'''
         return bool()
     def setClearButtonShown(self, show):
         '''void KLineEdit.setClearButtonShown(bool show)'''
     def clickMessage(self):
         '''QString KLineEdit.clickMessage()'''
         return QString()
     def setClickMessage(self, msg):
         '''void KLineEdit.setClickMessage(QString msg)'''
     def setCompletionBox(self, box):
         '''void KLineEdit.setCompletionBox(KCompletionBox box)'''
     def userText(self):
         '''QString KLineEdit.userText()'''
         return QString()
     def originalText(self):
         '''QString KLineEdit.originalText()'''
         return QString()
     def isSqueezedTextEnabled(self):
         '''bool KLineEdit.isSqueezedTextEnabled()'''
         return bool()
     def setSqueezedTextEnabled(self, enable):
         '''void KLineEdit.setSqueezedTextEnabled(bool enable)'''
     def copy(self):
         '''void KLineEdit.copy()'''
     def setCompletionObject(self, hsig = True):
         '''KCompletion KLineEdit.setCompletionObject(bool hsig = True)'''
         return KCompletion()
     def completionBox(self, create = True):
         '''KCompletionBox KLineEdit.completionBox(bool create = True)'''
         return KCompletionBox()
     def trapReturnKey(self):
         '''bool KLineEdit.trapReturnKey()'''
         return bool()
     def setTrapReturnKey(self, trap):
         '''void KLineEdit.setTrapReturnKey(bool trap)'''
     def urlDropsEnabled(self):
         '''bool KLineEdit.urlDropsEnabled()'''
         return bool()
     def setUrlDropsEnabled(self, enable):
         '''void KLineEdit.setUrlDropsEnabled(bool enable)'''
     def isContextMenuEnabled(self):
         '''bool KLineEdit.isContextMenuEnabled()'''
         return bool()
     def setContextMenuEnabled(self, showMenu):
         '''void KLineEdit.setContextMenuEnabled(bool showMenu)'''
     def setCompletionModeDisabled(self, mode, disable = True):
         '''void KLineEdit.setCompletionModeDisabled(KGlobalSettings.Completion mode, bool disable = True)'''
     def setCompletionMode(self, mode):
         '''void KLineEdit.setCompletionMode(KGlobalSettings.Completion mode)'''
     def setUrl(self, url):
         '''void KLineEdit.setUrl(KUrl url)'''
 
 
 class KLinkItemSelectionModel(QItemSelectionModel):
     """"""
     def __init__(self, targetModel, linkedItemSelectionModel, parent = None):
         '''void KLinkItemSelectionModel.__init__(QAbstractItemModel targetModel, QItemSelectionModel linkedItemSelectionModel, QObject parent = None)'''
     def select(self, index, command):
         '''void KLinkItemSelectionModel.select(QModelIndex index, QItemSelectionModel.SelectionFlags command)'''
     def select(self, selection, command):
         '''void KLinkItemSelectionModel.select(QItemSelection selection, QItemSelectionModel.SelectionFlags command)'''
 
 
 class KListWidgetSearchLine(KLineEdit):
     """"""
     def __init__(self, parent = None, listWidget = None):
         '''void KListWidgetSearchLine.__init__(QWidget parent = None, QListWidget listWidget = None)'''
     def event(self, event):
         '''bool KListWidgetSearchLine.event(QEvent event)'''
         return bool()
     def itemMatches(self, item, s):
         '''bool KListWidgetSearchLine.itemMatches(QListWidgetItem item, QString s)'''
         return bool()
     def clear(self):
         '''void KListWidgetSearchLine.clear()'''
     def setListWidget(self, lv):
         '''void KListWidgetSearchLine.setListWidget(QListWidget lv)'''
     def setCaseSensitivity(self, cs):
         '''void KListWidgetSearchLine.setCaseSensitivity(Qt.CaseSensitivity cs)'''
     def updateSearch(self, s = QString()):
         '''void KListWidgetSearchLine.updateSearch(QString s = QString())'''
     def listWidget(self):
         '''QListWidget KListWidgetSearchLine.listWidget()'''
         return QListWidget()
     def caseSensitive(self):
         '''Qt.CaseSensitivity KListWidgetSearchLine.caseSensitive()'''
         return Qt.CaseSensitivity()
 
 
 class KMainWindow(QMainWindow):
     """"""
     def __init__(self, parent = None, f = 0):
         '''void KMainWindow.__init__(QWidget parent = None, Qt.WindowFlags f = 0)'''
     def saveAutoSaveSettings(self):
         '''void KMainWindow.saveAutoSaveSettings()'''
     def showAboutApplication(self):
         '''void KMainWindow.showAboutApplication()'''
     def parseGeometry(self, parsewidth):
         '''void KMainWindow.parseGeometry(bool parsewidth)'''
     def restoreWindowSize(self, config):
         '''void KMainWindow.restoreWindowSize(KConfigGroup config)'''
     def saveWindowSize(self, config):
         '''void KMainWindow.saveWindowSize(KConfigGroup config)'''
     def settingsDirty(self):
         '''bool KMainWindow.settingsDirty()'''
         return bool()
     def readPropertiesInternal(self):
         '''int KMainWindow.readPropertiesInternal()'''
         return int()
     def savePropertiesInternal(self):
         '''int KMainWindow.savePropertiesInternal()'''
         return int()
     def readGlobalProperties(self, sessionConfig):
         '''void KMainWindow.readGlobalProperties(KConfig sessionConfig)'''
     def saveGlobalProperties(self, sessionConfig):
         '''void KMainWindow.saveGlobalProperties(KConfig sessionConfig)'''
     def readProperties(self):
         '''KConfigGroup KMainWindow.readProperties()'''
         return KConfigGroup()
     def saveProperties(self):
         '''KConfigGroup KMainWindow.saveProperties()'''
         return KConfigGroup()
     def queryClose(self):
         '''bool KMainWindow.queryClose()'''
         return bool()
     def queryExit(self):
         '''bool KMainWindow.queryExit()'''
         return bool()
     def closeEvent(self):
         '''QCloseEvent KMainWindow.closeEvent()'''
         return QCloseEvent()
     def event(self, event):
         '''bool KMainWindow.event(QEvent event)'''
         return bool()
     def setSettingsDirty(self):
         '''void KMainWindow.setSettingsDirty()'''
     def appHelpActivated(self):
         '''void KMainWindow.appHelpActivated()'''
     def setPlainCaption(self, caption):
         '''void KMainWindow.setPlainCaption(QString caption)'''
     def setCaption(self, caption):
         '''void KMainWindow.setCaption(QString caption)'''
     def setCaption(self, caption, modified):
         '''void KMainWindow.setCaption(QString caption, bool modified)'''
     def dbusName(self):
         '''QString KMainWindow.dbusName()'''
         return QString()
     def ignoreInitialGeometry(self):
         '''void KMainWindow.ignoreInitialGeometry()'''
     def initialGeometrySet(self):
         '''bool KMainWindow.initialGeometrySet()'''
         return bool()
     def saveMainWindowSettings(self, config):
         '''void KMainWindow.saveMainWindowSettings(KConfigGroup config)'''
     def applyMainWindowSettings(self, config, forceGlobal = False):
         '''void KMainWindow.applyMainWindowSettings(KConfigGroup config, bool forceGlobal = False)'''
     def autoSaveConfigGroup(self):
         '''KConfigGroup KMainWindow.autoSaveConfigGroup()'''
         return KConfigGroup()
     def autoSaveGroup(self):
         '''QString KMainWindow.autoSaveGroup()'''
         return QString()
     def autoSaveSettings(self):
         '''bool KMainWindow.autoSaveSettings()'''
         return bool()
     def resetAutoSaveSettings(self):
         '''void KMainWindow.resetAutoSaveSettings()'''
     def setAutoSaveSettings(self, groupName = QLatin1StringMainWindow, saveWindowSize = True):
         '''void KMainWindow.setAutoSaveSettings(QString groupName = QLatin1StringMainWindow, bool saveWindowSize = True)'''
     def setAutoSaveSettings(self, group, saveWindowSize = True):
         '''void KMainWindow.setAutoSaveSettings(KConfigGroup group, bool saveWindowSize = True)'''
     def toolBars(self):
         '''list-of-KToolBar KMainWindow.toolBars()'''
         return [KToolBar()]
     def toolBar(self, name = QString()):
         '''KToolBar KMainWindow.toolBar(QString name = QString())'''
         return KToolBar()
     def memberList(self):
         '''static list-of-KMainWindow KMainWindow.memberList()'''
         return [KMainWindow()]
     def statusBar(self):
         '''KStatusBar KMainWindow.statusBar()'''
         return KStatusBar()
     def menuBar(self):
         '''KMenuBar KMainWindow.menuBar()'''
         return KMenuBar()
     def hasMenuBar(self):
         '''bool KMainWindow.hasMenuBar()'''
         return bool()
     def restore(self, number, show = True):
         '''bool KMainWindow.restore(int number, bool show = True)'''
         return bool()
     def classNameOfToplevel(self, number):
         '''static QString KMainWindow.classNameOfToplevel(int number)'''
         return QString()
     def canBeRestored(self, number):
         '''static bool KMainWindow.canBeRestored(int number)'''
         return bool()
     def customHelpMenu(self, showWhatsThis = True):
         '''KMenu KMainWindow.customHelpMenu(bool showWhatsThis = True)'''
         return KMenu()
     def helpMenu(self, aboutAppText = QString(), showWhatsThis = True):
         '''KMenu KMainWindow.helpMenu(QString aboutAppText = QString(), bool showWhatsThis = True)'''
         return KMenu()
 
 
 class KSelectionOwner(QObject):
     """"""
     def __init__(self, selection, screen = None, parent = None):
         '''void KSelectionOwner.__init__(int selection, int screen = -1, QObject parent = None)'''
     def __init__(self, selection, screen = None, parent = None):
         '''void KSelectionOwner.__init__(str selection, int screen = -1, QObject parent = None)'''
     def setData(self, extra1, extra2):
         '''void KSelectionOwner.setData(int extra1, int extra2)'''
     def getAtoms(self):
         '''void KSelectionOwner.getAtoms()'''
     def replyTargets(self, property, requestor):
         '''void KSelectionOwner.replyTargets(int property, int requestor)'''
     def genericReply(self, target, property, requestor):
         '''bool KSelectionOwner.genericReply(int target, int property, int requestor)'''
         return bool()
     lostOwnership = pyqtSignal() # void lostOwnership() - signal
     def ownerWindow(self):
         '''int KSelectionOwner.ownerWindow()'''
         return int()
     def release(self):
         '''void KSelectionOwner.release()'''
     def claim(self, force, force_kill = True):
         '''bool KSelectionOwner.claim(bool force, bool force_kill = True)'''
         return bool()
 
 
 class KSelectionWatcher(QObject):
     """"""
     def __init__(self, selection, screen = None, parent = None):
         '''void KSelectionWatcher.__init__(int selection, int screen = -1, QObject parent = None)'''
     def __init__(self, selection, screen = None, parent = None):
         '''void KSelectionWatcher.__init__(str selection, int screen = -1, QObject parent = None)'''
     lostOwner = pyqtSignal() # void lostOwner() - signal
     newOwner = pyqtSignal() # void newOwner(Window) - signal
     def owner(self):
         '''int KSelectionWatcher.owner()'''
         return int()
 
 
 class KMenu(QMenu):
     """"""
     def __init__(self, parent = None):
         '''void KMenu.__init__(QWidget parent = None)'''
     def __init__(self, title, parent = None):
         '''void KMenu.__init__(QString title, QWidget parent = None)'''
     def hideEvent(self):
         '''QHideEvent KMenu.hideEvent()'''
         return QHideEvent()
     def contextMenuEvent(self, e):
         '''void KMenu.contextMenuEvent(QContextMenuEvent e)'''
     def focusNextPrevChild(self, next):
         '''bool KMenu.focusNextPrevChild(bool next)'''
         return bool()
     def mousePressEvent(self, e):
         '''void KMenu.mousePressEvent(QMouseEvent e)'''
     def mouseReleaseEvent(self, e):
         '''void KMenu.mouseReleaseEvent(QMouseEvent e)'''
     def keyPressEvent(self, e):
         '''void KMenu.keyPressEvent(QKeyEvent e)'''
     def closeEvent(self):
         '''QCloseEvent KMenu.closeEvent()'''
         return QCloseEvent()
     aboutToShowContextMenu = pyqtSignal() # void aboutToShowContextMenu(KMenu *,QAction *,QMenu *) - signal
     def keyboardModifiers(self):
         '''Qt.KeyboardModifiers KMenu.keyboardModifiers()'''
         return Qt.KeyboardModifiers()
     def mouseButtons(self):
         '''Qt.MouseButtons KMenu.mouseButtons()'''
         return Qt.MouseButtons()
     def contextMenuFocusAction(self):
         '''static QAction KMenu.contextMenuFocusAction()'''
         return QAction()
     def contextMenuFocus(self):
         '''static KMenu KMenu.contextMenuFocus()'''
         return KMenu()
     def hideContextMenu(self):
         '''void KMenu.hideContextMenu()'''
     def contextMenu(self):
         '''QMenu KMenu.contextMenu()'''
         return QMenu()
     def setKeyboardShortcutsExecute(self, enable):
         '''void KMenu.setKeyboardShortcutsExecute(bool enable)'''
     def setKeyboardShortcutsEnabled(self, enable):
         '''void KMenu.setKeyboardShortcutsEnabled(bool enable)'''
     def addTitle(self, text, before = None):
         '''QAction KMenu.addTitle(QString text, QAction before = None)'''
         return QAction()
     def addTitle(self, icon, text, before = None):
         '''QAction KMenu.addTitle(QIcon icon, QString text, QAction before = None)'''
         return QAction()
 
 
 class KMenuBar(QMenuBar):
     """"""
     def __init__(self, parent = None):
         '''void KMenuBar.__init__(QWidget parent = None)'''
     def paintEvent(self):
         '''QPaintEvent KMenuBar.paintEvent()'''
         return QPaintEvent()
     def closeEvent(self):
         '''QCloseEvent KMenuBar.closeEvent()'''
         return QCloseEvent()
     def eventFilter(self):
         '''QEvent KMenuBar.eventFilter()'''
         return QEvent()
     def resizeEvent(self):
         '''QResizeEvent KMenuBar.resizeEvent()'''
         return QResizeEvent()
     def slotReadConfig(self):
         '''void KMenuBar.slotReadConfig()'''
     def sizeHint(self):
         '''QSize KMenuBar.sizeHint()'''
         return QSize()
     def setMargin(self):
         '''int KMenuBar.setMargin()'''
         return int()
     def setLineWidth(self):
         '''int KMenuBar.setLineWidth()'''
         return int()
     def setFrameStyle(self):
         '''int KMenuBar.setFrameStyle()'''
         return int()
     def resize(self, w, h):
         '''void KMenuBar.resize(int w, int h)'''
     def resize(self, s):
         '''void KMenuBar.resize(QSize s)'''
     def setGeometry(self, r):
         '''void KMenuBar.setGeometry(QRect r)'''
     def setGeometry(self, x, y, w, h):
         '''void KMenuBar.setGeometry(int x, int y, int w, int h)'''
     def isTopLevelMenu(self):
         '''bool KMenuBar.isTopLevelMenu()'''
         return bool()
     def setTopLevelMenu(self, top_level = True):
         '''void KMenuBar.setTopLevelMenu(bool top_level = True)'''
 
 
 class KMessageBox():
     """"""
     # Enum KMessageBox.Option
     Notify = 0
     AllowLink = 0
     Dangerous = 0
     PlainCaption = 0
     NoExec = 0
     WindowModal = 0
 
     # Enum KMessageBox.DialogType
     QuestionYesNo = 0
     WarningYesNo = 0
     WarningContinueCancel = 0
     WarningYesNoCancel = 0
     Information = 0
     Sorry = 0
     Error = 0
     QuestionYesNoCancel = 0
 
     # Enum KMessageBox.ButtonCode
     Ok = 0
     Cancel = 0
     Yes = 0
     No = 0
     Continue = 0
 
     def __init__(self):
         '''void KMessageBox.__init__()'''
     def __init__(self):
         '''KMessageBox KMessageBox.__init__()'''
         return KMessageBox()
     def createKMessageBox(self, dialog, icon, text, strlist, ask, checkboxReturn, options, details = QString()):
         '''static int KMessageBox.createKMessageBox(KDialog dialog, QMessageBox.Icon icon, QString text, QStringList strlist, QString ask, bool checkboxReturn, KMessageBox.Options options, QString details = QString())'''
         return int()
     def createKMessageBox(self, dialog, icon, text, strlist, ask, checkboxReturn, options, details = QString(), notifyType = None):
         '''static int KMessageBox.createKMessageBox(KDialog dialog, QIcon icon, QString text, QStringList strlist, QString ask, bool checkboxReturn, KMessageBox.Options options, QString details = QString(), QMessageBox.Icon notifyType = QMessageBox.Information)'''
         return int()
     def setDontShowAskAgainConfig(self, cfg):
         '''static void KMessageBox.setDontShowAskAgainConfig(KConfig cfg)'''
     def saveDontShowAgainContinue(self, dontShowAgainName):
         '''static void KMessageBox.saveDontShowAgainContinue(QString dontShowAgainName)'''
     def saveDontShowAgainYesNo(self, dontShowAgainName, result):
         '''static void KMessageBox.saveDontShowAgainYesNo(QString dontShowAgainName, KMessageBox.ButtonCode result)'''
     def shouldBeShownContinue(self, dontShowAgainName):
         '''static bool KMessageBox.shouldBeShownContinue(QString dontShowAgainName)'''
         return bool()
     def shouldBeShownYesNo(self, dontShowAgainName, result):
         '''static bool KMessageBox.shouldBeShownYesNo(QString dontShowAgainName, KMessageBox.ButtonCode result)'''
         return bool()
     def queuedMessageBoxWId(self, parent_id, type, text, caption, options):
         '''static void KMessageBox.queuedMessageBoxWId(int parent_id, KMessageBox.DialogType type, QString text, QString caption, KMessageBox.Options options)'''
     def queuedMessageBoxWId(self, parent_id, type, text, caption = QString()):
         '''static void KMessageBox.queuedMessageBoxWId(int parent_id, KMessageBox.DialogType type, QString text, QString caption = QString())'''
     def queuedMessageBox(self, parent, type, text, caption, options):
         '''static void KMessageBox.queuedMessageBox(QWidget parent, KMessageBox.DialogType type, QString text, QString caption, KMessageBox.Options options)'''
     def queuedMessageBox(self, parent, type, text, caption = QString()):
         '''static void KMessageBox.queuedMessageBox(QWidget parent, KMessageBox.DialogType type, QString text, QString caption = QString())'''
     def messageBoxWId(self, parent_id, type, text, caption = QString(), buttonYes = None, buttonNo = None, buttonCancel = None, dontShowAskAgainName = QString(), options = None):
         '''static int KMessageBox.messageBoxWId(int parent_id, KMessageBox.DialogType type, QString text, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontShowAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def messageBox(self, parent, type, text, caption = QString(), buttonYes = None, buttonNo = None, buttonCancel = None, dontShowAskAgainName = QString(), options = None):
         '''static int KMessageBox.messageBox(QWidget parent, KMessageBox.DialogType type, QString text, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontShowAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def about(self, parent, text, caption = QString(), options = None):
         '''static void KMessageBox.about(QWidget parent, QString text, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def enableMessage(self, dontShowAgainName):
         '''static void KMessageBox.enableMessage(QString dontShowAgainName)'''
     def enableAllMessages(self):
         '''static void KMessageBox.enableAllMessages()'''
     def informationListWId(self, parent_id, text, strlist, caption = QString(), dontShowAgainName = QString(), options = None):
         '''static void KMessageBox.informationListWId(int parent_id, QString text, QStringList strlist, QString caption = QString(), QString dontShowAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def informationList(self, parent, text, strlist, caption = QString(), dontShowAgainName = QString(), options = None):
         '''static void KMessageBox.informationList(QWidget parent, QString text, QStringList strlist, QString caption = QString(), QString dontShowAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def informationWId(self, parent_id, text, caption = QString(), dontShowAgainName = QString(), options = None):
         '''static void KMessageBox.informationWId(int parent_id, QString text, QString caption = QString(), QString dontShowAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def information(self, parent, text, caption = QString(), dontShowAgainName = QString(), options = None):
         '''static void KMessageBox.information(QWidget parent, QString text, QString caption = QString(), QString dontShowAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def detailedSorryWId(self, parent_id, text, details, caption = QString(), options = None):
         '''static void KMessageBox.detailedSorryWId(int parent_id, QString text, QString details, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def detailedSorry(self, parent, text, details, caption = QString(), options = None):
         '''static void KMessageBox.detailedSorry(QWidget parent, QString text, QString details, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def sorryWId(self, parent_id, text, caption = QString(), options = None):
         '''static void KMessageBox.sorryWId(int parent_id, QString text, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def sorry(self, parent, text, caption = QString(), options = None):
         '''static void KMessageBox.sorry(QWidget parent, QString text, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def queuedDetailedErrorWId(self, parent_id, text, details, caption = QString()):
         '''static void KMessageBox.queuedDetailedErrorWId(int parent_id, QString text, QString details, QString caption = QString())'''
     def queuedDetailedError(self, parent, text, details, caption = QString()):
         '''static void KMessageBox.queuedDetailedError(QWidget parent, QString text, QString details, QString caption = QString())'''
     def detailedErrorWId(self, parent_id, text, details, caption = QString(), options = None):
         '''static void KMessageBox.detailedErrorWId(int parent_id, QString text, QString details, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def detailedError(self, parent, text, details, caption = QString(), options = None):
         '''static void KMessageBox.detailedError(QWidget parent, QString text, QString details, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def errorListWId(self, parent_id, text, strlist, caption = QString(), options = None):
         '''static void KMessageBox.errorListWId(int parent_id, QString text, QStringList strlist, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def errorList(self, parent, text, strlist, caption = QString(), options = None):
         '''static void KMessageBox.errorList(QWidget parent, QString text, QStringList strlist, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def errorWId(self, parent_id, text, caption = QString(), options = None):
         '''static void KMessageBox.errorWId(int parent_id, QString text, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def error(self, parent, text, caption = QString(), options = None):
         '''static void KMessageBox.error(QWidget parent, QString text, QString caption = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
     def warningYesNoCancelListWId(self, parent_id, text, strlist, caption = QString(), buttonYes = None, buttonNo = None, buttonCancel = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningYesNoCancelListWId(int parent_id, QString text, QStringList strlist, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def warningYesNoCancelList(self, parent, text, strlist, caption = QString(), buttonYes = None, buttonNo = None, buttonCancel = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningYesNoCancelList(QWidget parent, QString text, QStringList strlist, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def warningYesNoCancelWId(self, parent_id, text, caption = QString(), buttonYes = None, buttonNo = None, buttonCancel = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningYesNoCancelWId(int parent_id, QString text, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def warningYesNoCancel(self, parent, text, caption = QString(), buttonYes = None, buttonNo = None, buttonCancel = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningYesNoCancel(QWidget parent, QString text, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def warningContinueCancelListWId(self, parent_id, text, strlist, caption = QString(), buttonContinue = None, buttonCancel = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningContinueCancelListWId(int parent_id, QString text, QStringList strlist, QString caption = QString(), KGuiItem buttonContinue = KStandardGuiItem.cont(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def warningContinueCancelList(self, parent, text, strlist, caption = QString(), buttonContinue = None, buttonCancel = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningContinueCancelList(QWidget parent, QString text, QStringList strlist, QString caption = QString(), KGuiItem buttonContinue = KStandardGuiItem.cont(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def warningContinueCancelWId(self, parent_id, text, caption = QString(), buttonContinue = None, buttonCancel = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningContinueCancelWId(int parent_id, QString text, QString caption = QString(), KGuiItem buttonContinue = KStandardGuiItem.cont(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def warningContinueCancel(self, parent, text, caption = QString(), buttonContinue = None, buttonCancel = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningContinueCancel(QWidget parent, QString text, QString caption = QString(), KGuiItem buttonContinue = KStandardGuiItem.cont(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def warningYesNoListWId(self, parent_id, text, strlist, caption = QString(), buttonYes = None, buttonNo = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningYesNoListWId(int parent_id, QString text, QStringList strlist, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Options(KMessageBox.Notify|KMessageBox.Dangerous))'''
         return int()
     def warningYesNoList(self, parent, text, strlist, caption = QString(), buttonYes = None, buttonNo = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningYesNoList(QWidget parent, QString text, QStringList strlist, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Options(KMessageBox.Notify|KMessageBox.Dangerous))'''
         return int()
     def warningYesNoWId(self, parent_id, text, caption = QString(), buttonYes = None, buttonNo = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningYesNoWId(int parent_id, QString text, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Options(KMessageBox.Notify|KMessageBox.Dangerous))'''
         return int()
     def warningYesNo(self, parent, text, caption = QString(), buttonYes = None, buttonNo = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.warningYesNo(QWidget parent, QString text, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Options(KMessageBox.Notify|KMessageBox.Dangerous))'''
         return int()
     def questionYesNoListWId(self, parent_id, text, strlist, caption = QString(), buttonYes = None, buttonNo = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.questionYesNoListWId(int parent_id, QString text, QStringList strlist, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def questionYesNoList(self, parent, text, strlist, caption = QString(), buttonYes = None, buttonNo = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.questionYesNoList(QWidget parent, QString text, QStringList strlist, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def questionYesNoCancelWId(self, parent_id, text, caption = QString(), buttonYes = None, buttonNo = None, buttonCancel = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.questionYesNoCancelWId(int parent_id, QString text, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def questionYesNoCancel(self, parent, text, caption = QString(), buttonYes = None, buttonNo = None, buttonCancel = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.questionYesNoCancel(QWidget parent, QString text, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), KGuiItem buttonCancel = KStandardGuiItem.cancel(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def questionYesNoWId(self, parent_id, text, caption = QString(), buttonYes = None, buttonNo = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.questionYesNoWId(int parent_id, QString text, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     def questionYesNo(self, parent, text, caption = QString(), buttonYes = None, buttonNo = None, dontAskAgainName = QString(), options = None):
         '''static int KMessageBox.questionYesNo(QWidget parent, QString text, QString caption = QString(), KGuiItem buttonYes = KStandardGuiItem.yes(), KGuiItem buttonNo = KStandardGuiItem.no(), QString dontAskAgainName = QString(), KMessageBox.Options options = KMessageBox.Notify)'''
         return int()
     class Options():
         """"""
         def __init__(self):
             '''KMessageBox.Options KMessageBox.Options.__init__()'''
             return KMessageBox.Options()
         def __init__(self):
             '''int KMessageBox.Options.__init__()'''
             return int()
         def __init__(self):
             '''void KMessageBox.Options.__init__()'''
         def __bool__(self):
             '''int KMessageBox.Options.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KMessageBox.Options.__ne__(KMessageBox.Options f)'''
             return bool()
         def __eq__(self, f):
             '''bool KMessageBox.Options.__eq__(KMessageBox.Options f)'''
             return bool()
         def __invert__(self):
             '''KMessageBox.Options KMessageBox.Options.__invert__()'''
             return KMessageBox.Options()
         def __and__(self, mask):
             '''KMessageBox.Options KMessageBox.Options.__and__(int mask)'''
             return KMessageBox.Options()
         def __xor__(self, f):
             '''KMessageBox.Options KMessageBox.Options.__xor__(KMessageBox.Options f)'''
             return KMessageBox.Options()
         def __xor__(self, f):
             '''KMessageBox.Options KMessageBox.Options.__xor__(int f)'''
             return KMessageBox.Options()
         def __or__(self, f):
             '''KMessageBox.Options KMessageBox.Options.__or__(KMessageBox.Options f)'''
             return KMessageBox.Options()
         def __or__(self, f):
             '''KMessageBox.Options KMessageBox.Options.__or__(int f)'''
             return KMessageBox.Options()
         def __int__(self):
             '''int KMessageBox.Options.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KMessageBox.Options KMessageBox.Options.__ixor__(KMessageBox.Options f)'''
             return KMessageBox.Options()
         def __ior__(self, f):
             '''KMessageBox.Options KMessageBox.Options.__ior__(KMessageBox.Options f)'''
             return KMessageBox.Options()
         def __iand__(self, mask):
             '''KMessageBox.Options KMessageBox.Options.__iand__(int mask)'''
             return KMessageBox.Options()
 
 
 class KMessageBoxMessageHandler(QObject, KMessageHandler):
     """"""
     def __init__(self, parent = None):
         '''void KMessageBoxMessageHandler.__init__(QWidget parent = None)'''
     def message(self, messageType, text, caption):
         '''void KMessageBoxMessageHandler.message(KMessage.MessageType messageType, QString text, QString caption)'''
 
 
 class KMessageWidget(QFrame):
     """"""
     # Enum KMessageWidget.MessageType
     Positive = 0
     Information = 0
     Warning = 0
     Error = 0
 
     def __init__(self, parent = None):
         '''void KMessageWidget.__init__(QWidget parent = None)'''
     def __init__(self, text, parent = None):
         '''void KMessageWidget.__init__(QString text, QWidget parent = None)'''
     def heightForWidth(self, width):
         '''int KMessageWidget.heightForWidth(int width)'''
         return int()
     def showEvent(self, event):
         '''void KMessageWidget.showEvent(QShowEvent event)'''
     def resizeEvent(self, event):
         '''void KMessageWidget.resizeEvent(QResizeEvent event)'''
     def event(self, event):
         '''bool KMessageWidget.event(QEvent event)'''
         return bool()
     def paintEvent(self, event):
         '''void KMessageWidget.paintEvent(QPaintEvent event)'''
     def animatedHide(self):
         '''void KMessageWidget.animatedHide()'''
     def animatedShow(self):
         '''void KMessageWidget.animatedShow()'''
     def setMessageType(self, type):
         '''void KMessageWidget.setMessageType(KMessageWidget.MessageType type)'''
     def setCloseButtonVisible(self, visible):
         '''void KMessageWidget.setCloseButtonVisible(bool visible)'''
     def setWordWrap(self, wordWrap):
         '''void KMessageWidget.setWordWrap(bool wordWrap)'''
     def setText(self, text):
         '''void KMessageWidget.setText(QString text)'''
     def minimumSizeHint(self):
         '''QSize KMessageWidget.minimumSizeHint()'''
         return QSize()
     def sizeHint(self):
         '''QSize KMessageWidget.sizeHint()'''
         return QSize()
     def removeAction(self, action):
         '''void KMessageWidget.removeAction(QAction action)'''
     def addAction(self, action):
         '''void KMessageWidget.addAction(QAction action)'''
     def messageType(self):
         '''KMessageWidget.MessageType KMessageWidget.messageType()'''
         return KMessageWidget.MessageType()
     def isCloseButtonVisible(self):
         '''bool KMessageWidget.isCloseButtonVisible()'''
         return bool()
     def wordWrap(self):
         '''bool KMessageWidget.wordWrap()'''
         return bool()
     def text(self):
         '''QString KMessageWidget.text()'''
         return QString()
 
 
 class KModelIndexProxyMapper(QObject):
     """"""
     def __init__(self, leftModel, rightModel, parent = None):
         '''void KModelIndexProxyMapper.__init__(QAbstractItemModel leftModel, QAbstractItemModel rightModel, QObject parent = None)'''
     def mapSelectionRightToLeft(self, selection):
         '''QItemSelection KModelIndexProxyMapper.mapSelectionRightToLeft(QItemSelection selection)'''
         return QItemSelection()
     def mapSelectionLeftToRight(self, selection):
         '''QItemSelection KModelIndexProxyMapper.mapSelectionLeftToRight(QItemSelection selection)'''
         return QItemSelection()
     def mapRightToLeft(self, index):
         '''QModelIndex KModelIndexProxyMapper.mapRightToLeft(QModelIndex index)'''
         return QModelIndex()
     def mapLeftToRight(self, index):
         '''QModelIndex KModelIndexProxyMapper.mapLeftToRight(QModelIndex index)'''
         return QModelIndex()
 
 
 class KModifierKeyInfo(QObject):
     """"""
     def __init__(self, parent = None):
         '''void KModifierKeyInfo.__init__(QObject parent = None)'''
     keyRemoved = pyqtSignal() # void keyRemoved(Qt::Key) - signal
     keyAdded = pyqtSignal() # void keyAdded(Qt::Key) - signal
     buttonPressed = pyqtSignal() # void buttonPressed(Qt::MouseButton,bool) - signal
     keyLocked = pyqtSignal() # void keyLocked(Qt::Key,bool) - signal
     keyLatched = pyqtSignal() # void keyLatched(Qt::Key,bool) - signal
     keyPressed = pyqtSignal() # void keyPressed(Qt::Key,bool) - signal
     def isButtonPressed(self, button):
         '''bool KModifierKeyInfo.isButtonPressed(Qt.MouseButton button)'''
         return bool()
     def setKeyLocked(self, key, locked):
         '''bool KModifierKeyInfo.setKeyLocked(Qt.Key key, bool locked)'''
         return bool()
     def isKeyLocked(self, key):
         '''bool KModifierKeyInfo.isKeyLocked(Qt.Key key)'''
         return bool()
     def setKeyLatched(self, key, latched):
         '''bool KModifierKeyInfo.setKeyLatched(Qt.Key key, bool latched)'''
         return bool()
     def isKeyLatched(self, key):
         '''bool KModifierKeyInfo.isKeyLatched(Qt.Key key)'''
         return bool()
     def isKeyPressed(self, key):
         '''bool KModifierKeyInfo.isKeyPressed(Qt.Key key)'''
         return bool()
     def knownKeys(self):
         '''list-of-Qt.Key KModifierKeyInfo.knownKeys()'''
         return [Qt.Key()]
     def knowsKey(self, key):
         '''bool KModifierKeyInfo.knowsKey(Qt.Key key)'''
         return bool()
 
 
 class KMultiTabBar(QWidget):
     """"""
     # Enum KMultiTabBar.KMultiTabBarStyle
     VSNET = 0
     KDEV3ICON = 0
     STYLELAST = 0
 
     # Enum KMultiTabBar.KMultiTabBarPosition
     Left = 0
     Right = 0
     Top = 0
     Bottom = 0
 
     def __init__(self, pos, parent = None):
         '''void KMultiTabBar.__init__(KMultiTabBar.KMultiTabBarPosition pos, QWidget parent = None)'''
     def updateSeparator(self):
         '''void KMultiTabBar.updateSeparator()'''
     def fontChange(self):
         '''QFont KMultiTabBar.fontChange()'''
         return QFont()
     def tabStyle(self):
         '''KMultiTabBar.KMultiTabBarStyle KMultiTabBar.tabStyle()'''
         return KMultiTabBar.KMultiTabBarStyle()
     def setStyle(self, style):
         '''void KMultiTabBar.setStyle(KMultiTabBar.KMultiTabBarStyle style)'''
     def position(self):
         '''KMultiTabBar.KMultiTabBarPosition KMultiTabBar.position()'''
         return KMultiTabBar.KMultiTabBarPosition()
     def setPosition(self, pos):
         '''void KMultiTabBar.setPosition(KMultiTabBar.KMultiTabBarPosition pos)'''
     def tab(self, id):
         '''KMultiTabBarTab KMultiTabBar.tab(int id)'''
         return KMultiTabBarTab()
     def button(self, id):
         '''KMultiTabBarButton KMultiTabBar.button(int id)'''
         return KMultiTabBarButton()
     def isTabRaised(self, id):
         '''bool KMultiTabBar.isTabRaised(int id)'''
         return bool()
     def setTab(self, id, state):
         '''void KMultiTabBar.setTab(int id, bool state)'''
     def removeTab(self, id):
         '''void KMultiTabBar.removeTab(int id)'''
     def appendTab(self, pic, id = None, text = QString()):
         '''int KMultiTabBar.appendTab(QPixmap pic, int id = -1, QString text = QString())'''
         return int()
     def removeButton(self, id):
         '''void KMultiTabBar.removeButton(int id)'''
     def appendButton(self, pic, id = None, popup = None, not_used_yet = QString()):
         '''int KMultiTabBar.appendButton(QPixmap pic, int id = -1, QMenu popup = None, QString not_used_yet = QString())'''
         return int()
 
 
 class KMultiTabBarButton(QPushButton):
     """"""
     def __init__(self, pic, id, parent):
         '''QString KMultiTabBarButton.__init__(QPixmap pic, int id, QWidget parent)'''
         return QString()
     def paintEvent(self):
         '''QPaintEvent KMultiTabBarButton.paintEvent()'''
         return QPaintEvent()
     def showEvent(self):
         '''QShowEvent KMultiTabBarButton.showEvent()'''
         return QShowEvent()
     def hideEvent(self):
         '''QHideEvent KMultiTabBarButton.hideEvent()'''
         return QHideEvent()
     def slotClicked(self):
         '''void KMultiTabBarButton.slotClicked()'''
     clicked = pyqtSignal() # void clicked(int) - signal
     def setText(self, text):
         '''void KMultiTabBarButton.setText(QString text)'''
     def id(self):
         '''int KMultiTabBarButton.id()'''
         return int()
 
 
 class KMultiTabBarTab(KMultiTabBarButton):
     """"""
     def paintEvent(self):
         '''QPaintEvent KMultiTabBarTab.paintEvent()'''
         return QPaintEvent()
     def setIcon(self):
         '''QString KMultiTabBarTab.setIcon()'''
         return QString()
     def setIcon(self):
         '''QPixmap KMultiTabBarTab.setIcon()'''
         return QPixmap()
     def setState(self, state):
         '''void KMultiTabBarTab.setState(bool state)'''
     def setStyle(self):
         '''KMultiTabBar.KMultiTabBarStyle KMultiTabBarTab.setStyle()'''
         return KMultiTabBar.KMultiTabBarStyle()
     def setPosition(self):
         '''KMultiTabBar.KMultiTabBarPosition KMultiTabBarTab.setPosition()'''
         return KMultiTabBar.KMultiTabBarPosition()
     def minimumSizeHint(self):
         '''QSize KMultiTabBarTab.minimumSizeHint()'''
         return QSize()
     def sizeHint(self):
         '''QSize KMultiTabBarTab.sizeHint()'''
         return QSize()
 
 
 class KNewPasswordDialog(KDialog):
     """"""
     def __init__(self, parent = None):
         '''void KNewPasswordDialog.__init__(QWidget parent = None)'''
     newPassword = pyqtSignal() # void newPassword(const QStringamp;) - signal
     def checkAndGetPassword(self, pwd):
         '''bool KNewPasswordDialog.checkAndGetPassword(QString pwd)'''
         return bool()
     def checkPassword(self):
         '''QString KNewPasswordDialog.checkPassword()'''
         return QString()
     def accept(self):
         '''void KNewPasswordDialog.accept()'''
     def password(self):
         '''QString KNewPasswordDialog.password()'''
         return QString()
     def passwordStrengthWarningLevel(self):
         '''int KNewPasswordDialog.passwordStrengthWarningLevel()'''
         return int()
     def setPasswordStrengthWarningLevel(self, warningLevel):
         '''void KNewPasswordDialog.setPasswordStrengthWarningLevel(int warningLevel)'''
     def reasonablePasswordLength(self):
         '''int KNewPasswordDialog.reasonablePasswordLength()'''
         return int()
     def setReasonablePasswordLength(self, reasonableLength):
         '''void KNewPasswordDialog.setReasonablePasswordLength(int reasonableLength)'''
     def maximumPasswordLength(self):
         '''int KNewPasswordDialog.maximumPasswordLength()'''
         return int()
     def setMaximumPasswordLength(self, maxLength):
         '''void KNewPasswordDialog.setMaximumPasswordLength(int maxLength)'''
     def minimumPasswordLength(self):
         '''int KNewPasswordDialog.minimumPasswordLength()'''
         return int()
     def setMinimumPasswordLength(self, minLength):
         '''void KNewPasswordDialog.setMinimumPasswordLength(int minLength)'''
     def allowEmptyPasswords(self):
         '''bool KNewPasswordDialog.allowEmptyPasswords()'''
         return bool()
     def setAllowEmptyPasswords(self, allowed):
         '''void KNewPasswordDialog.setAllowEmptyPasswords(bool allowed)'''
     def pixmap(self):
         '''QPixmap KNewPasswordDialog.pixmap()'''
         return QPixmap()
     def setPixmap(self):
         '''QPixmap KNewPasswordDialog.setPixmap()'''
         return QPixmap()
     def prompt(self):
         '''QString KNewPasswordDialog.prompt()'''
         return QString()
     def setPrompt(self, prompt):
         '''void KNewPasswordDialog.setPrompt(QString prompt)'''
 
 
 class KNotification(QObject):
     """"""
     # Enum KNotification.StandardEvent
     Notification = 0
     Warning = 0
     Error = 0
     Catastrophe = 0
 
     # Enum KNotification.NotificationFlag
     RaiseWidgetOnActivation = 0
     CloseOnTimeout = 0
     Persistent = 0
     CloseWhenWidgetActivated = 0
     Persistant = 0
     DefaultEvent = 0
 
     def __init__(self, eventId, widget = None, flags = None):
         '''void KNotification.__init__(QString eventId, QWidget widget = None, KNotification.NotificationFlags flags = KNotification.CloseOnTimeout)'''
     def __init__(self, eventId, flags, parent = None):
         '''void KNotification.__init__(QString eventId, KNotification.NotificationFlags flags, QObject parent = None)'''
     def beep(self, reason = QString(), widget = None):
         '''static void KNotification.beep(QString reason = QString(), QWidget widget = None)'''
     def event(self, eventId, text = QString(), pixmap = QPixmap(), widget = None, flags = None, componentData = KComponentData()):
         '''static KNotification KNotification.event(QString eventId, QString text = QString(), QPixmap pixmap = QPixmap(), QWidget widget = None, KNotification.NotificationFlags flags = KNotification.CloseOnTimeout, KComponentData componentData = KComponentData())'''
         return KNotification()
     def event(self, eventId, text = QString(), pixmap = QPixmap(), widget = None, flags = None):
         '''static KNotification KNotification.event(KNotification.StandardEvent eventId, QString text = QString(), QPixmap pixmap = QPixmap(), QWidget widget = None, KNotification.NotificationFlags flags = KNotification.CloseOnTimeout)'''
         return KNotification()
     def event(self, eventId, title, text, pixmap = QPixmap(), widget = None, flags = None, componentData = KComponentData()):
         '''static KNotification KNotification.event(QString eventId, QString title, QString text, QPixmap pixmap = QPixmap(), QWidget widget = None, KNotification.NotificationFlags flags = KNotification.CloseOnTimeout, KComponentData componentData = KComponentData())'''
         return KNotification()
     def event(self, eventId, title, text, pixmap = QPixmap(), widget = None, flags = None):
         '''static KNotification KNotification.event(KNotification.StandardEvent eventId, QString title, QString text, QPixmap pixmap = QPixmap(), QWidget widget = None, KNotification.NotificationFlags flags = KNotification.CloseOnTimeout)'''
         return KNotification()
     def eventFilter(self, watched, event):
         '''bool KNotification.eventFilter(QObject watched, QEvent event)'''
         return bool()
     def update(self):
         '''void KNotification.update()'''
     def sendEvent(self):
         '''void KNotification.sendEvent()'''
     def deref(self):
         '''void KNotification.deref()'''
     def ref(self):
         '''void KNotification.ref()'''
     def raiseWidget(self):
         '''void KNotification.raiseWidget()'''
     def close(self):
         '''void KNotification.close()'''
     def activate(self, action = 0):
         '''void KNotification.activate(int action = 0)'''
     ignored = pyqtSignal() # void ignored() - signal
     closed = pyqtSignal() # void closed() - signal
     action3Activated = pyqtSignal() # void action3Activated() - signal
     action2Activated = pyqtSignal() # void action2Activated() - signal
     action1Activated = pyqtSignal() # void action1Activated() - signal
     activated = pyqtSignal() # void activated() - signal
     activated = pyqtSignal() # void activated(uint) - signal
     def setComponentData(self, componentData):
         '''void KNotification.setComponentData(KComponentData componentData)'''
     def setFlags(self, flags):
         '''void KNotification.setFlags(KNotification.NotificationFlags flags)'''
     def flags(self):
         '''KNotification.NotificationFlags KNotification.flags()'''
         return KNotification.NotificationFlags()
     def addContext(self, context):
         '''void KNotification.addContext(unknown-type context)'''
     def addContext(self, context_key, context_value):
         '''void KNotification.addContext(QString context_key, QString context_value)'''
     def setContexts(self, contexts):
         '''void KNotification.setContexts(list-of-tuple-of-QString-QString contexts)'''
     def contexts(self):
         '''list-of-tuple-of-QString-QString KNotification.contexts()'''
         return [tuple-of-QString-QString()]
     def setActions(self, actions):
         '''void KNotification.setActions(QStringList actions)'''
     def actions(self):
         '''QStringList KNotification.actions()'''
         return QStringList()
     def setPixmap(self, pix):
         '''void KNotification.setPixmap(QPixmap pix)'''
     def pixmap(self):
         '''QPixmap KNotification.pixmap()'''
         return QPixmap()
     def setText(self, text):
         '''void KNotification.setText(QString text)'''
     def text(self):
         '''QString KNotification.text()'''
         return QString()
     def setTitle(self, title):
         '''void KNotification.setTitle(QString title)'''
     def title(self):
         '''QString KNotification.title()'''
         return QString()
     def eventId(self):
         '''QString KNotification.eventId()'''
         return QString()
     def setWidget(self, widget):
         '''void KNotification.setWidget(QWidget widget)'''
     def widget(self):
         '''QWidget KNotification.widget()'''
         return QWidget()
     class NotificationFlags():
         """"""
         def __init__(self):
             '''KNotification.NotificationFlags KNotification.NotificationFlags.__init__()'''
             return KNotification.NotificationFlags()
         def __init__(self):
             '''int KNotification.NotificationFlags.__init__()'''
             return int()
         def __init__(self):
             '''void KNotification.NotificationFlags.__init__()'''
         def __bool__(self):
             '''int KNotification.NotificationFlags.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KNotification.NotificationFlags.__ne__(KNotification.NotificationFlags f)'''
             return bool()
         def __eq__(self, f):
             '''bool KNotification.NotificationFlags.__eq__(KNotification.NotificationFlags f)'''
             return bool()
         def __invert__(self):
             '''KNotification.NotificationFlags KNotification.NotificationFlags.__invert__()'''
             return KNotification.NotificationFlags()
         def __and__(self, mask):
             '''KNotification.NotificationFlags KNotification.NotificationFlags.__and__(int mask)'''
             return KNotification.NotificationFlags()
         def __xor__(self, f):
             '''KNotification.NotificationFlags KNotification.NotificationFlags.__xor__(KNotification.NotificationFlags f)'''
             return KNotification.NotificationFlags()
         def __xor__(self, f):
             '''KNotification.NotificationFlags KNotification.NotificationFlags.__xor__(int f)'''
             return KNotification.NotificationFlags()
         def __or__(self, f):
             '''KNotification.NotificationFlags KNotification.NotificationFlags.__or__(KNotification.NotificationFlags f)'''
             return KNotification.NotificationFlags()
         def __or__(self, f):
             '''KNotification.NotificationFlags KNotification.NotificationFlags.__or__(int f)'''
             return KNotification.NotificationFlags()
         def __int__(self):
             '''int KNotification.NotificationFlags.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KNotification.NotificationFlags KNotification.NotificationFlags.__ixor__(KNotification.NotificationFlags f)'''
             return KNotification.NotificationFlags()
         def __ior__(self, f):
             '''KNotification.NotificationFlags KNotification.NotificationFlags.__ior__(KNotification.NotificationFlags f)'''
             return KNotification.NotificationFlags()
         def __iand__(self, mask):
             '''KNotification.NotificationFlags KNotification.NotificationFlags.__iand__(int mask)'''
             return KNotification.NotificationFlags()
 
 
 class KNotificationRestrictions(QObject):
     """"""
     # Enum KNotificationRestrictions.Service
     NoServices = 0
     ScreenSaver = 0
     MessagingPopups = 0
     Notifications = 0
     CriticalNotifications = 0
     NonCriticalServices = 0
     AllServices = 0
 
     def __init__(self, control = None, parent = None):
         '''void KNotificationRestrictions.__init__(KNotificationRestrictions.Services control = KNotificationRestrictions.NonCriticalServices, QObject parent = None)'''
     class Services():
         """"""
         def __init__(self):
             '''KNotificationRestrictions.Services KNotificationRestrictions.Services.__init__()'''
             return KNotificationRestrictions.Services()
         def __init__(self):
             '''int KNotificationRestrictions.Services.__init__()'''
             return int()
         def __init__(self):
             '''void KNotificationRestrictions.Services.__init__()'''
         def __bool__(self):
             '''int KNotificationRestrictions.Services.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KNotificationRestrictions.Services.__ne__(KNotificationRestrictions.Services f)'''
             return bool()
         def __eq__(self, f):
             '''bool KNotificationRestrictions.Services.__eq__(KNotificationRestrictions.Services f)'''
             return bool()
         def __invert__(self):
             '''KNotificationRestrictions.Services KNotificationRestrictions.Services.__invert__()'''
             return KNotificationRestrictions.Services()
         def __and__(self, mask):
             '''KNotificationRestrictions.Services KNotificationRestrictions.Services.__and__(int mask)'''
             return KNotificationRestrictions.Services()
         def __xor__(self, f):
             '''KNotificationRestrictions.Services KNotificationRestrictions.Services.__xor__(KNotificationRestrictions.Services f)'''
             return KNotificationRestrictions.Services()
         def __xor__(self, f):
             '''KNotificationRestrictions.Services KNotificationRestrictions.Services.__xor__(int f)'''
             return KNotificationRestrictions.Services()
         def __or__(self, f):
             '''KNotificationRestrictions.Services KNotificationRestrictions.Services.__or__(KNotificationRestrictions.Services f)'''
             return KNotificationRestrictions.Services()
         def __or__(self, f):
             '''KNotificationRestrictions.Services KNotificationRestrictions.Services.__or__(int f)'''
             return KNotificationRestrictions.Services()
         def __int__(self):
             '''int KNotificationRestrictions.Services.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KNotificationRestrictions.Services KNotificationRestrictions.Services.__ixor__(KNotificationRestrictions.Services f)'''
             return KNotificationRestrictions.Services()
         def __ior__(self, f):
             '''KNotificationRestrictions.Services KNotificationRestrictions.Services.__ior__(KNotificationRestrictions.Services f)'''
             return KNotificationRestrictions.Services()
         def __iand__(self, mask):
             '''KNotificationRestrictions.Services KNotificationRestrictions.Services.__iand__(int mask)'''
             return KNotificationRestrictions.Services()
 
 
 class KNumInput(QWidget):
     """"""
     def __init__(self, parent = None):
         '''void KNumInput.__init__(QWidget parent = None)'''
     def __init__(self, parent, below):
         '''void KNumInput.__init__(QWidget parent, KNumInput below)'''
     def doLayout(self):
         '''abstract void KNumInput.doLayout()'''
     def layout(self, deep):
         '''void KNumInput.layout(bool deep)'''
     def slider(self):
         '''QSlider KNumInput.slider()'''
         return QSlider()
     def sizeHint(self):
         '''QSize KNumInput.sizeHint()'''
         return QSize()
     def setSteps(self, minor, major):
         '''void KNumInput.setSteps(int minor, int major)'''
     def showSlider(self):
         '''bool KNumInput.showSlider()'''
         return bool()
     def label(self):
         '''QString KNumInput.label()'''
         return QString()
     def setLabel(self, label, a = None):
         '''void KNumInput.setLabel(QString label, Qt.Alignment a = Qt.AlignLeft|Qt.AlignTop)'''
 
 
 class KIntNumInput(KNumInput):
     """"""
     def __init__(self, parent = None):
         '''void KIntNumInput.__init__(QWidget parent = None)'''
     def __init__(self, value, parent = None, base = 10):
         '''void KIntNumInput.__init__(int value, QWidget parent = None, int base = 10)'''
     def __init__(self, below, value, parent, base = 10):
         '''void KIntNumInput.__init__(KNumInput below, int value, QWidget parent, int base = 10)'''
     def resizeEvent(self):
         '''QResizeEvent KIntNumInput.resizeEvent()'''
         return QResizeEvent()
     def doLayout(self):
         '''void KIntNumInput.doLayout()'''
     def spinBox(self):
         '''QSpinBox KIntNumInput.spinBox()'''
         return QSpinBox()
     relativeValueChanged = pyqtSignal() # void relativeValueChanged(double) - signal
     valueChanged = pyqtSignal() # void valueChanged(int) - signal
     def setEditFocus(self, mark = True):
         '''void KIntNumInput.setEditFocus(bool mark = True)'''
     def setPrefix(self, prefix):
         '''void KIntNumInput.setPrefix(QString prefix)'''
     def setSuffix(self, suffix):
         '''void KIntNumInput.setSuffix(QString suffix)'''
     def setSuffix(self, suffix):
         '''void KIntNumInput.setSuffix(KLocalizedString suffix)'''
     def setReferencePoint(self):
         '''int KIntNumInput.setReferencePoint()'''
         return int()
     def setRelativeValue(self):
         '''float KIntNumInput.setRelativeValue()'''
         return float()
     def setValue(self):
         '''int KIntNumInput.setValue()'''
         return int()
     def minimumSizeHint(self):
         '''QSize KIntNumInput.minimumSizeHint()'''
         return QSize()
     def setLabel(self, label, a = None):
         '''void KIntNumInput.setLabel(QString label, Qt.Alignment a = Qt.AlignLeft|Qt.AlignTop)'''
     def setSpecialValueText(self, text):
         '''void KIntNumInput.setSpecialValueText(QString text)'''
     def setSingleStep(self, step):
         '''void KIntNumInput.setSingleStep(int step)'''
     def singleStep(self):
         '''int KIntNumInput.singleStep()'''
         return int()
     def maximum(self):
         '''int KIntNumInput.maximum()'''
         return int()
     def setMaximum(self, max):
         '''void KIntNumInput.setMaximum(int max)'''
     def minimum(self):
         '''int KIntNumInput.minimum()'''
         return int()
     def setMinimum(self, min):
         '''void KIntNumInput.setMinimum(int min)'''
     def setSliderEnabled(self, enabled = True):
         '''void KIntNumInput.setSliderEnabled(bool enabled = True)'''
     def setRange(self, min, max, singleStep = 1):
         '''void KIntNumInput.setRange(int min, int max, int singleStep = 1)'''
     def setRange(self, min, max, singleStep, slider):
         '''void KIntNumInput.setRange(int min, int max, int singleStep, bool slider)'''
     def specialValueText(self):
         '''QString KIntNumInput.specialValueText()'''
         return QString()
     def prefix(self):
         '''QString KIntNumInput.prefix()'''
         return QString()
     def suffix(self):
         '''QString KIntNumInput.suffix()'''
         return QString()
     def referencePoint(self):
         '''int KIntNumInput.referencePoint()'''
         return int()
     def relativeValue(self):
         '''float KIntNumInput.relativeValue()'''
         return float()
     def value(self):
         '''int KIntNumInput.value()'''
         return int()
 
 
 class KDoubleNumInput(KNumInput):
     """"""
     def __init__(self, parent = None):
         '''void KDoubleNumInput.__init__(QWidget parent = None)'''
     def __init__(self, lower, upper, value, parent = None, singleStep = None, precision = 2):
         '''void KDoubleNumInput.__init__(float lower, float upper, float value, QWidget parent = None, float singleStep = 0.01, int precision = 2)'''
     def __init__(self, below, lower, upper, value, parent = None, singleStep = None, precision = 2):
         '''void KDoubleNumInput.__init__(KNumInput below, float lower, float upper, float value, QWidget parent = None, float singleStep = 0.02, int precision = 2)'''
     def resizeEvent(self):
         '''QResizeEvent KDoubleNumInput.resizeEvent()'''
         return QResizeEvent()
     def doLayout(self):
         '''void KDoubleNumInput.doLayout()'''
     relativeValueChanged = pyqtSignal() # void relativeValueChanged(double) - signal
     valueChanged = pyqtSignal() # void valueChanged(double) - signal
     def setPrefix(self, prefix):
         '''void KDoubleNumInput.setPrefix(QString prefix)'''
     def setSuffix(self, suffix):
         '''void KDoubleNumInput.setSuffix(QString suffix)'''
     def setReferencePoint(self, ref):
         '''void KDoubleNumInput.setReferencePoint(float ref)'''
     def setRelativeValue(self):
         '''float KDoubleNumInput.setRelativeValue()'''
         return float()
     def setValue(self):
         '''float KDoubleNumInput.setValue()'''
         return float()
     def setExponentRatio(self, dbl):
         '''void KDoubleNumInput.setExponentRatio(float dbl)'''
     def exponentRatio(self):
         '''float KDoubleNumInput.exponentRatio()'''
         return float()
     def minimumSizeHint(self):
         '''QSize KDoubleNumInput.minimumSizeHint()'''
         return QSize()
     def setLabel(self, label, a = None):
         '''void KDoubleNumInput.setLabel(QString label, Qt.Alignment a = Qt.AlignLeft|Qt.AlignTop)'''
     def setSpecialValueText(self, text):
         '''void KDoubleNumInput.setSpecialValueText(QString text)'''
     def relativeValue(self):
         '''float KDoubleNumInput.relativeValue()'''
         return float()
     def referencePoint(self):
         '''float KDoubleNumInput.referencePoint()'''
         return float()
     def setPrecision(self, precision):
         '''void KDoubleNumInput.setPrecision(int precision)'''
     def setDecimals(self, decimals):
         '''void KDoubleNumInput.setDecimals(int decimals)'''
     def setSingleStep(self, singleStep):
         '''void KDoubleNumInput.setSingleStep(float singleStep)'''
     def singleStep(self):
         '''float KDoubleNumInput.singleStep()'''
         return float()
     def maximum(self):
         '''float KDoubleNumInput.maximum()'''
         return float()
     def setMaximum(self, max):
         '''void KDoubleNumInput.setMaximum(float max)'''
     def minimum(self):
         '''float KDoubleNumInput.minimum()'''
         return float()
     def setMinimum(self, min):
         '''void KDoubleNumInput.setMinimum(float min)'''
     def setSliderEnabled(self, enabled):
         '''void KDoubleNumInput.setSliderEnabled(bool enabled)'''
     def setRange(self, min, max, singleStep = 1, slider = True):
         '''void KDoubleNumInput.setRange(float min, float max, float singleStep = 1, bool slider = True)'''
     def specialValueText(self):
         '''QString KDoubleNumInput.specialValueText()'''
         return QString()
     def decimals(self):
         '''int KDoubleNumInput.decimals()'''
         return int()
     def prefix(self):
         '''QString KDoubleNumInput.prefix()'''
         return QString()
     def suffix(self):
         '''QString KDoubleNumInput.suffix()'''
         return QString()
     def value(self):
         '''float KDoubleNumInput.value()'''
         return float()
 
 
 class KIntSpinBox(QSpinBox):
     """"""
     def __init__(self, parent = None):
         '''void KIntSpinBox.__init__(QWidget parent = None)'''
     def __init__(self, lower, upper, singleStep, value, parent, base = 10):
         '''void KIntSpinBox.__init__(int lower, int upper, int singleStep, int value, QWidget parent, int base = 10)'''
     def valueFromText(self, text):
         '''int KIntSpinBox.valueFromText(QString text)'''
         return int()
     def textFromValue(self):
         '''int KIntSpinBox.textFromValue()'''
         return int()
     def setSuffix(self, suffix):
         '''void KIntSpinBox.setSuffix(KLocalizedString suffix)'''
     def setEditFocus(self, mark):
         '''void KIntSpinBox.setEditFocus(bool mark)'''
     def base(self):
         '''int KIntSpinBox.base()'''
         return int()
     def setBase(self, base):
         '''void KIntSpinBox.setBase(int base)'''
 
 
 class KIntValidator(QValidator):
     """"""
     def __init__(self, parent, base = 10):
         '''void KIntValidator.__init__(QWidget parent, int base = 10)'''
     def __init__(self, bottom, top, parent, base = 10):
         '''void KIntValidator.__init__(int bottom, int top, QWidget parent, int base = 10)'''
     def base(self):
         '''int KIntValidator.base()'''
         return int()
     def top(self):
         '''int KIntValidator.top()'''
         return int()
     def bottom(self):
         '''int KIntValidator.bottom()'''
         return int()
     def setBase(self, base):
         '''void KIntValidator.setBase(int base)'''
     def setRange(self, bottom, top):
         '''void KIntValidator.setRange(int bottom, int top)'''
     def fixup(self):
         '''QString KIntValidator.fixup()'''
         return QString()
     def validate(self):
         '''int KIntValidator.validate()'''
         return int()
 
 
 class KFloatValidator(QValidator):
     """"""
     def __init__(self, parent):
         '''void KFloatValidator.__init__(QWidget parent)'''
     def __init__(self, bottom, top, parent):
         '''void KFloatValidator.__init__(float bottom, float top, QWidget parent)'''
     def __init__(self, bottom, top, localeAware, parent):
         '''void KFloatValidator.__init__(float bottom, float top, bool localeAware, QWidget parent)'''
     def acceptLocalizedNumbers(self):
         '''bool KFloatValidator.acceptLocalizedNumbers()'''
         return bool()
     def setAcceptLocalizedNumbers(self, b):
         '''void KFloatValidator.setAcceptLocalizedNumbers(bool b)'''
     def top(self):
         '''float KFloatValidator.top()'''
         return float()
     def bottom(self):
         '''float KFloatValidator.bottom()'''
         return float()
     def setRange(self, bottom, top):
         '''void KFloatValidator.setRange(float bottom, float top)'''
     def fixup(self):
         '''QString KFloatValidator.fixup()'''
         return QString()
     def validate(self):
         '''int KFloatValidator.validate()'''
         return int()
 
 
 class KDoubleValidator(QDoubleValidator):
     """"""
     def __init__(self, parent):
         '''void KDoubleValidator.__init__(QObject parent)'''
     def __init__(self, bottom, top, decimals, parent):
         '''void KDoubleValidator.__init__(float bottom, float top, int decimals, QObject parent)'''
     def setAcceptLocalizedNumbers(self, accept):
         '''void KDoubleValidator.setAcceptLocalizedNumbers(bool accept)'''
     def acceptLocalizedNumbers(self):
         '''bool KDoubleValidator.acceptLocalizedNumbers()'''
         return bool()
     def validate(self, input, pos):
         '''QValidator.State KDoubleValidator.validate(QString input, int pos)'''
         return QValidator.State()
 
 
 class KPageModel(QAbstractItemModel):
     """"""
     # Enum KPageModel.Role
     HeaderRole = 0
     WidgetRole = 0
 
     def __init__(self, parent = None):
         '''void KPageModel.__init__(QObject parent = None)'''
 
 
 class KPageView(QWidget):
     """"""
     # Enum KPageView.FaceType
     Auto = 0
     Plain = 0
     List = 0
     Tree = 0
     Tabbed = 0
 
     def __init__(self, parent = None):
         '''void KPageView.__init__(QWidget parent = None)'''
     def viewPosition(self):
         '''Qt.Alignment KPageView.viewPosition()'''
         return Qt.Alignment()
     def showPageHeader(self):
         '''bool KPageView.showPageHeader()'''
         return bool()
     def createView(self):
         '''QAbstractItemView KPageView.createView()'''
         return QAbstractItemView()
     currentPageChanged = pyqtSignal() # void currentPageChanged(const QModelIndexamp;,const QModelIndexamp;) - signal
     def setDefaultWidget(self, widget):
         '''void KPageView.setDefaultWidget(QWidget widget)'''
     def itemDelegate(self):
         '''QAbstractItemDelegate KPageView.itemDelegate()'''
         return QAbstractItemDelegate()
     def setItemDelegate(self, delegate):
         '''void KPageView.setItemDelegate(QAbstractItemDelegate delegate)'''
     def currentPage(self):
         '''QModelIndex KPageView.currentPage()'''
         return QModelIndex()
     def setCurrentPage(self, index):
         '''void KPageView.setCurrentPage(QModelIndex index)'''
     def faceType(self):
         '''KPageView.FaceType KPageView.faceType()'''
         return KPageView.FaceType()
     def setFaceType(self, faceType):
         '''void KPageView.setFaceType(KPageView.FaceType faceType)'''
     def model(self):
         '''QAbstractItemModel KPageView.model()'''
         return QAbstractItemModel()
     def setModel(self, model):
         '''void KPageView.setModel(QAbstractItemModel model)'''
 
 
 class KPageWidget(KPageView):
     """"""
     def __init__(self, parent = None):
         '''void KPageWidget.__init__(QWidget parent = None)'''
     pageRemoved = pyqtSignal() # void pageRemoved(KPageWidgetItem *) - signal
     pageToggled = pyqtSignal() # void pageToggled(KPageWidgetItem *,bool) - signal
     currentPageChanged = pyqtSignal() # void currentPageChanged(KPageWidgetItem *,KPageWidgetItem *) - signal
     def currentPage(self):
         '''KPageWidgetItem KPageWidget.currentPage()'''
         return KPageWidgetItem()
     def setCurrentPage(self, item):
         '''void KPageWidget.setCurrentPage(KPageWidgetItem item)'''
     def removePage(self, item):
         '''void KPageWidget.removePage(KPageWidgetItem item)'''
     def addSubPage(self, parent, widget, name):
         '''KPageWidgetItem KPageWidget.addSubPage(KPageWidgetItem parent, QWidget widget, QString name)'''
         return KPageWidgetItem()
     def addSubPage(self, parent, item):
         '''void KPageWidget.addSubPage(KPageWidgetItem parent, KPageWidgetItem item)'''
     def insertPage(self, before, widget, name):
         '''KPageWidgetItem KPageWidget.insertPage(KPageWidgetItem before, QWidget widget, QString name)'''
         return KPageWidgetItem()
     def insertPage(self, before, item):
         '''void KPageWidget.insertPage(KPageWidgetItem before, KPageWidgetItem item)'''
     def addPage(self, widget, name):
         '''KPageWidgetItem KPageWidget.addPage(QWidget widget, QString name)'''
         return KPageWidgetItem()
     def addPage(self, item):
         '''void KPageWidget.addPage(KPageWidgetItem item)'''
 
 
 class KPageWidgetItem(QObject):
     """"""
     def __init__(self, widget):
         '''void KPageWidgetItem.__init__(QWidget widget)'''
     def __init__(self, widget, name):
         '''void KPageWidgetItem.__init__(QWidget widget, QString name)'''
     toggled = pyqtSignal() # void toggled(bool) - signal
     changed = pyqtSignal() # void changed() - signal
     def setChecked(self, checked):
         '''void KPageWidgetItem.setChecked(bool checked)'''
     def setEnabled(self):
         '''bool KPageWidgetItem.setEnabled()'''
         return bool()
     def isEnabled(self):
         '''bool KPageWidgetItem.isEnabled()'''
         return bool()
     def isChecked(self):
         '''bool KPageWidgetItem.isChecked()'''
         return bool()
     def isCheckable(self):
         '''bool KPageWidgetItem.isCheckable()'''
         return bool()
     def setCheckable(self, checkable):
         '''void KPageWidgetItem.setCheckable(bool checkable)'''
     def icon(self):
         '''KIcon KPageWidgetItem.icon()'''
         return KIcon()
     def setIcon(self, icon):
         '''void KPageWidgetItem.setIcon(KIcon icon)'''
     def header(self):
         '''QString KPageWidgetItem.header()'''
         return QString()
     def setHeader(self, header):
         '''void KPageWidgetItem.setHeader(QString header)'''
     def name(self):
         '''QString KPageWidgetItem.name()'''
         return QString()
     def setName(self, name):
         '''void KPageWidgetItem.setName(QString name)'''
     def widget(self):
         '''QWidget KPageWidgetItem.widget()'''
         return QWidget()
 
 
 class KPageWidgetModel(KPageModel):
     """"""
     def __init__(self, parent = None):
         '''void KPageWidgetModel.__init__(QObject parent = None)'''
     toggled = pyqtSignal() # void toggled(KPageWidgetItem *,bool) - signal
     def item(self, index):
         '''KPageWidgetItem KPageWidgetModel.item(QModelIndex index)'''
         return KPageWidgetItem()
     def rowCount(self, parent = QModelIndex()):
         '''int KPageWidgetModel.rowCount(QModelIndex parent = QModelIndex())'''
         return int()
     def parent(self, index):
         '''QModelIndex KPageWidgetModel.parent(QModelIndex index)'''
         return QModelIndex()
     def index(self, row, column, parent = QModelIndex()):
         '''QModelIndex KPageWidgetModel.index(int row, int column, QModelIndex parent = QModelIndex())'''
         return QModelIndex()
     def index(self, item):
         '''QModelIndex KPageWidgetModel.index(KPageWidgetItem item)'''
         return QModelIndex()
     def flags(self, index):
         '''Qt.ItemFlags KPageWidgetModel.flags(QModelIndex index)'''
         return Qt.ItemFlags()
     def setData(self, index, value, role = None):
         '''bool KPageWidgetModel.setData(QModelIndex index, QVariant value, int role = Qt.EditRole)'''
         return bool()
     def data(self, index, role = None):
         '''QVariant KPageWidgetModel.data(QModelIndex index, int role = Qt.DisplayRole)'''
         return QVariant()
     def columnCount(self, parent = QModelIndex()):
         '''int KPageWidgetModel.columnCount(QModelIndex parent = QModelIndex())'''
         return int()
     def removePage(self, item):
         '''void KPageWidgetModel.removePage(KPageWidgetItem item)'''
     def addSubPage(self, parent, widget, name):
         '''KPageWidgetItem KPageWidgetModel.addSubPage(KPageWidgetItem parent, QWidget widget, QString name)'''
         return KPageWidgetItem()
     def addSubPage(self, parent, item):
         '''void KPageWidgetModel.addSubPage(KPageWidgetItem parent, KPageWidgetItem item)'''
     def insertPage(self, before, widget, name):
         '''KPageWidgetItem KPageWidgetModel.insertPage(KPageWidgetItem before, QWidget widget, QString name)'''
         return KPageWidgetItem()
     def insertPage(self, before, item):
         '''void KPageWidgetModel.insertPage(KPageWidgetItem before, KPageWidgetItem item)'''
     def addPage(self, widget, name):
         '''KPageWidgetItem KPageWidgetModel.addPage(QWidget widget, QString name)'''
         return KPageWidgetItem()
     def addPage(self, item):
         '''void KPageWidgetModel.addPage(KPageWidgetItem item)'''
 
 
 class KPassivePopup(QFrame):
     """"""
     # Enum KPassivePopup.PopupStyle
     Boxed = 0
     Balloon = 0
     CustomStyle = 0
 
     def __init__(self, parent = None, f = 0):
         '''void KPassivePopup.__init__(QWidget parent = None, Qt.WindowFlags f = 0)'''
     def __init__(self, parent):
         '''void KPassivePopup.__init__(int parent)'''
     def paintEvent(self, pe):
         '''void KPassivePopup.paintEvent(QPaintEvent pe)'''
     def updateMask(self):
         '''void KPassivePopup.updateMask()'''
     def mouseReleaseEvent(self, e):
         '''void KPassivePopup.mouseReleaseEvent(QMouseEvent e)'''
     def calculateNearbyPoint(self, target):
         '''QPoint KPassivePopup.calculateNearbyPoint(QRect target)'''
         return QPoint()
     def moveNear(self, target):
         '''void KPassivePopup.moveNear(QRect target)'''
     def hideEvent(self):
         '''QHideEvent KPassivePopup.hideEvent()'''
         return QHideEvent()
     def positionSelf(self):
         '''void KPassivePopup.positionSelf()'''
     clicked = pyqtSignal() # void clicked() - signal
     clicked = pyqtSignal() # void clicked(const QPointamp;) - signal
     def setVisible(self, visible):
         '''void KPassivePopup.setVisible(bool visible)'''
     def show(self):
         '''void KPassivePopup.show()'''
     def show(self, p):
         '''void KPassivePopup.show(QPoint p)'''
     def setPopupStyle(self, popupstyle):
         '''void KPassivePopup.setPopupStyle(int popupstyle)'''
     def setTimeout(self, delay):
         '''void KPassivePopup.setTimeout(int delay)'''
     def message(self, text, parent):
         '''static KPassivePopup KPassivePopup.message(QString text, QWidget parent)'''
         return KPassivePopup()
     def message(self, text, parent):
         '''static KPassivePopup KPassivePopup.message(QString text, QSystemTrayIcon parent)'''
         return KPassivePopup()
     def message(self, caption, text, parent):
         '''static KPassivePopup KPassivePopup.message(QString caption, QString text, QWidget parent)'''
         return KPassivePopup()
     def message(self, caption, text, parent):
         '''static KPassivePopup KPassivePopup.message(QString caption, QString text, QSystemTrayIcon parent)'''
         return KPassivePopup()
     def message(self, caption, text, icon, parent, timeout = None):
         '''static KPassivePopup KPassivePopup.message(QString caption, QString text, QPixmap icon, QWidget parent, int timeout = -1)'''
         return KPassivePopup()
     def message(self, caption, text, icon, parent, timeout = None):
         '''static KPassivePopup KPassivePopup.message(QString caption, QString text, QPixmap icon, QSystemTrayIcon parent, int timeout = -1)'''
         return KPassivePopup()
     def message(self, caption, text, icon, parent, timeout = None):
         '''static KPassivePopup KPassivePopup.message(QString caption, QString text, QPixmap icon, int parent, int timeout = -1)'''
         return KPassivePopup()
     def message(self, popupStyle, text, parent):
         '''static KPassivePopup KPassivePopup.message(int popupStyle, QString text, QWidget parent)'''
         return KPassivePopup()
     def message(self, popupStyle, text, parent):
         '''static KPassivePopup KPassivePopup.message(int popupStyle, QString text, QSystemTrayIcon parent)'''
         return KPassivePopup()
     def message(self, popupStyle, caption, text, parent):
         '''static KPassivePopup KPassivePopup.message(int popupStyle, QString caption, QString text, QSystemTrayIcon parent)'''
         return KPassivePopup()
     def message(self, popupStyle, caption, text, parent):
         '''static KPassivePopup KPassivePopup.message(int popupStyle, QString caption, QString text, QWidget parent)'''
         return KPassivePopup()
     def message(self, popupStyle, caption, text, icon, parent, timeout = None):
         '''static KPassivePopup KPassivePopup.message(int popupStyle, QString caption, QString text, QPixmap icon, QWidget parent, int timeout = -1)'''
         return KPassivePopup()
     def message(self, popupStyle, caption, text, icon, parent, timeout = None):
         '''static KPassivePopup KPassivePopup.message(int popupStyle, QString caption, QString text, QPixmap icon, QSystemTrayIcon parent, int timeout = -1)'''
         return KPassivePopup()
     def message(self, popupStyle, caption, text, icon, parent, timeout = None):
         '''static KPassivePopup KPassivePopup.message(int popupStyle, QString caption, QString text, QPixmap icon, int parent, int timeout = -1)'''
         return KPassivePopup()
     def setAnchor(self, anchor):
         '''void KPassivePopup.setAnchor(QPoint anchor)'''
     def anchor(self):
         '''QPoint KPassivePopup.anchor()'''
         return QPoint()
     def defaultArea(self):
         '''QRect KPassivePopup.defaultArea()'''
         return QRect()
     def autoDelete(self):
         '''bool KPassivePopup.autoDelete()'''
         return bool()
     def setAutoDelete(self, autoDelete):
         '''void KPassivePopup.setAutoDelete(bool autoDelete)'''
     def timeout(self):
         '''int KPassivePopup.timeout()'''
         return int()
     def view(self):
         '''QWidget KPassivePopup.view()'''
         return QWidget()
     def standardView(self, caption, text, icon, parent = None):
         '''KVBox KPassivePopup.standardView(QString caption, QString text, QPixmap icon, QWidget parent = None)'''
         return KVBox()
     def setView(self, child):
         '''void KPassivePopup.setView(QWidget child)'''
     def setView(self, caption, text = QString()):
         '''void KPassivePopup.setView(QString caption, QString text = QString())'''
     def setView(self, caption, text, icon):
         '''void KPassivePopup.setView(QString caption, QString text, QPixmap icon)'''
 
 
 class KPassivePopupMessageHandler(QObject, KMessageHandler):
     """"""
     def __init__(self, parent = None):
         '''void KPassivePopupMessageHandler.__init__(QWidget parent = None)'''
     def message(self, messageType, text, caption):
         '''void KPassivePopupMessageHandler.message(KMessage.MessageType messageType, QString text, QString caption)'''
 
 
 class KPasswordDialog(KDialog):
     """"""
     # Enum KPasswordDialog.ErrorType
     UnknownError = 0
     UsernameError = 0
     PasswordError = 0
     FatalError = 0
     DomainError = 0
 
     # Enum KPasswordDialog.KPasswordDialogFlag
     NoFlags = 0
     ShowKeepPassword = 0
     ShowUsernameLine = 0
     UsernameReadOnly = 0
     ShowAnonymousLoginCheckBox = 0
     ShowDomainLine = 0
     DomainReadOnly = 0
 
     def __init__(self, parent = None, flags = 0, otherButtons = 0):
         '''void KPasswordDialog.__init__(QWidget parent = None, KPasswordDialog.KPasswordDialogFlags flags = 0, KDialog.ButtonCodes otherButtons = 0)'''
     def checkPassword(self):
         '''bool KPasswordDialog.checkPassword()'''
         return bool()
     gotUsernameAndPassword = pyqtSignal() # void gotUsernameAndPassword(const QStringamp;,const QStringamp;,bool) - signal
     gotPassword = pyqtSignal() # void gotPassword(const QStringamp;,bool) - signal
     def accept(self):
         '''void KPasswordDialog.accept()'''
     def setKnownLogins(self, knownLogins):
         '''void KPasswordDialog.setKnownLogins(dict-of-QString-QString knownLogins)'''
     def setPassword(self, password):
         '''void KPasswordDialog.setPassword(QString password)'''
     def setUsernameReadOnly(self, readOnly):
         '''void KPasswordDialog.setUsernameReadOnly(bool readOnly)'''
     def setKeepPassword(self, b):
         '''void KPasswordDialog.setKeepPassword(bool b)'''
     def keepPassword(self):
         '''bool KPasswordDialog.keepPassword()'''
         return bool()
     def anonymousMode(self):
         '''bool KPasswordDialog.anonymousMode()'''
         return bool()
     def setAnonymousMode(self, anonymous):
         '''void KPasswordDialog.setAnonymousMode(bool anonymous)'''
     def domain(self):
         '''QString KPasswordDialog.domain()'''
         return QString()
     def setDomain(self):
         '''QString KPasswordDialog.setDomain()'''
         return QString()
     def username(self):
         '''QString KPasswordDialog.username()'''
         return QString()
     def setUsername(self):
         '''QString KPasswordDialog.setUsername()'''
         return QString()
     def password(self):
         '''QString KPasswordDialog.password()'''
         return QString()
     def showErrorMessage(self, message, type = None):
         '''void KPasswordDialog.showErrorMessage(QString message, KPasswordDialog.ErrorType type = KPasswordDialog.PasswordError)'''
     def addCommentLine(self, label, comment):
         '''void KPasswordDialog.addCommentLine(QString label, QString comment)'''
     def pixmap(self):
         '''QPixmap KPasswordDialog.pixmap()'''
         return QPixmap()
     def setPixmap(self):
         '''QPixmap KPasswordDialog.setPixmap()'''
         return QPixmap()
     def prompt(self):
         '''QString KPasswordDialog.prompt()'''
         return QString()
     def setPrompt(self, prompt):
         '''void KPasswordDialog.setPrompt(QString prompt)'''
     class KPasswordDialogFlags():
         """"""
         def __init__(self):
             '''KPasswordDialog.KPasswordDialogFlags KPasswordDialog.KPasswordDialogFlags.__init__()'''
             return KPasswordDialog.KPasswordDialogFlags()
         def __init__(self):
             '''int KPasswordDialog.KPasswordDialogFlags.__init__()'''
             return int()
         def __init__(self):
             '''void KPasswordDialog.KPasswordDialogFlags.__init__()'''
         def __bool__(self):
             '''int KPasswordDialog.KPasswordDialogFlags.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KPasswordDialog.KPasswordDialogFlags.__ne__(KPasswordDialog.KPasswordDialogFlags f)'''
             return bool()
         def __eq__(self, f):
             '''bool KPasswordDialog.KPasswordDialogFlags.__eq__(KPasswordDialog.KPasswordDialogFlags f)'''
             return bool()
         def __invert__(self):
             '''KPasswordDialog.KPasswordDialogFlags KPasswordDialog.KPasswordDialogFlags.__invert__()'''
             return KPasswordDialog.KPasswordDialogFlags()
         def __and__(self, mask):
             '''KPasswordDialog.KPasswordDialogFlags KPasswordDialog.KPasswordDialogFlags.__and__(int mask)'''
             return KPasswordDialog.KPasswordDialogFlags()
         def __xor__(self, f):
             '''KPasswordDialog.KPasswordDialogFlags KPasswordDialog.KPasswordDialogFlags.__xor__(KPasswordDialog.KPasswordDialogFlags f)'''
             return KPasswordDialog.KPasswordDialogFlags()
         def __xor__(self, f):
             '''KPasswordDialog.KPasswordDialogFlags KPasswordDialog.KPasswordDialogFlags.__xor__(int f)'''
             return KPasswordDialog.KPasswordDialogFlags()
         def __or__(self, f):
             '''KPasswordDialog.KPasswordDialogFlags KPasswordDialog.KPasswordDialogFlags.__or__(KPasswordDialog.KPasswordDialogFlags f)'''
             return KPasswordDialog.KPasswordDialogFlags()
         def __or__(self, f):
             '''KPasswordDialog.KPasswordDialogFlags KPasswordDialog.KPasswordDialogFlags.__or__(int f)'''
             return KPasswordDialog.KPasswordDialogFlags()
         def __int__(self):
             '''int KPasswordDialog.KPasswordDialogFlags.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KPasswordDialog.KPasswordDialogFlags KPasswordDialog.KPasswordDialogFlags.__ixor__(KPasswordDialog.KPasswordDialogFlags f)'''
             return KPasswordDialog.KPasswordDialogFlags()
         def __ior__(self, f):
             '''KPasswordDialog.KPasswordDialogFlags KPasswordDialog.KPasswordDialogFlags.__ior__(KPasswordDialog.KPasswordDialogFlags f)'''
             return KPasswordDialog.KPasswordDialogFlags()
         def __iand__(self, mask):
             '''KPasswordDialog.KPasswordDialogFlags KPasswordDialog.KPasswordDialogFlags.__iand__(int mask)'''
             return KPasswordDialog.KPasswordDialogFlags()
 
 
 class KPasteTextAction(KAction):
     """"""
     def __init__(self, parent):
         '''void KPasteTextAction.__init__(QObject parent)'''
     def __init__(self, text, parent):
         '''void KPasteTextAction.__init__(QString text, QObject parent)'''
     def __init__(self, icon, text, parent):
         '''void KPasteTextAction.__init__(KIcon icon, QString text, QObject parent)'''
     def setMixedMode(self, mode):
         '''void KPasteTextAction.setMixedMode(bool mode)'''
 
 
 class KPixmapProvider():
     """"""
     def __init__(self):
         '''void KPixmapProvider.__init__()'''
     def __init__(self):
         '''KPixmapProvider KPixmapProvider.__init__()'''
         return KPixmapProvider()
     def pixmapFor(self, text, size = 0):
         '''abstract QPixmap KPixmapProvider.pixmapFor(QString text, int size = 0)'''
         return QPixmap()
 
 
 class KPixmapRegionSelectorDialog(KDialog):
     """"""
     def __init__(self, parent = None):
         '''void KPixmapRegionSelectorDialog.__init__(QWidget parent = None)'''
     def adjustRegionSelectorWidgetSizeToFitScreen(self):
         '''void KPixmapRegionSelectorDialog.adjustRegionSelectorWidgetSizeToFitScreen()'''
     def getSelectedImage(self, pixmap, parent = None):
         '''static QImage KPixmapRegionSelectorDialog.getSelectedImage(QPixmap pixmap, QWidget parent = None)'''
         return QImage()
     def getSelectedImage(self, pixmap, aspectRatioWidth, aspectRatioHeight, parent = None):
         '''static QImage KPixmapRegionSelectorDialog.getSelectedImage(QPixmap pixmap, int aspectRatioWidth, int aspectRatioHeight, QWidget parent = None)'''
         return QImage()
     def getSelectedRegion(self, pixmap, parent = None):
         '''static QRect KPixmapRegionSelectorDialog.getSelectedRegion(QPixmap pixmap, QWidget parent = None)'''
         return QRect()
     def getSelectedRegion(self, pixmap, aspectRatioWidth, aspectRatioHeight, parent = None):
         '''static QRect KPixmapRegionSelectorDialog.getSelectedRegion(QPixmap pixmap, int aspectRatioWidth, int aspectRatioHeight, QWidget parent = None)'''
         return QRect()
     def pixmapRegionSelectorWidget(self):
         '''KPixmapRegionSelectorWidget KPixmapRegionSelectorDialog.pixmapRegionSelectorWidget()'''
         return KPixmapRegionSelectorWidget()
 
 
 class KPixmapRegionSelectorWidget(QWidget):
     """"""
     # Enum KPixmapRegionSelectorWidget.RotateDirection
     Rotate90 = 0
     Rotate180 = 0
     Rotate270 = 0
 
     def __init__(self, parent = None):
         '''void KPixmapRegionSelectorWidget.__init__(QWidget parent = None)'''
     pixmapRotated = pyqtSignal() # void pixmapRotated() - signal
     def createPopupMenu(self):
         '''KMenu KPixmapRegionSelectorWidget.createPopupMenu()'''
         return KMenu()
     def rotateCounterclockwise(self):
         '''void KPixmapRegionSelectorWidget.rotateCounterclockwise()'''
     def rotateClockwise(self):
         '''void KPixmapRegionSelectorWidget.rotateClockwise()'''
     def rotate(self, direction):
         '''void KPixmapRegionSelectorWidget.rotate(KPixmapRegionSelectorWidget.RotateDirection direction)'''
     def setMaximumWidgetSize(self, width, height):
         '''void KPixmapRegionSelectorWidget.setMaximumWidgetSize(int width, int height)'''
     def setFreeSelectionAspectRatio(self):
         '''void KPixmapRegionSelectorWidget.setFreeSelectionAspectRatio()'''
     def setSelectionAspectRatio(self, width, height):
         '''void KPixmapRegionSelectorWidget.setSelectionAspectRatio(int width, int height)'''
     def selectedImage(self):
         '''QImage KPixmapRegionSelectorWidget.selectedImage()'''
         return QImage()
     def resetSelection(self):
         '''void KPixmapRegionSelectorWidget.resetSelection()'''
     def unzoomedSelectedRegion(self):
         '''QRect KPixmapRegionSelectorWidget.unzoomedSelectedRegion()'''
         return QRect()
     def selectedRegion(self):
         '''QRect KPixmapRegionSelectorWidget.selectedRegion()'''
         return QRect()
     def setSelectedRegion(self, rect):
         '''void KPixmapRegionSelectorWidget.setSelectedRegion(QRect rect)'''
     def pixmap(self):
         '''QPixmap KPixmapRegionSelectorWidget.pixmap()'''
         return QPixmap()
     def setPixmap(self, pixmap):
         '''void KPixmapRegionSelectorWidget.setPixmap(QPixmap pixmap)'''
 
 
 class KPixmapSequence():
     """"""
     def __init__(self):
         '''void KPixmapSequence.__init__()'''
     def __init__(self, other):
         '''void KPixmapSequence.__init__(KPixmapSequence other)'''
     def __init__(self, pixmap, frameSize = QSize()):
         '''void KPixmapSequence.__init__(QPixmap pixmap, QSize frameSize = QSize())'''
     def __init__(self, iconName, size = None):
         '''void KPixmapSequence.__init__(QString iconName, int size = KIconLoader.SizeSmall)'''
     def frameAt(self, index):
         '''QPixmap KPixmapSequence.frameAt(int index)'''
         return QPixmap()
     def frameCount(self):
         '''int KPixmapSequence.frameCount()'''
         return int()
     def frameSize(self):
         '''QSize KPixmapSequence.frameSize()'''
         return QSize()
     def isEmpty(self):
         '''bool KPixmapSequence.isEmpty()'''
         return bool()
     def isValid(self):
         '''bool KPixmapSequence.isValid()'''
         return bool()
 
 
 class KPixmapSequenceOverlayPainter(QObject):
     """"""
     def __init__(self, parent = None):
         '''void KPixmapSequenceOverlayPainter.__init__(QObject parent = None)'''
     def stop(self):
         '''void KPixmapSequenceOverlayPainter.stop()'''
     def start(self):
         '''void KPixmapSequenceOverlayPainter.start()'''
     def setOffset(self, offset):
         '''void KPixmapSequenceOverlayPainter.setOffset(QPoint offset)'''
     def setAlignment(self, align):
         '''void KPixmapSequenceOverlayPainter.setAlignment(Qt.Alignment align)'''
     def setRect(self, rect):
         '''void KPixmapSequenceOverlayPainter.setRect(QRect rect)'''
     def setWidget(self, w):
         '''void KPixmapSequenceOverlayPainter.setWidget(QWidget w)'''
     def setInterval(self, msecs):
         '''void KPixmapSequenceOverlayPainter.setInterval(int msecs)'''
     def setSequence(self, seq):
         '''void KPixmapSequenceOverlayPainter.setSequence(KPixmapSequence seq)'''
     def offset(self):
         '''QPoint KPixmapSequenceOverlayPainter.offset()'''
         return QPoint()
     def alignment(self):
         '''Qt.Alignment KPixmapSequenceOverlayPainter.alignment()'''
         return Qt.Alignment()
     def rect(self):
         '''QRect KPixmapSequenceOverlayPainter.rect()'''
         return QRect()
     def interval(self):
         '''int KPixmapSequenceOverlayPainter.interval()'''
         return int()
     def sequence(self):
         '''KPixmapSequence KPixmapSequenceOverlayPainter.sequence()'''
         return KPixmapSequence()
 
 
 class KPixmapSequenceWidget(QWidget):
     """"""
     def __init__(self, parent = None):
         '''void KPixmapSequenceWidget.__init__(QWidget parent = None)'''
     def setInterval(self, msecs):
         '''void KPixmapSequenceWidget.setInterval(int msecs)'''
     def setSequence(self, seq):
         '''void KPixmapSequenceWidget.setSequence(KPixmapSequence seq)'''
     def sizeHint(self):
         '''QSize KPixmapSequenceWidget.sizeHint()'''
         return QSize()
     def interval(self):
         '''int KPixmapSequenceWidget.interval()'''
         return int()
     def sequence(self):
         '''KPixmapSequence KPixmapSequenceWidget.sequence()'''
         return KPixmapSequence()
 
 
 class KPlotAxis():
     """"""
     def __init__(self, label = QString()):
         '''void KPlotAxis.__init__(QString label = QString())'''
     def minorTickMarks(self):
         '''list-of-float KPlotAxis.minorTickMarks()'''
         return [float()]
     def majorTickMarks(self):
         '''list-of-float KPlotAxis.majorTickMarks()'''
         return [float()]
     def setTickMarks(self, x0, length):
         '''void KPlotAxis.setTickMarks(float x0, float length)'''
     def tickLabelPrecision(self):
         '''int KPlotAxis.tickLabelPrecision()'''
         return int()
     def tickLabelFormat(self):
         '''str KPlotAxis.tickLabelFormat()'''
         return str()
     def tickLabelWidth(self):
         '''int KPlotAxis.tickLabelWidth()'''
         return int()
     def setTickLabelFormat(self, format = None, fieldWidth = 0, precision = None):
         '''void KPlotAxis.setTickLabelFormat(str format = 'g', int fieldWidth = 0, int precision = -1)'''
     def tickLabel(self, value):
         '''QString KPlotAxis.tickLabel(float value)'''
         return QString()
     def label(self):
         '''QString KPlotAxis.label()'''
         return QString()
     def setLabel(self, label):
         '''void KPlotAxis.setLabel(QString label)'''
     def setTickLabelsShown(self, b):
         '''void KPlotAxis.setTickLabelsShown(bool b)'''
     def areTickLabelsShown(self):
         '''bool KPlotAxis.areTickLabelsShown()'''
         return bool()
     def setVisible(self, visible):
         '''void KPlotAxis.setVisible(bool visible)'''
     def isVisible(self):
         '''bool KPlotAxis.isVisible()'''
         return bool()
 
 
 class KPlotObject():
     """"""
     # Enum KPlotObject.PointStyle
     NoPoints = 0
     Circle = 0
     Letter = 0
     Triangle = 0
     Square = 0
     Pentagon = 0
     Hexagon = 0
     Asterisk = 0
     Star = 0
     UnknwonPoint = 0
 
     # Enum KPlotObject.PlotType
     UnknownType = 0
     Points = 0
     Lines = 0
     Bars = 0
 
     def __init__(self, color = None, otype = None, size = 2, ps = None):
         '''void KPlotObject.__init__(QColor color = Qt.white, KPlotObject.PlotType otype = KPlotObject.Points, float size = 2, KPlotObject.PointStyle ps = KPlotObject.Circle)'''
     def draw(self, p, pw):
         '''void KPlotObject.draw(QPainter p, KPlotWidget pw)'''
     def clearPoints(self):
         '''void KPlotObject.clearPoints()'''
     def removePoint(self, index):
         '''void KPlotObject.removePoint(int index)'''
     def addPoint(self, p, label = QString(), barWidth = 0):
         '''void KPlotObject.addPoint(QPointF p, QString label = QString(), float barWidth = 0)'''
     def addPoint(self, p):
         '''void KPlotObject.addPoint(KPlotPoint p)'''
     def addPoint(self, x, y, label = QString(), barWidth = 0):
         '''void KPlotObject.addPoint(float x, float y, QString label = QString(), float barWidth = 0)'''
     def points(self):
         '''list-of-KPlotPoint KPlotObject.points()'''
         return [KPlotPoint()]
     def setBarBrush(self, b):
         '''void KPlotObject.setBarBrush(QBrush b)'''
     def barBrush(self):
         '''QBrush KPlotObject.barBrush()'''
         return QBrush()
     def setBrush(self, b):
         '''void KPlotObject.setBrush(QBrush b)'''
     def brush(self):
         '''QBrush KPlotObject.brush()'''
         return QBrush()
     def setLabelPen(self, p):
         '''void KPlotObject.setLabelPen(QPen p)'''
     def labelPen(self):
         '''QPen KPlotObject.labelPen()'''
         return QPen()
     def setBarPen(self, p):
         '''void KPlotObject.setBarPen(QPen p)'''
     def barPen(self):
         '''QPen KPlotObject.barPen()'''
         return QPen()
     def setLinePen(self, p):
         '''void KPlotObject.setLinePen(QPen p)'''
     def linePen(self):
         '''QPen KPlotObject.linePen()'''
         return QPen()
     def setPen(self, p):
         '''void KPlotObject.setPen(QPen p)'''
     def pen(self):
         '''QPen KPlotObject.pen()'''
         return QPen()
     def setPointStyle(self, p):
         '''void KPlotObject.setPointStyle(KPlotObject.PointStyle p)'''
     def pointStyle(self):
         '''KPlotObject.PointStyle KPlotObject.pointStyle()'''
         return KPlotObject.PointStyle()
     def setSize(self, s):
         '''void KPlotObject.setSize(float s)'''
     def size(self):
         '''float KPlotObject.size()'''
         return float()
     def setShowBars(self, b):
         '''void KPlotObject.setShowBars(bool b)'''
     def setShowLines(self, b):
         '''void KPlotObject.setShowLines(bool b)'''
     def setShowPoints(self, b):
         '''void KPlotObject.setShowPoints(bool b)'''
     def plotTypes(self):
         '''KPlotObject.PlotTypes KPlotObject.plotTypes()'''
         return KPlotObject.PlotTypes()
     class PlotTypes():
         """"""
         def __init__(self):
             '''KPlotObject.PlotTypes KPlotObject.PlotTypes.__init__()'''
             return KPlotObject.PlotTypes()
         def __init__(self):
             '''int KPlotObject.PlotTypes.__init__()'''
             return int()
         def __init__(self):
             '''void KPlotObject.PlotTypes.__init__()'''
         def __bool__(self):
             '''int KPlotObject.PlotTypes.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KPlotObject.PlotTypes.__ne__(KPlotObject.PlotTypes f)'''
             return bool()
         def __eq__(self, f):
             '''bool KPlotObject.PlotTypes.__eq__(KPlotObject.PlotTypes f)'''
             return bool()
         def __invert__(self):
             '''KPlotObject.PlotTypes KPlotObject.PlotTypes.__invert__()'''
             return KPlotObject.PlotTypes()
         def __and__(self, mask):
             '''KPlotObject.PlotTypes KPlotObject.PlotTypes.__and__(int mask)'''
             return KPlotObject.PlotTypes()
         def __xor__(self, f):
             '''KPlotObject.PlotTypes KPlotObject.PlotTypes.__xor__(KPlotObject.PlotTypes f)'''
             return KPlotObject.PlotTypes()
         def __xor__(self, f):
             '''KPlotObject.PlotTypes KPlotObject.PlotTypes.__xor__(int f)'''
             return KPlotObject.PlotTypes()
         def __or__(self, f):
             '''KPlotObject.PlotTypes KPlotObject.PlotTypes.__or__(KPlotObject.PlotTypes f)'''
             return KPlotObject.PlotTypes()
         def __or__(self, f):
             '''KPlotObject.PlotTypes KPlotObject.PlotTypes.__or__(int f)'''
             return KPlotObject.PlotTypes()
         def __int__(self):
             '''int KPlotObject.PlotTypes.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KPlotObject.PlotTypes KPlotObject.PlotTypes.__ixor__(KPlotObject.PlotTypes f)'''
             return KPlotObject.PlotTypes()
         def __ior__(self, f):
             '''KPlotObject.PlotTypes KPlotObject.PlotTypes.__ior__(KPlotObject.PlotTypes f)'''
             return KPlotObject.PlotTypes()
         def __iand__(self, mask):
             '''KPlotObject.PlotTypes KPlotObject.PlotTypes.__iand__(int mask)'''
             return KPlotObject.PlotTypes()
 
 
 class KPlotPoint():
     """"""
     def __init__(self):
         '''void KPlotPoint.__init__()'''
     def __init__(self, x, y, label = QString(), width = 0):
         '''void KPlotPoint.__init__(float x, float y, QString label = QString(), float width = 0)'''
     def __init__(self, p, label = QString(), width = 0):
         '''void KPlotPoint.__init__(QPointF p, QString label = QString(), float width = 0)'''
     def setBarWidth(self, w):
         '''void KPlotPoint.setBarWidth(float w)'''
     def barWidth(self):
         '''float KPlotPoint.barWidth()'''
         return float()
     def setLabel(self, label):
         '''void KPlotPoint.setLabel(QString label)'''
     def label(self):
         '''QString KPlotPoint.label()'''
         return QString()
     def setY(self, y):
         '''void KPlotPoint.setY(float y)'''
     def y(self):
         '''float KPlotPoint.y()'''
         return float()
     def setX(self, x):
         '''void KPlotPoint.setX(float x)'''
     def x(self):
         '''float KPlotPoint.x()'''
         return float()
     def setPosition(self, pos):
         '''void KPlotPoint.setPosition(QPointF pos)'''
     def position(self):
         '''QPointF KPlotPoint.position()'''
         return QPointF()
 
 
 class KPlotWidget(QFrame):
     """"""
     # Enum KPlotWidget.Axis
     LeftAxis = 0
     BottomAxis = 0
     RightAxis = 0
     TopAxis = 0
 
     def __init__(self, parent = None):
         '''void KPlotWidget.__init__(QWidget parent = None)'''
     def pointsUnderPoint(self, p):
         '''list-of-KPlotPoint KPlotWidget.pointsUnderPoint(QPoint p)'''
         return [KPlotPoint()]
     def setPixRect(self):
         '''void KPlotWidget.setPixRect()'''
     def drawAxes(self, p):
         '''void KPlotWidget.drawAxes(QPainter p)'''
     def resizeEvent(self):
         '''QResizeEvent KPlotWidget.resizeEvent()'''
         return QResizeEvent()
     def paintEvent(self):
         '''QPaintEvent KPlotWidget.paintEvent()'''
         return QPaintEvent()
     def event(self):
         '''QEvent KPlotWidget.event()'''
         return QEvent()
     def setObjectToolTipShown(self, show):
         '''void KPlotWidget.setObjectToolTipShown(bool show)'''
     def setShowGrid(self, show):
         '''void KPlotWidget.setShowGrid(bool show)'''
     def axis(self, type):
         '''KPlotAxis KPlotWidget.axis(KPlotWidget.Axis type)'''
         return KPlotAxis()
     def placeLabel(self, painter, pp):
         '''void KPlotWidget.placeLabel(QPainter painter, KPlotPoint pp)'''
     def maskAlongLine(self, p1, p2, value = 1):
         '''void KPlotWidget.maskAlongLine(QPointF p1, QPointF p2, float value = 1)'''
     def maskRect(self, r, value = 1):
         '''void KPlotWidget.maskRect(QRectF r, float value = 1)'''
     def mapToWidget(self, p):
         '''QPointF KPlotWidget.mapToWidget(QPointF p)'''
         return QPointF()
     def setDefaultPaddings(self):
         '''void KPlotWidget.setDefaultPaddings()'''
     def setBottomPadding(self, padding):
         '''void KPlotWidget.setBottomPadding(int padding)'''
     def setTopPadding(self, padding):
         '''void KPlotWidget.setTopPadding(int padding)'''
     def setRightPadding(self, padding):
         '''void KPlotWidget.setRightPadding(int padding)'''
     def setLeftPadding(self, padding):
         '''void KPlotWidget.setLeftPadding(int padding)'''
     def bottomPadding(self):
         '''int KPlotWidget.bottomPadding()'''
         return int()
     def topPadding(self):
         '''int KPlotWidget.topPadding()'''
         return int()
     def rightPadding(self):
         '''int KPlotWidget.rightPadding()'''
         return int()
     def leftPadding(self):
         '''int KPlotWidget.leftPadding()'''
         return int()
     def setAntialiasing(self, b):
         '''void KPlotWidget.setAntialiasing(bool b)'''
     def antialiasing(self):
         '''bool KPlotWidget.antialiasing()'''
         return bool()
     def isObjectToolTipShown(self):
         '''bool KPlotWidget.isObjectToolTipShown()'''
         return bool()
     def isGridShown(self):
         '''bool KPlotWidget.isGridShown()'''
         return bool()
     def setGridColor(self, gc):
         '''void KPlotWidget.setGridColor(QColor gc)'''
     def setForegroundColor(self, fg):
         '''void KPlotWidget.setForegroundColor(QColor fg)'''
     def setBackgroundColor(self, bg):
         '''void KPlotWidget.setBackgroundColor(QColor bg)'''
     def gridColor(self):
         '''QColor KPlotWidget.gridColor()'''
         return QColor()
     def foregroundColor(self):
         '''QColor KPlotWidget.foregroundColor()'''
         return QColor()
     def backgroundColor(self):
         '''QColor KPlotWidget.backgroundColor()'''
         return QColor()
     def replacePlotObject(self, i, o):
         '''void KPlotWidget.replacePlotObject(int i, KPlotObject o)'''
     def resetPlot(self):
         '''void KPlotWidget.resetPlot()'''
     def resetPlotMask(self):
         '''void KPlotWidget.resetPlotMask()'''
     def removeAllPlotObjects(self):
         '''void KPlotWidget.removeAllPlotObjects()'''
     def plotObjects(self):
         '''list-of-KPlotObject KPlotWidget.plotObjects()'''
         return [KPlotObject()]
     def addPlotObjects(self, objects):
         '''void KPlotWidget.addPlotObjects(list-of-KPlotObject objects)'''
     def addPlotObject(self, object):
         '''void KPlotWidget.addPlotObject(KPlotObject object)'''
     def pixRect(self):
         '''QRect KPlotWidget.pixRect()'''
         return QRect()
     def secondaryDataRect(self):
         '''QRectF KPlotWidget.secondaryDataRect()'''
         return QRectF()
     def dataRect(self):
         '''QRectF KPlotWidget.dataRect()'''
         return QRectF()
     def clearSecondaryLimits(self):
         '''void KPlotWidget.clearSecondaryLimits()'''
     def setSecondaryLimits(self, x1, x2, y1, y2):
         '''void KPlotWidget.setSecondaryLimits(float x1, float x2, float y1, float y2)'''
     def setLimits(self, x1, x2, y1, y2):
         '''void KPlotWidget.setLimits(float x1, float x2, float y1, float y2)'''
     def sizeHint(self):
         '''QSize KPlotWidget.sizeHint()'''
         return QSize()
     def minimumSizeHint(self):
         '''QSize KPlotWidget.minimumSizeHint()'''
         return QSize()
 
 
 class KProgressDialog(KDialog):
     """"""
     def __init__(self, parent = None, caption = QString(), text = QString(), flags = 0):
         '''void KProgressDialog.__init__(QWidget parent = None, QString caption = QString(), QString text = QString(), Qt.WindowFlags flags = 0)'''
     def showEvent(self, event):
         '''void KProgressDialog.showEvent(QShowEvent event)'''
     def reject(self):
         '''void KProgressDialog.reject()'''
     def minimumDuration(self):
         '''int KProgressDialog.minimumDuration()'''
         return int()
     def setMinimumDuration(self, ms):
         '''void KProgressDialog.setMinimumDuration(int ms)'''
     def buttonText(self):
         '''QString KProgressDialog.buttonText()'''
         return QString()
     def setButtonText(self, text):
         '''void KProgressDialog.setButtonText(QString text)'''
     def ignoreCancel(self):
         '''void KProgressDialog.ignoreCancel()'''
     def wasCancelled(self):
         '''bool KProgressDialog.wasCancelled()'''
         return bool()
     def autoReset(self):
         '''bool KProgressDialog.autoReset()'''
         return bool()
     def setAutoReset(self, autoReset):
         '''void KProgressDialog.setAutoReset(bool autoReset)'''
     def autoClose(self):
         '''bool KProgressDialog.autoClose()'''
         return bool()
     def setAutoClose(self, close):
         '''void KProgressDialog.setAutoClose(bool close)'''
     def showCancelButton(self, show):
         '''void KProgressDialog.showCancelButton(bool show)'''
     def allowCancel(self):
         '''bool KProgressDialog.allowCancel()'''
         return bool()
     def setAllowCancel(self, allowCancel):
         '''void KProgressDialog.setAllowCancel(bool allowCancel)'''
     def labelText(self):
         '''QString KProgressDialog.labelText()'''
         return QString()
     def setLabelText(self, text):
         '''void KProgressDialog.setLabelText(QString text)'''
     def progressBar(self):
         '''QProgressBar KProgressDialog.progressBar()'''
         return QProgressBar()
 
 
 class KPushButton(QPushButton):
     """"""
     def __init__(self, parent = None):
         '''void KPushButton.__init__(QWidget parent = None)'''
     def __init__(self, text, parent = None):
         '''void KPushButton.__init__(QString text, QWidget parent = None)'''
     def __init__(self, icon, text, parent = None):
         '''void KPushButton.__init__(KIcon icon, QString text, QWidget parent = None)'''
     def __init__(self, item, parent = None):
         '''void KPushButton.__init__(KGuiItem item, QWidget parent = None)'''
     authorized = pyqtSignal() # void authorized(KAuth::Action *) - signal
     def paintEvent(self):
         '''QPaintEvent KPushButton.paintEvent()'''
         return QPaintEvent()
     def setAuthAction(self, action):
         '''void KPushButton.setAuthAction(KAuth.Action action)'''
     def setAuthAction(self, actionName):
         '''void KPushButton.setAuthAction(QString actionName)'''
     def authAction(self):
         '''KAuth.Action KPushButton.authAction()'''
         return KAuth.Action()
     def sizeHint(self):
         '''QSize KPushButton.sizeHint()'''
         return QSize()
     def startDrag(self):
         '''void KPushButton.startDrag()'''
     def mouseMoveEvent(self):
         '''QMouseEvent KPushButton.mouseMoveEvent()'''
         return QMouseEvent()
     def mousePressEvent(self):
         '''QMouseEvent KPushButton.mousePressEvent()'''
         return QMouseEvent()
     def dragObject(self):
         '''QDrag KPushButton.dragObject()'''
         return QDrag()
     def delayedMenu(self):
         '''QMenu KPushButton.delayedMenu()'''
         return QMenu()
     def setDelayedMenu(self, delayed_menu):
         '''void KPushButton.setDelayedMenu(QMenu delayed_menu)'''
     def setText(self, text):
         '''void KPushButton.setText(QString text)'''
     def setIcon(self, icon):
         '''void KPushButton.setIcon(KIcon icon)'''
     def setIcon(self, pix):
         '''void KPushButton.setIcon(QIcon pix)'''
     def guiItem(self):
         '''KStandardGuiItem.StandardItem KPushButton.guiItem()'''
         return KStandardGuiItem.StandardItem()
     def setGuiItem(self, item):
         '''void KPushButton.setGuiItem(KGuiItem item)'''
     def setGuiItem(self, item):
         '''void KPushButton.setGuiItem(KStandardGuiItem.StandardItem item)'''
     def isDragEnabled(self):
         '''bool KPushButton.isDragEnabled()'''
         return bool()
     def setDragEnabled(self, enable):
         '''void KPushButton.setDragEnabled(bool enable)'''
 
 
 class KRecentFilesAction(KSelectAction):
     """"""
     def __init__(self, parent):
         '''void KRecentFilesAction.__init__(QObject parent)'''
     def __init__(self, text, parent):
         '''void KRecentFilesAction.__init__(QString text, QObject parent)'''
     def __init__(self, icon, text, parent):
         '''void KRecentFilesAction.__init__(KIcon icon, QString text, QObject parent)'''
     recentListCleared = pyqtSignal() # void recentListCleared() - signal
     urlSelected = pyqtSignal() # void urlSelected(const KUrlamp;) - signal
     def urls(self):
         '''KUrl.List KRecentFilesAction.urls()'''
         return KUrl.List()
     def removeUrl(self, url):
         '''void KRecentFilesAction.removeUrl(KUrl url)'''
     def addUrl(self, url, name = QString()):
         '''void KRecentFilesAction.addUrl(KUrl url, QString name = QString())'''
     def saveEntries(self, config):
         '''void KRecentFilesAction.saveEntries(KConfigGroup config)'''
     def loadEntries(self, config):
         '''void KRecentFilesAction.loadEntries(KConfigGroup config)'''
     def setMaxItems(self, maxItems):
         '''void KRecentFilesAction.setMaxItems(int maxItems)'''
     def maxItems(self):
         '''int KRecentFilesAction.maxItems()'''
         return int()
     def clear(self):
         '''void KRecentFilesAction.clear()'''
     def removeAction(self, action):
         '''QAction KRecentFilesAction.removeAction(QAction action)'''
         return QAction()
     def addAction(self, action, url, name):
         '''void KRecentFilesAction.addAction(QAction action, KUrl url, QString name)'''
 
 
 class KRecursiveFilterProxyModel(QSortFilterProxyModel):
     """"""
     def __init__(self, parent = None):
         '''void KRecursiveFilterProxyModel.__init__(QObject parent = None)'''
     def match(self, start, role, value, hits = 1, flags = None):
         '''list-of-QModelIndex KRecursiveFilterProxyModel.match(QModelIndex start, int role, QVariant value, int hits = 1, Qt.MatchFlags flags = Qt.MatchFlags(Qt.MatchStartsWith|Qt.MatchWrap))'''
         return [QModelIndex()]
     def acceptRow(self, sourceRow, sourceParent):
         '''bool KRecursiveFilterProxyModel.acceptRow(int sourceRow, QModelIndex sourceParent)'''
         return bool()
     def setSourceModel(self, model):
         '''void KRecursiveFilterProxyModel.setSourceModel(QAbstractItemModel model)'''
 
 
 class KReplace(KFind):
     """"""
     def __init__(self, pattern, replacement, options, parent = None):
         '''void KReplace.__init__(QString pattern, QString replacement, int options, QWidget parent = None)'''
     def __init__(self, pattern, replacement, options, parent, replaceDialog):
         '''void KReplace.__init__(QString pattern, QString replacement, int options, QWidget parent, QWidget replaceDialog)'''
     def displayFinalDialog(self):
         '''void KReplace.displayFinalDialog()'''
     def shouldRestart(self, forceAsking = False, showNumMatches = True):
         '''bool KReplace.shouldRestart(bool forceAsking = False, bool showNumMatches = True)'''
         return bool()
     def closeReplaceNextDialog(self):
         '''void KReplace.closeReplaceNextDialog()'''
     def replaceNextDialog(self, create = False):
         '''KDialog KReplace.replaceNextDialog(bool create = False)'''
         return KDialog()
     def replace(self):
         '''KFind.Result KReplace.replace()'''
         return KFind.Result()
     def replace(self, text, pattern, replacement, index, options, replacedLength):
         '''static int KReplace.replace(QString text, QString pattern, QString replacement, int index, int options, int replacedLength)'''
         return int()
     def replace(self, text, pattern, replacement, index, options, replacedLength):
         '''static int KReplace.replace(QString text, QRegExp pattern, QString replacement, int index, int options, int replacedLength)'''
         return int()
     replace = pyqtSignal() # void replace(const QStringamp;,int,int,int) - signal
     def resetCounts(self):
         '''void KReplace.resetCounts()'''
     def numReplacements(self):
         '''int KReplace.numReplacements()'''
         return int()
 
 
 class KReplaceDialog(KFindDialog):
     """"""
     # Enum KReplaceDialog.Options
     PromptOnReplace = 0
     BackReference = 0
 
     def __init__(self, parent = None, options = 0, findStrings = QStringList(), replaceStrings = QStringList(), hasSelection = True):
         '''void KReplaceDialog.__init__(QWidget parent = None, int options = 0, QStringList findStrings = QStringList(), QStringList replaceStrings = QStringList(), bool hasSelection = True)'''
     def showEvent(self):
         '''QShowEvent KReplaceDialog.showEvent()'''
         return QShowEvent()
     def replaceExtension(self):
         '''QWidget KReplaceDialog.replaceExtension()'''
         return QWidget()
     def replacement(self):
         '''QString KReplaceDialog.replacement()'''
         return QString()
     def options(self):
         '''int KReplaceDialog.options()'''
         return int()
     def setOptions(self, options):
         '''void KReplaceDialog.setOptions(int options)'''
     def replacementHistory(self):
         '''QStringList KReplaceDialog.replacementHistory()'''
         return QStringList()
     def setReplacementHistory(self, history):
         '''void KReplaceDialog.setReplacementHistory(QStringList history)'''
 
 
 class KRestrictedLine(KLineEdit):
     """"""
     def __init__(self, parent = None):
         '''void KRestrictedLine.__init__(QWidget parent = None)'''
     def inputMethodEvent(self, e):
         '''void KRestrictedLine.inputMethodEvent(QInputMethodEvent e)'''
     def keyPressEvent(self, e):
         '''void KRestrictedLine.keyPressEvent(QKeyEvent e)'''
     invalidChar = pyqtSignal() # void invalidChar(int) - signal
     def validChars(self):
         '''QString KRestrictedLine.validChars()'''
         return QString()
     def setValidChars(self, valid):
         '''void KRestrictedLine.setValidChars(QString valid)'''
 
 
 class KTextEdit(QTextEdit):
     """"""
     def __init__(self, text, parent = None):
         '''void KTextEdit.__init__(QString text, QWidget parent = None)'''
     def __init__(self, parent = None):
         '''void KTextEdit.__init__(QWidget parent = None)'''
     aboutToShowContextMenu = pyqtSignal() # void aboutToShowContextMenu(QMenu *) - signal
     def focusOutEvent(self):
         '''QFocusEvent KTextEdit.focusOutEvent()'''
         return QFocusEvent()
     def paintEvent(self):
         '''QPaintEvent KTextEdit.paintEvent()'''
         return QPaintEvent()
     def clickMessage(self):
         '''QString KTextEdit.clickMessage()'''
         return QString()
     def setClickMessage(self, msg):
         '''void KTextEdit.setClickMessage(QString msg)'''
     def checkSpellingEnabledInternal(self):
         '''bool KTextEdit.checkSpellingEnabledInternal()'''
         return bool()
     def setCheckSpellingEnabledInternal(self, check):
         '''void KTextEdit.setCheckSpellingEnabledInternal(bool check)'''
     def contextMenuEvent(self):
         '''QContextMenuEvent KTextEdit.contextMenuEvent()'''
         return QContextMenuEvent()
     def deleteWordForward(self):
         '''void KTextEdit.deleteWordForward()'''
     def deleteWordBack(self):
         '''void KTextEdit.deleteWordBack()'''
     def wheelEvent(self):
         '''QWheelEvent KTextEdit.wheelEvent()'''
         return QWheelEvent()
     def focusInEvent(self):
         '''QFocusEvent KTextEdit.focusInEvent()'''
         return QFocusEvent()
     def keyPressEvent(self):
         '''QKeyEvent KTextEdit.keyPressEvent()'''
         return QKeyEvent()
     def event(self):
         '''QEvent KTextEdit.event()'''
         return QEvent()
     def slotSpeakText(self):
         '''void KTextEdit.slotSpeakText()'''
     def slotReplace(self):
         '''void KTextEdit.slotReplace()'''
     def slotFindNext(self):
         '''void KTextEdit.slotFindNext()'''
     def slotFind(self):
         '''void KTextEdit.slotFind()'''
     def slotDoFind(self):
         '''void KTextEdit.slotDoFind()'''
     def slotReplaceNext(self):
         '''void KTextEdit.slotReplaceNext()'''
     def slotDoReplace(self):
         '''void KTextEdit.slotDoReplace()'''
     def replace(self):
         '''void KTextEdit.replace()'''
     def showSpellConfigDialog(self, configFileName, windowIcon = QString()):
         '''void KTextEdit.showSpellConfigDialog(QString configFileName, QString windowIcon = QString())'''
     def checkSpelling(self):
         '''void KTextEdit.checkSpelling()'''
     def setSpellCheckingLanguage(self, language):
         '''void KTextEdit.setSpellCheckingLanguage(QString language)'''
     languageChanged = pyqtSignal() # void languageChanged(const QStringamp;) - signal
     spellCheckStatus = pyqtSignal() # void spellCheckStatus(const QStringamp;) - signal
     checkSpellingChanged = pyqtSignal() # void checkSpellingChanged(bool) - signal
     def spellCheckingLanguage(self):
         '''QString KTextEdit.spellCheckingLanguage()'''
         return QString()
     def setSpellInterface(self, spellInterface):
         '''void KTextEdit.setSpellInterface(KTextEditSpellInterface spellInterface)'''
     def enableFindReplace(self, enabled):
         '''void KTextEdit.enableFindReplace(bool enabled)'''
     def mousePopupMenu(self):
         '''QMenu KTextEdit.mousePopupMenu()'''
         return QMenu()
     def setHighlighter(self, _highLighter):
         '''void KTextEdit.setHighlighter(Sonnet.Highlighter _highLighter)'''
     def highlighter(self):
         '''Sonnet.Highlighter KTextEdit.highlighter()'''
         return Sonnet.Highlighter()
     def createHighlighter(self):
         '''void KTextEdit.createHighlighter()'''
     def setSpellCheckingConfigFileName(self, fileName):
         '''void KTextEdit.setSpellCheckingConfigFileName(QString fileName)'''
     def highlightWord(self, length, pos):
         '''void KTextEdit.highlightWord(int length, int pos)'''
     def checkSpellingEnabled(self):
         '''bool KTextEdit.checkSpellingEnabled()'''
         return bool()
     def setCheckSpellingEnabled(self, check):
         '''void KTextEdit.setCheckSpellingEnabled(bool check)'''
     def setReadOnly(self, readOnly):
         '''void KTextEdit.setReadOnly(bool readOnly)'''
 
 
 class KRichTextEdit(KTextEdit):
     """"""
     # Enum KRichTextEdit.Mode
     Plain = 0
     Rich = 0
 
     def __init__(self, text, parent = None):
         '''void KRichTextEdit.__init__(QString text, QWidget parent = None)'''
     def __init__(self, parent = None):
         '''void KRichTextEdit.__init__(QWidget parent = None)'''
     def makeLeftToRight(self):
         '''void KRichTextEdit.makeLeftToRight()'''
     def makeRightToLeft(self):
         '''void KRichTextEdit.makeRightToLeft()'''
     def keyPressEvent(self, event):
         '''void KRichTextEdit.keyPressEvent(QKeyEvent event)'''
     selectionFinished = pyqtSignal() # void selectionFinished() - signal
     textModeChanged = pyqtSignal() # void textModeChanged(KRichTextEdit::Mode) - signal
     def setTextSubScript(self, subscript):
         '''void KRichTextEdit.setTextSubScript(bool subscript)'''
     def setTextSuperScript(self, superscript):
         '''void KRichTextEdit.setTextSuperScript(bool superscript)'''
     def toCleanHtml(self):
         '''QString KRichTextEdit.toCleanHtml()'''
         return QString()
     def switchToPlainText(self):
         '''void KRichTextEdit.switchToPlainText()'''
     def insertHorizontalRule(self):
         '''void KRichTextEdit.insertHorizontalRule()'''
     def setTextBackgroundColor(self, color):
         '''void KRichTextEdit.setTextBackgroundColor(QColor color)'''
     def setTextForegroundColor(self, color):
         '''void KRichTextEdit.setTextForegroundColor(QColor color)'''
     def setTextStrikeOut(self, strikeOut):
         '''void KRichTextEdit.setTextStrikeOut(bool strikeOut)'''
     def setTextUnderline(self, underline):
         '''void KRichTextEdit.setTextUnderline(bool underline)'''
     def setTextItalic(self, italic):
         '''void KRichTextEdit.setTextItalic(bool italic)'''
     def setTextBold(self, bold):
         '''void KRichTextEdit.setTextBold(bool bold)'''
     def setFont(self, font):
         '''void KRichTextEdit.setFont(QFont font)'''
     def setFontSize(self, size):
         '''void KRichTextEdit.setFontSize(int size)'''
     def setFontFamily(self, fontFamily):
         '''void KRichTextEdit.setFontFamily(QString fontFamily)'''
     def indentListLess(self):
         '''void KRichTextEdit.indentListLess()'''
     def indentListMore(self):
         '''void KRichTextEdit.indentListMore()'''
     def setListStyle(self, _styleIndex):
         '''void KRichTextEdit.setListStyle(int _styleIndex)'''
     def alignJustify(self):
         '''void KRichTextEdit.alignJustify()'''
     def alignRight(self):
         '''void KRichTextEdit.alignRight()'''
     def alignCenter(self):
         '''void KRichTextEdit.alignCenter()'''
     def alignLeft(self):
         '''void KRichTextEdit.alignLeft()'''
     def canDedentList(self):
         '''bool KRichTextEdit.canDedentList()'''
         return bool()
     def canIndentList(self):
         '''bool KRichTextEdit.canIndentList()'''
         return bool()
     def updateLink(self, linkUrl, linkText):
         '''void KRichTextEdit.updateLink(QString linkUrl, QString linkText)'''
     def selectLinkText(self, cursor):
         '''void KRichTextEdit.selectLinkText(QTextCursor cursor)'''
     def selectLinkText(self):
         '''void KRichTextEdit.selectLinkText()'''
     def currentLinkUrl(self):
         '''QString KRichTextEdit.currentLinkUrl()'''
         return QString()
     def currentLinkText(self):
         '''QString KRichTextEdit.currentLinkText()'''
         return QString()
     def setTextOrHtml(self, text):
         '''void KRichTextEdit.setTextOrHtml(QString text)'''
     def textOrHtml(self):
         '''QString KRichTextEdit.textOrHtml()'''
         return QString()
     def textMode(self):
         '''KRichTextEdit.Mode KRichTextEdit.textMode()'''
         return KRichTextEdit.Mode()
     def enableRichTextMode(self):
         '''void KRichTextEdit.enableRichTextMode()'''
 
 
 class KRichTextWidget(KRichTextEdit):
     """"""
     # Enum KRichTextWidget.RichTextSupportValues
     DisableRichText = 0
     SupportBold = 0
     SupportItalic = 0
     SupportUnderline = 0
     SupportStrikeOut = 0
     SupportFontFamily = 0
     SupportFontSize = 0
     SupportTextForegroundColor = 0
     SupportTextBackgroundColor = 0
     FullTextFormattingSupport = 0
     SupportChangeListStyle = 0
     SupportIndentLists = 0
     SupportDedentLists = 0
     FullListSupport = 0
     SupportAlignment = 0
     SupportRuleLine = 0
     SupportHyperlinks = 0
     SupportFormatPainting = 0
     SupportToPlainText = 0
     SupportSuperScriptAndSubScript = 0
     SupportDirection = 0
     FullSupport = 0
 
     def __init__(self, parent):
         '''void KRichTextWidget.__init__(QWidget parent)'''
     def __init__(self, text, parent = None):
         '''void KRichTextWidget.__init__(QString text, QWidget parent = None)'''
     def mouseReleaseEvent(self, event):
         '''void KRichTextWidget.mouseReleaseEvent(QMouseEvent event)'''
     def setActionsEnabled(self, enabled):
         '''void KRichTextWidget.setActionsEnabled(bool enabled)'''
     def updateActionStates(self):
         '''void KRichTextWidget.updateActionStates()'''
     def richTextSupport(self):
         '''KRichTextWidget.RichTextSupport KRichTextWidget.richTextSupport()'''
         return KRichTextWidget.RichTextSupport()
     def setRichTextSupport(self, support):
         '''void KRichTextWidget.setRichTextSupport(KRichTextWidget.RichTextSupport support)'''
     def createActions(self, actionCollection):
         '''void KRichTextWidget.createActions(KActionCollection actionCollection)'''
     class RichTextSupport():
         """"""
         def __init__(self):
             '''KRichTextWidget.RichTextSupport KRichTextWidget.RichTextSupport.__init__()'''
             return KRichTextWidget.RichTextSupport()
         def __init__(self):
             '''int KRichTextWidget.RichTextSupport.__init__()'''
             return int()
         def __init__(self):
             '''void KRichTextWidget.RichTextSupport.__init__()'''
         def __bool__(self):
             '''int KRichTextWidget.RichTextSupport.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KRichTextWidget.RichTextSupport.__ne__(KRichTextWidget.RichTextSupport f)'''
             return bool()
         def __eq__(self, f):
             '''bool KRichTextWidget.RichTextSupport.__eq__(KRichTextWidget.RichTextSupport f)'''
             return bool()
         def __invert__(self):
             '''KRichTextWidget.RichTextSupport KRichTextWidget.RichTextSupport.__invert__()'''
             return KRichTextWidget.RichTextSupport()
         def __and__(self, mask):
             '''KRichTextWidget.RichTextSupport KRichTextWidget.RichTextSupport.__and__(int mask)'''
             return KRichTextWidget.RichTextSupport()
         def __xor__(self, f):
             '''KRichTextWidget.RichTextSupport KRichTextWidget.RichTextSupport.__xor__(KRichTextWidget.RichTextSupport f)'''
             return KRichTextWidget.RichTextSupport()
         def __xor__(self, f):
             '''KRichTextWidget.RichTextSupport KRichTextWidget.RichTextSupport.__xor__(int f)'''
             return KRichTextWidget.RichTextSupport()
         def __or__(self, f):
             '''KRichTextWidget.RichTextSupport KRichTextWidget.RichTextSupport.__or__(KRichTextWidget.RichTextSupport f)'''
             return KRichTextWidget.RichTextSupport()
         def __or__(self, f):
             '''KRichTextWidget.RichTextSupport KRichTextWidget.RichTextSupport.__or__(int f)'''
             return KRichTextWidget.RichTextSupport()
         def __int__(self):
             '''int KRichTextWidget.RichTextSupport.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KRichTextWidget.RichTextSupport KRichTextWidget.RichTextSupport.__ixor__(KRichTextWidget.RichTextSupport f)'''
             return KRichTextWidget.RichTextSupport()
         def __ior__(self, f):
             '''KRichTextWidget.RichTextSupport KRichTextWidget.RichTextSupport.__ior__(KRichTextWidget.RichTextSupport f)'''
             return KRichTextWidget.RichTextSupport()
         def __iand__(self, mask):
             '''KRichTextWidget.RichTextSupport KRichTextWidget.RichTextSupport.__iand__(int mask)'''
             return KRichTextWidget.RichTextSupport()
 
 
 class KRuler(QAbstractSlider):
     """"""
     # Enum KRuler.MetricStyle
     Custom = 0
     Pixel = 0
     Inch = 0
     Millimetres = 0
     Centimetres = 0
     Metres = 0
 
     def __init__(self, parent = None):
         '''void KRuler.__init__(QWidget parent = None)'''
     def __init__(self, orient, parent = None, f = 0):
         '''void KRuler.__init__(Qt.Orientation orient, QWidget parent = None, Qt.WindowFlags f = 0)'''
     def __init__(self, orient, widgetWidth, parent = None, f = 0):
         '''void KRuler.__init__(Qt.Orientation orient, int widgetWidth, QWidget parent = None, Qt.WindowFlags f = 0)'''
     def paintEvent(self):
         '''QPaintEvent KRuler.paintEvent()'''
         return QPaintEvent()
     def slotEndOffset(self):
         '''int KRuler.slotEndOffset()'''
         return int()
     def slotNewOffset(self):
         '''int KRuler.slotNewOffset()'''
         return int()
     def slotNewValue(self):
         '''int KRuler.slotNewValue()'''
         return int()
     def endOffset(self):
         '''int KRuler.endOffset()'''
         return int()
     def offset(self):
         '''int KRuler.offset()'''
         return int()
     def setOffset(self, offset):
         '''void KRuler.setOffset(int offset)'''
     def slideDown(self, count = 1):
         '''void KRuler.slideDown(int count = 1)'''
     def slideUp(self, count = 1):
         '''void KRuler.slideUp(int count = 1)'''
     def lengthFixed(self):
         '''bool KRuler.lengthFixed()'''
         return bool()
     def setLengthFixed(self, fix):
         '''void KRuler.setLengthFixed(bool fix)'''
     def length(self):
         '''int KRuler.length()'''
         return int()
     def setLength(self):
         '''int KRuler.setLength()'''
         return int()
     def pixelPerMark(self):
         '''float KRuler.pixelPerMark()'''
         return float()
     def setPixelPerMark(self, rate):
         '''void KRuler.setPixelPerMark(float rate)'''
     def setRulerMetricStyle(self):
         '''KRuler.MetricStyle KRuler.setRulerMetricStyle()'''
         return KRuler.MetricStyle()
     def endLabel(self):
         '''QString KRuler.endLabel()'''
         return QString()
     def setEndLabel(self):
         '''QString KRuler.setEndLabel()'''
         return QString()
     def showEndLabel(self):
         '''bool KRuler.showEndLabel()'''
         return bool()
     def setShowEndLabel(self):
         '''bool KRuler.setShowEndLabel()'''
         return bool()
     def setFrameStyle(self):
         '''int KRuler.setFrameStyle()'''
         return int()
     def showPointer(self):
         '''bool KRuler.showPointer()'''
         return bool()
     def setShowPointer(self):
         '''bool KRuler.setShowPointer()'''
         return bool()
     def showEndMarks(self):
         '''bool KRuler.showEndMarks()'''
         return bool()
     def setShowEndMarks(self):
         '''bool KRuler.setShowEndMarks()'''
         return bool()
     def showBigMarks(self):
         '''bool KRuler.showBigMarks()'''
         return bool()
     def setShowBigMarks(self):
         '''bool KRuler.setShowBigMarks()'''
         return bool()
     def showMediumMarks(self):
         '''bool KRuler.showMediumMarks()'''
         return bool()
     def setShowMediumMarks(self):
         '''bool KRuler.setShowMediumMarks()'''
         return bool()
     def showLittleMarks(self):
         '''bool KRuler.showLittleMarks()'''
         return bool()
     def setShowLittleMarks(self):
         '''bool KRuler.setShowLittleMarks()'''
         return bool()
     def showTinyMarks(self):
         '''bool KRuler.showTinyMarks()'''
         return bool()
     def setShowTinyMarks(self):
         '''bool KRuler.setShowTinyMarks()'''
         return bool()
     def bigMarkDistance(self):
         '''int KRuler.bigMarkDistance()'''
         return int()
     def setBigMarkDistance(self):
         '''int KRuler.setBigMarkDistance()'''
         return int()
     def mediumMarkDistance(self):
         '''int KRuler.mediumMarkDistance()'''
         return int()
     def setMediumMarkDistance(self):
         '''int KRuler.setMediumMarkDistance()'''
         return int()
     def littleMarkDistance(self):
         '''int KRuler.littleMarkDistance()'''
         return int()
     def setLittleMarkDistance(self):
         '''int KRuler.setLittleMarkDistance()'''
         return int()
     def tinyMarkDistance(self):
         '''int KRuler.tinyMarkDistance()'''
         return int()
     def setTinyMarkDistance(self):
         '''int KRuler.setTinyMarkDistance()'''
         return int()
     def maxValue(self):
         '''int KRuler.maxValue()'''
         return int()
     def setMaxValue(self):
         '''int KRuler.setMaxValue()'''
         return int()
     def minValue(self):
         '''int KRuler.minValue()'''
         return int()
     def setMinValue(self):
         '''int KRuler.setMinValue()'''
         return int()
 
 
 class KSelectionProxyModel(QAbstractProxyModel):
     """"""
     # Enum KSelectionProxyModel.FilterBehavior
     SubTrees = 0
     SubTreeRoots = 0
     SubTreesWithoutRoots = 0
     ExactSelection = 0
     ChildrenOfExactSelection = 0
 
     def __init__(self, selectionModel, parent = None):
         '''void KSelectionProxyModel.__init__(QItemSelectionModel selectionModel, QObject parent = None)'''
     def mapSelectionToSource(self, selection):
         '''QItemSelection KSelectionProxyModel.mapSelectionToSource(QItemSelection selection)'''
         return QItemSelection()
     def mapSelectionFromSource(self, selection):
         '''QItemSelection KSelectionProxyModel.mapSelectionFromSource(QItemSelection selection)'''
         return QItemSelection()
     def match(self, start, role, value, hits = 1, flags = None):
         '''list-of-QModelIndex KSelectionProxyModel.match(QModelIndex start, int role, QVariant value, int hits = 1, Qt.MatchFlags flags = Qt.MatchFlags(Qt.MatchStartsWith|Qt.MatchWrap))'''
         return [QModelIndex()]
     def sourceRootIndexes(self):
         '''list-of-QPersistentModelIndex KSelectionProxyModel.sourceRootIndexes()'''
         return [QPersistentModelIndex()]
     def columnCount(self):
         '''QModelIndex KSelectionProxyModel.columnCount()'''
         return QModelIndex()
     def parent(self):
         '''QModelIndex KSelectionProxyModel.parent()'''
         return QModelIndex()
     def index(self):
         '''QModelIndex KSelectionProxyModel.index()'''
         return QModelIndex()
     def hasChildren(self, parent = QModelIndex()):
         '''bool KSelectionProxyModel.hasChildren(QModelIndex parent = QModelIndex())'''
         return bool()
     def dropMimeData(self, data, action, row, column, parent):
         '''bool KSelectionProxyModel.dropMimeData(QMimeData data, Qt.DropAction action, int row, int column, QModelIndex parent)'''
         return bool()
     def supportedDropActions(self):
         '''Qt.DropActions KSelectionProxyModel.supportedDropActions()'''
         return Qt.DropActions()
     def mimeTypes(self):
         '''QStringList KSelectionProxyModel.mimeTypes()'''
         return QStringList()
     def mimeData(self, indexes):
         '''QMimeData KSelectionProxyModel.mimeData(list-of-QModelIndex indexes)'''
         return QMimeData()
     def headerData(self, section, orientation, role = None):
         '''QVariant KSelectionProxyModel.headerData(int section, Qt.Orientation orientation, int role = Qt.DisplayRole)'''
         return QVariant()
     def rowCount(self, parent = QModelIndex()):
         '''int KSelectionProxyModel.rowCount(QModelIndex parent = QModelIndex())'''
         return int()
     def data(self, index, role = None):
         '''QVariant KSelectionProxyModel.data(QModelIndex index, int role = Qt.DisplayRole)'''
         return QVariant()
     def flags(self, index):
         '''Qt.ItemFlags KSelectionProxyModel.flags(QModelIndex index)'''
         return Qt.ItemFlags()
     def mapToSource(self, proxyIndex):
         '''QModelIndex KSelectionProxyModel.mapToSource(QModelIndex proxyIndex)'''
         return QModelIndex()
     def mapFromSource(self, sourceIndex):
         '''QModelIndex KSelectionProxyModel.mapFromSource(QModelIndex sourceIndex)'''
         return QModelIndex()
     def filterBehavior(self):
         '''KSelectionProxyModel.FilterBehavior KSelectionProxyModel.filterBehavior()'''
         return KSelectionProxyModel.FilterBehavior()
     def setFilterBehavior(self, behavior):
         '''void KSelectionProxyModel.setFilterBehavior(KSelectionProxyModel.FilterBehavior behavior)'''
     def selectionModel(self):
         '''QItemSelectionModel KSelectionProxyModel.selectionModel()'''
         return QItemSelectionModel()
     def setSourceModel(self, sourceModel):
         '''void KSelectionProxyModel.setSourceModel(QAbstractItemModel sourceModel)'''
 
 
 class KGradientSelector(KSelector):
     """"""
     def __init__(self, parent = None):
         '''void KGradientSelector.__init__(QWidget parent = None)'''
     def __init__(self, o, parent = None):
         '''void KGradientSelector.__init__(Qt.Orientation o, QWidget parent = None)'''
     def stops(self):
         '''list-of-tuple-of-float-QColor KGradientSelector.stops()'''
         return [tuple-of-float-QColor()]
     def setStops(self, stops):
         '''void KGradientSelector.setStops(list-of-tuple-of-float-QColor stops)'''
     def minimumSize(self):
         '''QSize KGradientSelector.minimumSize()'''
         return QSize()
     def drawContents(self):
         '''QPainter KGradientSelector.drawContents()'''
         return QPainter()
     def secondText(self):
         '''QString KGradientSelector.secondText()'''
         return QString()
     def firstText(self):
         '''QString KGradientSelector.firstText()'''
         return QString()
     def secondColor(self):
         '''QColor KGradientSelector.secondColor()'''
         return QColor()
     def firstColor(self):
         '''QColor KGradientSelector.firstColor()'''
         return QColor()
     def setSecondText(self, t):
         '''void KGradientSelector.setSecondText(QString t)'''
     def setFirstText(self, t):
         '''void KGradientSelector.setFirstText(QString t)'''
     def setSecondColor(self, col):
         '''void KGradientSelector.setSecondColor(QColor col)'''
     def setFirstColor(self, col):
         '''void KGradientSelector.setFirstColor(QColor col)'''
     def setText(self, t1, t2):
         '''void KGradientSelector.setText(QString t1, QString t2)'''
     def setColors(self, col1, col2):
         '''void KGradientSelector.setColors(QColor col1, QColor col2)'''
 
 
 class KSeparator(QFrame):
     """"""
     def __init__(self, parent = None, f = 0):
         '''void KSeparator.__init__(QWidget parent = None, Qt.WindowFlags f = 0)'''
     def __init__(self, orientation, parent = None, f = 0):
         '''void KSeparator.__init__(Qt.Orientation orientation, QWidget parent = None, Qt.WindowFlags f = 0)'''
     def setOrientation(self, orientation):
         '''void KSeparator.setOrientation(Qt.Orientation orientation)'''
     def orientation(self):
         '''Qt.Orientation KSeparator.orientation()'''
         return Qt.Orientation()
 
 
 class KSessionManager():
     """"""
     def __init__(self):
         '''void KSessionManager.__init__()'''
     def sessionClients(self):
         '''static list-of-KSessionManager KSessionManager.sessionClients()'''
         return [KSessionManager()]
     def commitData(self, sm):
         '''bool KSessionManager.commitData(QSessionManager sm)'''
         return bool()
     def saveState(self, sm):
         '''bool KSessionManager.saveState(QSessionManager sm)'''
         return bool()
 
 
 class KShortcut():
     """"""
     # Enum KShortcut.EmptyHandling
     KeepEmpty = 0
     RemoveEmpty = 0
 
     def __init__(self):
         '''void KShortcut.__init__()'''
     def __init__(self, primary):
         '''void KShortcut.__init__(QKeySequence primary)'''
     def __init__(self, primary, alternate):
         '''void KShortcut.__init__(QKeySequence primary, QKeySequence alternate)'''
     def __init__(self, keyQtPri, keyQtAlt = 0):
         '''void KShortcut.__init__(int keyQtPri, int keyQtAlt = 0)'''
     def __init__(self, other):
         '''void KShortcut.__init__(KShortcut other)'''
     def __init__(self, description):
         '''void KShortcut.__init__(QString description)'''
     def __init__(self, seqs):
         '''void KShortcut.__init__(list-of-QKeySequence seqs)'''
     def remove(self, keySeq, handleEmpty = None):
         '''void KShortcut.remove(QKeySequence keySeq, KShortcut.EmptyHandling handleEmpty = KShortcut.RemoveEmpty)'''
     def setAlternate(self, keySeq):
         '''void KShortcut.setAlternate(QKeySequence keySeq)'''
     def setPrimary(self, keySeq):
         '''void KShortcut.setPrimary(QKeySequence keySeq)'''
     def toList(self, handleEmpty = None):
         '''list-of-QKeySequence KShortcut.toList(KShortcut.EmptyHandling handleEmpty = KShortcut.RemoveEmpty)'''
         return [QKeySequence()]
     def __ne__(self, other):
         '''bool KShortcut.__ne__(KShortcut other)'''
         return bool()
     def __eq__(self, other):
         '''bool KShortcut.__eq__(KShortcut other)'''
         return bool()
     def toString(self):
         '''QString KShortcut.toString()'''
         return QString()
     def toString(self, format):
         '''QString KShortcut.toString(QKeySequence.SequenceFormat format)'''
         return QString()
     def conflictsWith(self, needle):
         '''bool KShortcut.conflictsWith(QKeySequence needle)'''
         return bool()
     def contains(self, needle):
         '''bool KShortcut.contains(QKeySequence needle)'''
         return bool()
     def isEmpty(self):
         '''bool KShortcut.isEmpty()'''
         return bool()
     def alternate(self):
         '''QKeySequence KShortcut.alternate()'''
         return QKeySequence()
     def primary(self):
         '''QKeySequence KShortcut.primary()'''
         return QKeySequence()
 
 
 class KShortcutsDialog(KDialog):
     """"""
     def __init__(self, types = None, allowLetterShortcuts = None, parent = None):
         '''void KShortcutsDialog.__init__(KShortcutsEditor.ActionTypes types = KShortcutsEditor.AllActions, KShortcutsEditor.LetterShortcuts allowLetterShortcuts = KShortcutsEditor.LetterShortcutsAllowed, QWidget parent = None)'''
     saved = pyqtSignal() # void saved() - signal
     def sizeHint(self):
         '''QSize KShortcutsDialog.sizeHint()'''
         return QSize()
     def configure(self, saveSettings = True):
         '''bool KShortcutsDialog.configure(bool saveSettings = True)'''
         return bool()
     def configure(self, collection, allowLetterShortcuts = None, parent = None, bSaveSettings = True):
         '''static int KShortcutsDialog.configure(KActionCollection collection, KShortcutsEditor.LetterShortcuts allowLetterShortcuts = KShortcutsEditor.LetterShortcutsAllowed, QWidget parent = None, bool bSaveSettings = True)'''
         return int()
     def actionCollections(self):
         '''list-of-KActionCollection KShortcutsDialog.actionCollections()'''
         return [KActionCollection()]
     def addCollection(self, title = QString()):
         '''KActionCollection KShortcutsDialog.addCollection(QString title = QString())'''
         return KActionCollection()
 
 
 class KShortcutsEditor(QWidget):
     """"""
     # Enum KShortcutsEditor.LetterShortcuts
     LetterShortcutsDisallowed = 0
     LetterShortcutsAllowed = 0
 
     # Enum KShortcutsEditor.ActionType
     WidgetAction = 0
     WindowAction = 0
     ApplicationAction = 0
     GlobalAction = 0
     AllActions = 0
 
     def __init__(self, collection, parent, actionTypes = None, allowLetterShortcuts = None):
         '''void KShortcutsEditor.__init__(KActionCollection collection, QWidget parent, KShortcutsEditor.ActionTypes actionTypes = KShortcutsEditor.AllActions, KShortcutsEditor.LetterShortcuts allowLetterShortcuts = KShortcutsEditor.LetterShortcutsAllowed)'''
     def __init__(self, parent, actionTypes = None, allowLetterShortcuts = None):
         '''void KShortcutsEditor.__init__(QWidget parent, KShortcutsEditor.ActionTypes actionTypes = KShortcutsEditor.AllActions, KShortcutsEditor.LetterShortcuts allowLetterShortcuts = KShortcutsEditor.LetterShortcutsAllowed)'''
     def printShortcuts(self):
         '''void KShortcutsEditor.printShortcuts()'''
     def allDefault(self):
         '''void KShortcutsEditor.allDefault()'''
     def resizeColumns(self):
         '''void KShortcutsEditor.resizeColumns()'''
     keyChange = pyqtSignal() # void keyChange() - signal
     def importConfiguration(self, config):
         '''void KShortcutsEditor.importConfiguration(KConfig config)'''
     def importConfiguration(self, config):
         '''void KShortcutsEditor.importConfiguration(KConfigBase config)'''
     def exportConfiguration(self, config):
         '''void KShortcutsEditor.exportConfiguration(KConfig config)'''
     def exportConfiguration(self, config):
         '''void KShortcutsEditor.exportConfiguration(KConfigBase config)'''
     def writeConfiguration(self, config = None):
         '''void KShortcutsEditor.writeConfiguration(KConfigGroup config = None)'''
     def clearConfiguration(self):
         '''void KShortcutsEditor.clearConfiguration()'''
     def commit(self):
         '''void KShortcutsEditor.commit()'''
     def save(self):
         '''void KShortcutsEditor.save()'''
     def undoChanges(self):
         '''void KShortcutsEditor.undoChanges()'''
     def addCollection(self, title = QString()):
         '''KActionCollection KShortcutsEditor.addCollection(QString title = QString())'''
         return KActionCollection()
     def clearCollections(self):
         '''void KShortcutsEditor.clearCollections()'''
     def isModified(self):
         '''bool KShortcutsEditor.isModified()'''
         return bool()
     class ActionTypes():
         """"""
         def __init__(self):
             '''KShortcutsEditor.ActionTypes KShortcutsEditor.ActionTypes.__init__()'''
             return KShortcutsEditor.ActionTypes()
         def __init__(self):
             '''int KShortcutsEditor.ActionTypes.__init__()'''
             return int()
         def __init__(self):
             '''void KShortcutsEditor.ActionTypes.__init__()'''
         def __bool__(self):
             '''int KShortcutsEditor.ActionTypes.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KShortcutsEditor.ActionTypes.__ne__(KShortcutsEditor.ActionTypes f)'''
             return bool()
         def __eq__(self, f):
             '''bool KShortcutsEditor.ActionTypes.__eq__(KShortcutsEditor.ActionTypes f)'''
             return bool()
         def __invert__(self):
             '''KShortcutsEditor.ActionTypes KShortcutsEditor.ActionTypes.__invert__()'''
             return KShortcutsEditor.ActionTypes()
         def __and__(self, mask):
             '''KShortcutsEditor.ActionTypes KShortcutsEditor.ActionTypes.__and__(int mask)'''
             return KShortcutsEditor.ActionTypes()
         def __xor__(self, f):
             '''KShortcutsEditor.ActionTypes KShortcutsEditor.ActionTypes.__xor__(KShortcutsEditor.ActionTypes f)'''
             return KShortcutsEditor.ActionTypes()
         def __xor__(self, f):
             '''KShortcutsEditor.ActionTypes KShortcutsEditor.ActionTypes.__xor__(int f)'''
             return KShortcutsEditor.ActionTypes()
         def __or__(self, f):
             '''KShortcutsEditor.ActionTypes KShortcutsEditor.ActionTypes.__or__(KShortcutsEditor.ActionTypes f)'''
             return KShortcutsEditor.ActionTypes()
         def __or__(self, f):
             '''KShortcutsEditor.ActionTypes KShortcutsEditor.ActionTypes.__or__(int f)'''
             return KShortcutsEditor.ActionTypes()
         def __int__(self):
             '''int KShortcutsEditor.ActionTypes.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KShortcutsEditor.ActionTypes KShortcutsEditor.ActionTypes.__ixor__(KShortcutsEditor.ActionTypes f)'''
             return KShortcutsEditor.ActionTypes()
         def __ior__(self, f):
             '''KShortcutsEditor.ActionTypes KShortcutsEditor.ActionTypes.__ior__(KShortcutsEditor.ActionTypes f)'''
             return KShortcutsEditor.ActionTypes()
         def __iand__(self, mask):
             '''KShortcutsEditor.ActionTypes KShortcutsEditor.ActionTypes.__iand__(int mask)'''
             return KShortcutsEditor.ActionTypes()
 
 
 class KShortcutWidget(QWidget):
     """"""
     def __init__(self, parent = None):
         '''void KShortcutWidget.__init__(QWidget parent = None)'''
     def applyStealShortcut(self):
         '''void KShortcutWidget.applyStealShortcut()'''
     def clearShortcut(self):
         '''void KShortcutWidget.clearShortcut()'''
     def setShortcut(self, cut):
         '''void KShortcutWidget.setShortcut(KShortcut cut)'''
     shortcutChanged = pyqtSignal() # void shortcutChanged(const KShortcutamp;) - signal
     def setCheckActionList(self, checkList):
         '''void KShortcutWidget.setCheckActionList(list-of-QAction checkList)'''
     def setCheckActionCollections(self, actionCollections):
         '''void KShortcutWidget.setCheckActionCollections(list-of-KActionCollection actionCollections)'''
     def setClearButtonsShown(self, show):
         '''void KShortcutWidget.setClearButtonsShown(bool show)'''
     def isModifierlessAllowed(self):
         '''bool KShortcutWidget.isModifierlessAllowed()'''
         return bool()
     def setModifierlessAllowed(self, allow):
         '''void KShortcutWidget.setModifierlessAllowed(bool allow)'''
 
 
 class KSplashScreen(QSplashScreen):
     """"""
     def __init__(self, pixmap, f = 0):
         '''void KSplashScreen.__init__(QPixmap pixmap, Qt.WindowFlags f = 0)'''
 
 
 class KSqueezedTextLabel(QLabel):
     """"""
     def __init__(self, parent = None):
         '''void KSqueezedTextLabel.__init__(QWidget parent = None)'''
     def __init__(self, text, parent = None):
         '''void KSqueezedTextLabel.__init__(QString text, QWidget parent = None)'''
     def mouseReleaseEvent(self):
         '''QMouseEvent KSqueezedTextLabel.mouseReleaseEvent()'''
         return QMouseEvent()
     def fullText(self):
         '''QString KSqueezedTextLabel.fullText()'''
         return QString()
     def squeezeTextToLabel(self):
         '''void KSqueezedTextLabel.squeezeTextToLabel()'''
     def contextMenuEvent(self):
         '''QContextMenuEvent KSqueezedTextLabel.contextMenuEvent()'''
         return QContextMenuEvent()
     def resizeEvent(self):
         '''QResizeEvent KSqueezedTextLabel.resizeEvent()'''
         return QResizeEvent()
     def clear(self):
         '''void KSqueezedTextLabel.clear()'''
     def setText(self, text):
         '''void KSqueezedTextLabel.setText(QString text)'''
     def setTextElideMode(self, mode):
         '''void KSqueezedTextLabel.setTextElideMode(Qt.TextElideMode mode)'''
     def textElideMode(self):
         '''Qt.TextElideMode KSqueezedTextLabel.textElideMode()'''
         return Qt.TextElideMode()
     def setAlignment(self):
         '''Qt.Alignment KSqueezedTextLabel.setAlignment()'''
         return Qt.Alignment()
     def sizeHint(self):
         '''QSize KSqueezedTextLabel.sizeHint()'''
         return QSize()
     def minimumSizeHint(self):
         '''QSize KSqueezedTextLabel.minimumSizeHint()'''
         return QSize()
 
 
 class KStandardAction():
     """"""
     # Enum KStandardAction.StandardAction
     ActionNone = 0
     New = 0
     Open = 0
     OpenRecent = 0
     Save = 0
     SaveAs = 0
     Revert = 0
     Close = 0
     Print = 0
     PrintPreview = 0
     Mail = 0
     Quit = 0
     Undo = 0
     Redo = 0
     Cut = 0
     Copy = 0
     Paste = 0
     SelectAll = 0
     Deselect = 0
     Find = 0
     FindNext = 0
     FindPrev = 0
     Replace = 0
     ActualSize = 0
     FitToPage = 0
     FitToWidth = 0
     FitToHeight = 0
     ZoomIn = 0
     ZoomOut = 0
     Zoom = 0
     Redisplay = 0
     Up = 0
     Back = 0
     Forward = 0
     Home = 0
     Prior = 0
     Next = 0
     Goto = 0
     GotoPage = 0
     GotoLine = 0
     FirstPage = 0
     LastPage = 0
     DocumentBack = 0
     DocumentForward = 0
     AddBookmark = 0
     EditBookmarks = 0
     Spelling = 0
     ShowMenubar = 0
     ShowToolbar = 0
     ShowStatusbar = 0
     SaveOptions = 0
     KeyBindings = 0
     Preferences = 0
     ConfigureToolbars = 0
     Help = 0
     HelpContents = 0
     WhatsThis = 0
     ReportBug = 0
     AboutApp = 0
     AboutKDE = 0
     TipofDay = 0
     ConfigureNotifications = 0
     FullScreen = 0
     Clear = 0
     PasteText = 0
     SwitchApplicationLanguage = 0
 
     def aboutKDE(self, parent):
         '''static SLOT() KStandardAction.aboutKDE(QObject parent)'''
         return SLOT()()
     def aboutKDE(self, parent):
         '''static callable KStandardAction.aboutKDE(QObject parent)'''
         return callable()
     def aboutApp(self, parent):
         '''static SLOT() KStandardAction.aboutApp(QObject parent)'''
         return SLOT()()
     def aboutApp(self, parent):
         '''static callable KStandardAction.aboutApp(QObject parent)'''
         return callable()
     def reportBug(self, parent):
         '''static SLOT() KStandardAction.reportBug(QObject parent)'''
         return SLOT()()
     def reportBug(self, parent):
         '''static callable KStandardAction.reportBug(QObject parent)'''
         return callable()
     def tipOfDay(self, parent):
         '''static SLOT() KStandardAction.tipOfDay(QObject parent)'''
         return SLOT()()
     def tipOfDay(self, parent):
         '''static callable KStandardAction.tipOfDay(QObject parent)'''
         return callable()
     def whatsThis(self, parent):
         '''static SLOT() KStandardAction.whatsThis(QObject parent)'''
         return SLOT()()
     def whatsThis(self, parent):
         '''static callable KStandardAction.whatsThis(QObject parent)'''
         return callable()
     def helpContents(self, parent):
         '''static SLOT() KStandardAction.helpContents(QObject parent)'''
         return SLOT()()
     def helpContents(self, parent):
         '''static callable KStandardAction.helpContents(QObject parent)'''
         return callable()
     def help(self, parent):
         '''static SLOT() KStandardAction.help(QObject parent)'''
         return SLOT()()
     def help(self, parent):
         '''static callable KStandardAction.help(QObject parent)'''
         return callable()
     def configureNotifications(self, parent):
         '''static SLOT() KStandardAction.configureNotifications(QObject parent)'''
         return SLOT()()
     def configureNotifications(self, parent):
         '''static callable KStandardAction.configureNotifications(QObject parent)'''
         return callable()
     def configureToolbars(self, parent):
         '''static SLOT() KStandardAction.configureToolbars(QObject parent)'''
         return SLOT()()
     def configureToolbars(self, parent):
         '''static callable KStandardAction.configureToolbars(QObject parent)'''
         return callable()
     def preferences(self, parent):
         '''static SLOT() KStandardAction.preferences(QObject parent)'''
         return SLOT()()
     def preferences(self, parent):
         '''static callable KStandardAction.preferences(QObject parent)'''
         return callable()
     def keyBindings(self, parent):
         '''static SLOT() KStandardAction.keyBindings(QObject parent)'''
         return SLOT()()
     def keyBindings(self, parent):
         '''static callable KStandardAction.keyBindings(QObject parent)'''
         return callable()
     def saveOptions(self, parent):
         '''static SLOT() KStandardAction.saveOptions(QObject parent)'''
         return SLOT()()
     def saveOptions(self, parent):
         '''static callable KStandardAction.saveOptions(QObject parent)'''
         return callable()
     def fullScreen(self, window, parent):
         '''static SLOT() KStandardAction.fullScreen(QWidget window, QObject parent)'''
         return SLOT()()
     def fullScreen(self, window, parent):
         '''static callable KStandardAction.fullScreen(QWidget window, QObject parent)'''
         return callable()
     def showStatusbar(self, parent):
         '''static SLOT() KStandardAction.showStatusbar(QObject parent)'''
         return SLOT()()
     def showStatusbar(self, parent):
         '''static callable KStandardAction.showStatusbar(QObject parent)'''
         return callable()
     def showMenubar(self, parent):
         '''static SLOT() KStandardAction.showMenubar(QObject parent)'''
         return SLOT()()
     def showMenubar(self, parent):
         '''static callable KStandardAction.showMenubar(QObject parent)'''
         return callable()
     def spelling(self, parent):
         '''static SLOT() KStandardAction.spelling(QObject parent)'''
         return SLOT()()
     def spelling(self, parent):
         '''static callable KStandardAction.spelling(QObject parent)'''
         return callable()
     def editBookmarks(self, parent):
         '''static SLOT() KStandardAction.editBookmarks(QObject parent)'''
         return SLOT()()
     def editBookmarks(self, parent):
         '''static callable KStandardAction.editBookmarks(QObject parent)'''
         return callable()
     def addBookmark(self, parent):
         '''static SLOT() KStandardAction.addBookmark(QObject parent)'''
         return SLOT()()
     def addBookmark(self, parent):
         '''static callable KStandardAction.addBookmark(QObject parent)'''
         return callable()
     def documentForward(self, parent):
         '''static SLOT() KStandardAction.documentForward(QObject parent)'''
         return SLOT()()
     def documentForward(self, parent):
         '''static callable KStandardAction.documentForward(QObject parent)'''
         return callable()
     def documentBack(self, parent):
         '''static SLOT() KStandardAction.documentBack(QObject parent)'''
         return SLOT()()
     def documentBack(self, parent):
         '''static callable KStandardAction.documentBack(QObject parent)'''
         return callable()
     def lastPage(self, parent):
         '''static SLOT() KStandardAction.lastPage(QObject parent)'''
         return SLOT()()
     def lastPage(self, parent):
         '''static callable KStandardAction.lastPage(QObject parent)'''
         return callable()
     def firstPage(self, parent):
         '''static SLOT() KStandardAction.firstPage(QObject parent)'''
         return SLOT()()
     def firstPage(self, parent):
         '''static callable KStandardAction.firstPage(QObject parent)'''
         return callable()
     def gotoLine(self, parent):
         '''static SLOT() KStandardAction.gotoLine(QObject parent)'''
         return SLOT()()
     def gotoLine(self, parent):
         '''static callable KStandardAction.gotoLine(QObject parent)'''
         return callable()
     def gotoPage(self, parent):
         '''static SLOT() KStandardAction.gotoPage(QObject parent)'''
         return SLOT()()
     def gotoPage(self, parent):
         '''static callable KStandardAction.gotoPage(QObject parent)'''
         return callable()
     def goTo(self, parent):
         '''static SLOT() KStandardAction.goTo(QObject parent)'''
         return SLOT()()
     def goTo(self, parent):
         '''static callable KStandardAction.goTo(QObject parent)'''
         return callable()
     def next(self, parent):
         '''static SLOT() KStandardAction.next(QObject parent)'''
         return SLOT()()
     def next(self, parent):
         '''static callable KStandardAction.next(QObject parent)'''
         return callable()
     def prior(self, parent):
         '''static SLOT() KStandardAction.prior(QObject parent)'''
         return SLOT()()
     def prior(self, parent):
         '''static callable KStandardAction.prior(QObject parent)'''
         return callable()
     def home(self, parent):
         '''static SLOT() KStandardAction.home(QObject parent)'''
         return SLOT()()
     def home(self, parent):
         '''static callable KStandardAction.home(QObject parent)'''
         return callable()
     def forward(self, parent):
         '''static SLOT() KStandardAction.forward(QObject parent)'''
         return SLOT()()
     def forward(self, parent):
         '''static callable KStandardAction.forward(QObject parent)'''
         return callable()
     def back(self, parent):
         '''static SLOT() KStandardAction.back(QObject parent)'''
         return SLOT()()
     def back(self, parent):
         '''static callable KStandardAction.back(QObject parent)'''
         return callable()
     def up(self, parent):
         '''static SLOT() KStandardAction.up(QObject parent)'''
         return SLOT()()
     def up(self, parent):
         '''static callable KStandardAction.up(QObject parent)'''
         return callable()
     def redisplay(self, parent):
         '''static SLOT() KStandardAction.redisplay(QObject parent)'''
         return SLOT()()
     def redisplay(self, parent):
         '''static callable KStandardAction.redisplay(QObject parent)'''
         return callable()
     def zoom(self, parent):
         '''static SLOT() KStandardAction.zoom(QObject parent)'''
         return SLOT()()
     def zoom(self, parent):
         '''static callable KStandardAction.zoom(QObject parent)'''
         return callable()
     def zoomOut(self, parent):
         '''static SLOT() KStandardAction.zoomOut(QObject parent)'''
         return SLOT()()
     def zoomOut(self, parent):
         '''static callable KStandardAction.zoomOut(QObject parent)'''
         return callable()
     def zoomIn(self, parent):
         '''static SLOT() KStandardAction.zoomIn(QObject parent)'''
         return SLOT()()
     def zoomIn(self, parent):
         '''static callable KStandardAction.zoomIn(QObject parent)'''
         return callable()
     def fitToHeight(self, parent):
         '''static SLOT() KStandardAction.fitToHeight(QObject parent)'''
         return SLOT()()
     def fitToHeight(self, parent):
         '''static callable KStandardAction.fitToHeight(QObject parent)'''
         return callable()
     def fitToWidth(self, parent):
         '''static SLOT() KStandardAction.fitToWidth(QObject parent)'''
         return SLOT()()
     def fitToWidth(self, parent):
         '''static callable KStandardAction.fitToWidth(QObject parent)'''
         return callable()
     def fitToPage(self, parent):
         '''static SLOT() KStandardAction.fitToPage(QObject parent)'''
         return SLOT()()
     def fitToPage(self, parent):
         '''static callable KStandardAction.fitToPage(QObject parent)'''
         return callable()
     def actualSize(self, parent):
         '''static SLOT() KStandardAction.actualSize(QObject parent)'''
         return SLOT()()
     def actualSize(self, parent):
         '''static callable KStandardAction.actualSize(QObject parent)'''
         return callable()
     def replace(self, parent):
         '''static SLOT() KStandardAction.replace(QObject parent)'''
         return SLOT()()
     def replace(self, parent):
         '''static callable KStandardAction.replace(QObject parent)'''
         return callable()
     def findPrev(self, parent):
         '''static SLOT() KStandardAction.findPrev(QObject parent)'''
         return SLOT()()
     def findPrev(self, parent):
         '''static callable KStandardAction.findPrev(QObject parent)'''
         return callable()
     def findNext(self, parent):
         '''static SLOT() KStandardAction.findNext(QObject parent)'''
         return SLOT()()
     def findNext(self, parent):
         '''static callable KStandardAction.findNext(QObject parent)'''
         return callable()
     def find(self, parent):
         '''static SLOT() KStandardAction.find(QObject parent)'''
         return SLOT()()
     def find(self, parent):
         '''static callable KStandardAction.find(QObject parent)'''
         return callable()
     def deselect(self, parent):
         '''static SLOT() KStandardAction.deselect(QObject parent)'''
         return SLOT()()
     def deselect(self, parent):
         '''static callable KStandardAction.deselect(QObject parent)'''
         return callable()
     def pasteText(self, parent):
         '''static SLOT() KStandardAction.pasteText(QObject parent)'''
         return SLOT()()
     def pasteText(self, parent):
         '''static callable KStandardAction.pasteText(QObject parent)'''
         return callable()
     def selectAll(self, parent):
         '''static KAction KStandardAction.selectAll(QObject parent)'''
         return KAction()
     def selectAll(self, parent):
         '''static SLOT() KStandardAction.selectAll(QObject parent)'''
         return SLOT()()
     def selectAll(self, parent):
         '''static callable KStandardAction.selectAll(QObject parent)'''
         return callable()
     def clear(self, parent):
         '''static KAction KStandardAction.clear(QObject parent)'''
         return KAction()
     def clear(self, parent):
         '''static SLOT() KStandardAction.clear(QObject parent)'''
         return SLOT()()
     def clear(self, parent):
         '''static callable KStandardAction.clear(QObject parent)'''
         return callable()
     def paste(self, parent):
         '''static KAction KStandardAction.paste(QObject parent)'''
         return KAction()
     def paste(self, parent):
         '''static SLOT() KStandardAction.paste(QObject parent)'''
         return SLOT()()
     def paste(self, parent):
         '''static callable KStandardAction.paste(QObject parent)'''
         return callable()
     def copy(self, parent):
         '''static KAction KStandardAction.copy(QObject parent)'''
         return KAction()
     def copy(self, parent):
         '''static SLOT() KStandardAction.copy(QObject parent)'''
         return SLOT()()
     def copy(self, parent):
         '''static callable KStandardAction.copy(QObject parent)'''
         return callable()
     def cut(self, parent):
         '''static KAction KStandardAction.cut(QObject parent)'''
         return KAction()
     def cut(self, parent):
         '''static SLOT() KStandardAction.cut(QObject parent)'''
         return SLOT()()
     def cut(self, parent):
         '''static callable KStandardAction.cut(QObject parent)'''
         return callable()
     def redo(self, parent):
         '''static SLOT() KStandardAction.redo(QObject parent)'''
         return SLOT()()
     def redo(self, parent):
         '''static callable KStandardAction.redo(QObject parent)'''
         return callable()
     def undo(self, parent):
         '''static SLOT() KStandardAction.undo(QObject parent)'''
         return SLOT()()
     def undo(self, parent):
         '''static callable KStandardAction.undo(QObject parent)'''
         return callable()
     def quit(self, parent):
         '''static SLOT() KStandardAction.quit(QObject parent)'''
         return SLOT()()
     def quit(self, parent):
         '''static callable KStandardAction.quit(QObject parent)'''
         return callable()
     def mail(self, parent):
         '''static SLOT() KStandardAction.mail(QObject parent)'''
         return SLOT()()
     def mail(self, parent):
         '''static callable KStandardAction.mail(QObject parent)'''
         return callable()
     def printPreview(self, parent):
         '''static SLOT() KStandardAction.printPreview(QObject parent)'''
         return SLOT()()
     def printPreview(self, parent):
         '''static callable KStandardAction.printPreview(QObject parent)'''
         return callable()
     def print_(self, parent):
         '''static SLOT() KStandardAction.print_(QObject parent)'''
         return SLOT()()
     def print_(self, parent):
         '''static callable KStandardAction.print_(QObject parent)'''
         return callable()
     def close(self, parent):
         '''static SLOT() KStandardAction.close(QObject parent)'''
         return SLOT()()
     def close(self, parent):
         '''static callable KStandardAction.close(QObject parent)'''
         return callable()
     def revert(self, parent):
         '''static SLOT() KStandardAction.revert(QObject parent)'''
         return SLOT()()
     def revert(self, parent):
         '''static callable KStandardAction.revert(QObject parent)'''
         return callable()
     def saveAs(self, parent):
         '''static SLOT() KStandardAction.saveAs(QObject parent)'''
         return SLOT()()
     def saveAs(self, parent):
         '''static callable KStandardAction.saveAs(QObject parent)'''
         return callable()
     def save(self, parent):
         '''static SLOT() KStandardAction.save(QObject parent)'''
         return SLOT()()
     def save(self, parent):
         '''static callable KStandardAction.save(QObject parent)'''
         return callable()
     def openRecent(self, parent):
         '''static SLOT() KStandardAction.openRecent(QObject parent)'''
         return SLOT()()
     def openRecent(self, parent):
         '''static callable KStandardAction.openRecent(QObject parent)'''
         return callable()
     def open(self, parent):
         '''static SLOT() KStandardAction.open(QObject parent)'''
         return SLOT()()
     def open(self, parent):
         '''static callable KStandardAction.open(QObject parent)'''
         return callable()
     def openNew(self, parent):
         '''static SLOT() KStandardAction.openNew(QObject parent)'''
         return SLOT()()
     def openNew(self, parent):
         '''static callable KStandardAction.openNew(QObject parent)'''
         return callable()
     def shortcutForActionId(self, id):
         '''static KStandardShortcut.StandardShortcut KStandardAction.shortcutForActionId(KStandardAction.StandardAction id)'''
         return KStandardShortcut.StandardShortcut()
     def actionIds(self):
         '''static unknown-type KStandardAction.actionIds()'''
         return unknown-type()
     def stdNames(self):
         '''static QStringList KStandardAction.stdNames()'''
         return QStringList()
     def stdName(self, act_enum):
         '''static str KStandardAction.stdName(KStandardAction.StandardAction act_enum)'''
         return str()
     def name(self, id):
         '''static str KStandardAction.name(KStandardAction.StandardAction id)'''
         return str()
     def create(self, id, parent):
         '''static SLOT() KStandardAction.create(KStandardAction.StandardAction id, QObject parent)'''
         return SLOT()()
     def create(self, id, parent):
         '''static callable KStandardAction.create(KStandardAction.StandardAction id, QObject parent)'''
         return callable()
 
 
 class KStandardGuiItem():
     """"""
     # Enum KStandardGuiItem.StandardItem
     Ok = 0
     Cancel = 0
     Yes = 0
     No = 0
     Discard = 0
     Save = 0
     DontSave = 0
     SaveAs = 0
     Apply = 0
     Clear = 0
     Help = 0
     Defaults = 0
     Close = 0
     Back = 0
     Forward = 0
     Print = 0
     Continue = 0
     Open = 0
     Quit = 0
     AdminMode = 0
     Reset = 0
     Delete = 0
     Insert = 0
     Configure = 0
     Find = 0
     Stop = 0
     Add = 0
     Remove = 0
     Test = 0
     Properties = 0
     Overwrite = 0
     CloseWindow = 0
     CloseDocument = 0
 
     # Enum KStandardGuiItem.BidiMode
     UseRTL = 0
     IgnoreRTL = 0
 
     def test(self):
         '''static KGuiItem KStandardGuiItem.test()'''
         return KGuiItem()
     def remove(self):
         '''static KGuiItem KStandardGuiItem.remove()'''
         return KGuiItem()
     def add(self):
         '''static KGuiItem KStandardGuiItem.add()'''
         return KGuiItem()
     def stop(self):
         '''static KGuiItem KStandardGuiItem.stop()'''
         return KGuiItem()
     def find(self):
         '''static KGuiItem KStandardGuiItem.find()'''
         return KGuiItem()
     def quit(self):
         '''static KGuiItem KStandardGuiItem.quit()'''
         return KGuiItem()
     def backAndForward(self):
         '''static unknown-type KStandardGuiItem.backAndForward()'''
         return unknown-type()
     def configure(self):
         '''static KGuiItem KStandardGuiItem.configure()'''
         return KGuiItem()
     def forward(self, useBidi = None):
         '''static KGuiItem KStandardGuiItem.forward(KStandardGuiItem.BidiMode useBidi = KStandardGuiItem.IgnoreRTL)'''
         return KGuiItem()
     def back(self, useBidi = None):
         '''static KGuiItem KStandardGuiItem.back(KStandardGuiItem.BidiMode useBidi = KStandardGuiItem.IgnoreRTL)'''
         return KGuiItem()
     def open(self):
         '''static KGuiItem KStandardGuiItem.open()'''
         return KGuiItem()
     def del_(self):
         '''static KGuiItem KStandardGuiItem.del_()'''
         return KGuiItem()
     def cont(self):
         '''static KGuiItem KStandardGuiItem.cont()'''
         return KGuiItem()
     def adminMode(self):
         '''static KGuiItem KStandardGuiItem.adminMode()'''
         return KGuiItem()
     def overwrite(self):
         '''static KGuiItem KStandardGuiItem.overwrite()'''
         return KGuiItem()
     def reset(self):
         '''static KGuiItem KStandardGuiItem.reset()'''
         return KGuiItem()
     def properties(self):
         '''static KGuiItem KStandardGuiItem.properties()'''
         return KGuiItem()
     def print_(self):
         '''static KGuiItem KStandardGuiItem.print_()'''
         return KGuiItem()
     def closeDocument(self):
         '''static KGuiItem KStandardGuiItem.closeDocument()'''
         return KGuiItem()
     def closeWindow(self):
         '''static KGuiItem KStandardGuiItem.closeWindow()'''
         return KGuiItem()
     def close(self):
         '''static KGuiItem KStandardGuiItem.close()'''
         return KGuiItem()
     def defaults(self):
         '''static KGuiItem KStandardGuiItem.defaults()'''
         return KGuiItem()
     def clear(self):
         '''static KGuiItem KStandardGuiItem.clear()'''
         return KGuiItem()
     def apply(self):
         '''static KGuiItem KStandardGuiItem.apply()'''
         return KGuiItem()
     def saveAs(self):
         '''static KGuiItem KStandardGuiItem.saveAs()'''
         return KGuiItem()
     def dontSave(self):
         '''static KGuiItem KStandardGuiItem.dontSave()'''
         return KGuiItem()
     def help(self):
         '''static KGuiItem KStandardGuiItem.help()'''
         return KGuiItem()
     def save(self):
         '''static KGuiItem KStandardGuiItem.save()'''
         return KGuiItem()
     def discard(self):
         '''static KGuiItem KStandardGuiItem.discard()'''
         return KGuiItem()
     def insert(self):
         '''static KGuiItem KStandardGuiItem.insert()'''
         return KGuiItem()
     def no(self):
         '''static KGuiItem KStandardGuiItem.no()'''
         return KGuiItem()
     def yes(self):
         '''static KGuiItem KStandardGuiItem.yes()'''
         return KGuiItem()
     def cancel(self):
         '''static KGuiItem KStandardGuiItem.cancel()'''
         return KGuiItem()
     def ok(self):
         '''static KGuiItem KStandardGuiItem.ok()'''
         return KGuiItem()
     def standardItem(self, id):
         '''static QString KStandardGuiItem.standardItem(KStandardGuiItem.StandardItem id)'''
         return QString()
     def guiItem(self, id):
         '''static KGuiItem KStandardGuiItem.guiItem(KStandardGuiItem.StandardItem id)'''
         return KGuiItem()
 
 
 class KStandardShortcut():
     """"""
     # Enum KStandardShortcut.StandardShortcut
     AccelNone = 0
     Open = 0
     New = 0
     Close = 0
     Save = 0
     Print = 0
     Quit = 0
     Undo = 0
     Redo = 0
     Cut = 0
     Copy = 0
     Paste = 0
     PasteSelection = 0
     SelectAll = 0
     Deselect = 0
     DeleteWordBack = 0
     DeleteWordForward = 0
     Find = 0
     FindNext = 0
     FindPrev = 0
     Replace = 0
     Home = 0
     Begin = 0
     End = 0
     Prior = 0
     Next = 0
     Up = 0
     Back = 0
     Forward = 0
     Reload = 0
     BeginningOfLine = 0
     EndOfLine = 0
     GotoLine = 0
     BackwardWord = 0
     ForwardWord = 0
     AddBookmark = 0
     ZoomIn = 0
     ZoomOut = 0
     FullScreen = 0
     ShowMenubar = 0
     TabNext = 0
     TabPrev = 0
     Help = 0
     WhatsThis = 0
     TextCompletion = 0
     PrevCompletion = 0
     NextCompletion = 0
     SubstringCompletion = 0
     RotateUp = 0
     RotateDown = 0
     OpenRecent = 0
     SaveAs = 0
     Revert = 0
     PrintPreview = 0
     Mail = 0
     Clear = 0
     ActualSize = 0
     FitToPage = 0
     FitToWidth = 0
     FitToHeight = 0
     Zoom = 0
     Goto = 0
     GotoPage = 0
     DocumentBack = 0
     DocumentForward = 0
     EditBookmarks = 0
     Spelling = 0
     ShowToolbar = 0
     ShowStatusbar = 0
     SaveOptions = 0
     KeyBindings = 0
     Preferences = 0
     ConfigureToolbars = 0
     ConfigureNotifications = 0
     TipofDay = 0
     ReportBug = 0
     SwitchApplicationLanguage = 0
     AboutApp = 0
     AboutKDE = 0
     StandardShortcutCount = 0
 
     def showMenubar(self):
         '''static KShortcut KStandardShortcut.showMenubar()'''
         return KShortcut()
     def forwardWord(self):
         '''static KShortcut KStandardShortcut.forwardWord()'''
         return KShortcut()
     def backwardWord(self):
         '''static KShortcut KStandardShortcut.backwardWord()'''
         return KShortcut()
     def forward(self):
         '''static KShortcut KStandardShortcut.forward()'''
         return KShortcut()
     def back(self):
         '''static KShortcut KStandardShortcut.back()'''
         return KShortcut()
     def up(self):
         '''static KShortcut KStandardShortcut.up()'''
         return KShortcut()
     def reload(self):
         '''static KShortcut KStandardShortcut.reload()'''
         return KShortcut()
     def rotateDown(self):
         '''static KShortcut KStandardShortcut.rotateDown()'''
         return KShortcut()
     def rotateUp(self):
         '''static KShortcut KStandardShortcut.rotateUp()'''
         return KShortcut()
     def substringCompletion(self):
         '''static KShortcut KStandardShortcut.substringCompletion()'''
         return KShortcut()
     def nextCompletion(self):
         '''static KShortcut KStandardShortcut.nextCompletion()'''
         return KShortcut()
     def prevCompletion(self):
         '''static KShortcut KStandardShortcut.prevCompletion()'''
         return KShortcut()
     def completion(self):
         '''static KShortcut KStandardShortcut.completion()'''
         return KShortcut()
     def help(self):
         '''static KShortcut KStandardShortcut.help()'''
         return KShortcut()
     def fullScreen(self):
         '''static KShortcut KStandardShortcut.fullScreen()'''
         return KShortcut()
     def tabPrev(self):
         '''static KShortcut KStandardShortcut.tabPrev()'''
         return KShortcut()
     def tabNext(self):
         '''static KShortcut KStandardShortcut.tabNext()'''
         return KShortcut()
     def addBookmark(self):
         '''static KShortcut KStandardShortcut.addBookmark()'''
         return KShortcut()
     def gotoLine(self):
         '''static KShortcut KStandardShortcut.gotoLine()'''
         return KShortcut()
     def next(self):
         '''static KShortcut KStandardShortcut.next()'''
         return KShortcut()
     def prior(self):
         '''static KShortcut KStandardShortcut.prior()'''
         return KShortcut()
     def endOfLine(self):
         '''static KShortcut KStandardShortcut.endOfLine()'''
         return KShortcut()
     def beginningOfLine(self):
         '''static KShortcut KStandardShortcut.beginningOfLine()'''
         return KShortcut()
     def end(self):
         '''static KShortcut KStandardShortcut.end()'''
         return KShortcut()
     def begin(self):
         '''static KShortcut KStandardShortcut.begin()'''
         return KShortcut()
     def home(self):
         '''static KShortcut KStandardShortcut.home()'''
         return KShortcut()
     def zoomOut(self):
         '''static KShortcut KStandardShortcut.zoomOut()'''
         return KShortcut()
     def zoomIn(self):
         '''static KShortcut KStandardShortcut.zoomIn()'''
         return KShortcut()
     def replace(self):
         '''static KShortcut KStandardShortcut.replace()'''
         return KShortcut()
     def findPrev(self):
         '''static KShortcut KStandardShortcut.findPrev()'''
         return KShortcut()
     def findNext(self):
         '''static KShortcut KStandardShortcut.findNext()'''
         return KShortcut()
     def deleteWordForward(self):
         '''static KShortcut KStandardShortcut.deleteWordForward()'''
         return KShortcut()
     def deleteWordBack(self):
         '''static KShortcut KStandardShortcut.deleteWordBack()'''
         return KShortcut()
     def selectAll(self):
         '''static KShortcut KStandardShortcut.selectAll()'''
         return KShortcut()
     def pasteSelection(self):
         '''static KShortcut KStandardShortcut.pasteSelection()'''
         return KShortcut()
     def paste(self):
         '''static KShortcut KStandardShortcut.paste()'''
         return KShortcut()
     def copy(self):
         '''static KShortcut KStandardShortcut.copy()'''
         return KShortcut()
     def cut(self):
         '''static KShortcut KStandardShortcut.cut()'''
         return KShortcut()
     def redo(self):
         '''static KShortcut KStandardShortcut.redo()'''
         return KShortcut()
     def undo(self):
         '''static KShortcut KStandardShortcut.undo()'''
         return KShortcut()
     def quit(self):
         '''static KShortcut KStandardShortcut.quit()'''
         return KShortcut()
     def print_(self):
         '''static KShortcut KStandardShortcut.print_()'''
         return KShortcut()
     def save(self):
         '''static KShortcut KStandardShortcut.save()'''
         return KShortcut()
     def close(self):
         '''static KShortcut KStandardShortcut.close()'''
         return KShortcut()
     def openNew(self):
         '''static KShortcut KStandardShortcut.openNew()'''
         return KShortcut()
     def open(self):
         '''static KShortcut KStandardShortcut.open()'''
         return KShortcut()
     def saveShortcut(self, id, newShortcut):
         '''static void KStandardShortcut.saveShortcut(KStandardShortcut.StandardShortcut id, KShortcut newShortcut)'''
     def hardcodedDefaultShortcut(self, id):
         '''static KShortcut KStandardShortcut.hardcodedDefaultShortcut(KStandardShortcut.StandardShortcut id)'''
         return KShortcut()
     def find(self, keySeq):
         '''static KStandardShortcut.StandardShortcut KStandardShortcut.find(QKeySequence keySeq)'''
         return KStandardShortcut.StandardShortcut()
     def find(self, keyName):
         '''static KStandardShortcut.StandardShortcut KStandardShortcut.find(str keyName)'''
         return KStandardShortcut.StandardShortcut()
     def find(self):
         '''static KShortcut KStandardShortcut.find()'''
         return KShortcut()
     def whatsThis(self, id):
         '''static QString KStandardShortcut.whatsThis(KStandardShortcut.StandardShortcut id)'''
         return QString()
     def whatsThis(self):
         '''static KShortcut KStandardShortcut.whatsThis()'''
         return KShortcut()
     def label(self, id):
         '''static QString KStandardShortcut.label(KStandardShortcut.StandardShortcut id)'''
         return QString()
     def name(self, id):
         '''static QString KStandardShortcut.name(KStandardShortcut.StandardShortcut id)'''
         return QString()
     def shortcut(self, id):
         '''static KShortcut KStandardShortcut.shortcut(KStandardShortcut.StandardShortcut id)'''
         return KShortcut()
 
 
 class KStartupInfo(QObject):
     """"""
     # Enum KStartupInfo.startup_t
     NoMatch = 0
     Match = 0
     CantDetect = 0
 
     CleanOnCantDetect = None # int - member
     DisableKWinModule = None # int - member
     AnnounceSilenceChanges = None # int - member
     def __init__(self, flags, parent = None):
         '''void KStartupInfo.__init__(int flags, QObject parent = None)'''
     def customEvent(self, e_P):
         '''void KStartupInfo.customEvent(QEvent e_P)'''
     gotRemoveStartup = pyqtSignal() # void gotRemoveStartup(const KStartupInfoIdamp;,const KStartupInfoDataamp;) - signal
     gotStartupChange = pyqtSignal() # void gotStartupChange(const KStartupInfoIdamp;,const KStartupInfoDataamp;) - signal
     gotNewStartup = pyqtSignal() # void gotNewStartup(const KStartupInfoIdamp;,const KStartupInfoDataamp;) - signal
     def handleAutoAppStartedSending(self):
         '''static void KStartupInfo.handleAutoAppStartedSending()'''
     def windowStartupId(self, w):
         '''static QByteArray KStartupInfo.windowStartupId(int w)'''
         return QByteArray()
     def setWindowStartupId(self, window, id):
         '''static void KStartupInfo.setWindowStartupId(int window, QByteArray id)'''
     def setTimeout(self, secs):
         '''void KStartupInfo.setTimeout(int secs)'''
     def checkStartup(self, w):
         '''KStartupInfo.startup_t KStartupInfo.checkStartup(int w)'''
         return KStartupInfo.startup_t()
     def checkStartup(self, w, id):
         '''KStartupInfo.startup_t KStartupInfo.checkStartup(int w, KStartupInfoId id)'''
         return KStartupInfo.startup_t()
     def checkStartup(self, w, data):
         '''KStartupInfo.startup_t KStartupInfo.checkStartup(int w, KStartupInfoData data)'''
         return KStartupInfo.startup_t()
     def checkStartup(self, w, id, data):
         '''KStartupInfo.startup_t KStartupInfo.checkStartup(int w, KStartupInfoId id, KStartupInfoData data)'''
         return KStartupInfo.startup_t()
     def resetStartupEnv(self):
         '''static void KStartupInfo.resetStartupEnv()'''
     def currentStartupIdEnv(self):
         '''static KStartupInfoId KStartupInfo.currentStartupIdEnv()'''
         return KStartupInfoId()
     def sendFinish(self, id):
         '''static bool KStartupInfo.sendFinish(KStartupInfoId id)'''
         return bool()
     def sendFinish(self, id, data):
         '''static bool KStartupInfo.sendFinish(KStartupInfoId id, KStartupInfoData data)'''
         return bool()
     def sendChange(self, id, data):
         '''static bool KStartupInfo.sendChange(KStartupInfoId id, KStartupInfoData data)'''
         return bool()
     def sendStartup(self, id, data):
         '''static bool KStartupInfo.sendStartup(KStartupInfoId id, KStartupInfoData data)'''
         return bool()
     def createNewStartupId(self):
         '''static QByteArray KStartupInfo.createNewStartupId()'''
         return QByteArray()
     def silenceStartup(self, silence):
         '''static void KStartupInfo.silenceStartup(bool silence)'''
     def setNewStartupId(self, window, startup_id):
         '''static void KStartupInfo.setNewStartupId(QWidget window, QByteArray startup_id)'''
     def appStarted(self):
         '''static void KStartupInfo.appStarted()'''
     def appStarted(self, startup_id):
         '''static void KStartupInfo.appStarted(QByteArray startup_id)'''
     def disableAutoAppStartedSending(self, disable = True):
         '''static void KStartupInfo.disableAutoAppStartedSending(bool disable = True)'''
 
 
 class KStartupInfoId():
     """"""
     def __init__(self):
         '''void KStartupInfoId.__init__()'''
     def __init__(self, data):
         '''void KStartupInfoId.__init__(KStartupInfoId data)'''
     def __ge__(self, id):
         '''bool KStartupInfoId.__ge__(KStartupInfoId id)'''
         return bool()
     def __lt__(self, id):
         '''bool KStartupInfoId.__lt__(KStartupInfoId id)'''
         return bool()
     def setupStartupEnv(self):
         '''bool KStartupInfoId.setupStartupEnv()'''
         return bool()
     def timestamp(self):
         '''int KStartupInfoId.timestamp()'''
         return int()
     def id(self):
         '''QByteArray KStartupInfoId.id()'''
         return QByteArray()
     def initId(self, id = None):
         '''void KStartupInfoId.initId(QByteArray id = )'''
     def none(self):
         '''bool KStartupInfoId.none()'''
         return bool()
     def __ne__(self, id):
         '''bool KStartupInfoId.__ne__(KStartupInfoId id)'''
         return bool()
     def __eq__(self, id):
         '''bool KStartupInfoId.__eq__(KStartupInfoId id)'''
         return bool()
 
 
 class KStartupInfoData():
     """"""
     # Enum KStartupInfoData.TriState
     Yes = 0
     No = 0
     Unknown = 0
 
     def __init__(self):
         '''void KStartupInfoData.__init__()'''
     def __init__(self, data):
         '''void KStartupInfoData.__init__(KStartupInfoData data)'''
     def setApplicationId(self, desktop):
         '''void KStartupInfoData.setApplicationId(QString desktop)'''
     def applicationId(self):
         '''QString KStartupInfoData.applicationId()'''
         return QString()
     def pids(self):
         '''list-of-int KStartupInfoData.pids()'''
         return [int()]
     def update(self, data):
         '''void KStartupInfoData.update(KStartupInfoData data)'''
     def setLaunchedBy(self, window):
         '''void KStartupInfoData.setLaunchedBy(int window)'''
     def launchedBy(self):
         '''int KStartupInfoData.launchedBy()'''
         return int()
     def setXinerama(self, xinerama):
         '''void KStartupInfoData.setXinerama(int xinerama)'''
     def xinerama(self):
         '''int KStartupInfoData.xinerama()'''
         return int()
     def setScreen(self, screen):
         '''void KStartupInfoData.setScreen(int screen)'''
     def screen(self):
         '''int KStartupInfoData.screen()'''
         return int()
     def timestamp(self):
         '''int KStartupInfoData.timestamp()'''
         return int()
     def setTimestamp(self, time):
         '''void KStartupInfoData.setTimestamp(int time)'''
     def silent(self):
         '''KStartupInfoData.TriState KStartupInfoData.silent()'''
         return KStartupInfoData.TriState()
     def setSilent(self, state):
         '''void KStartupInfoData.setSilent(KStartupInfoData.TriState state)'''
     def hostname(self):
         '''QByteArray KStartupInfoData.hostname()'''
         return QByteArray()
     def setHostname(self, hostname = QByteArray()):
         '''void KStartupInfoData.setHostname(QByteArray hostname = QByteArray())'''
     def is_pid(self, pid):
         '''bool KStartupInfoData.is_pid(int pid)'''
         return bool()
     def addPid(self, pid):
         '''void KStartupInfoData.addPid(int pid)'''
     def WMClass(self):
         '''QByteArray KStartupInfoData.WMClass()'''
         return QByteArray()
     def findWMClass(self):
         '''QByteArray KStartupInfoData.findWMClass()'''
         return QByteArray()
     def setWMClass(self, wmclass):
         '''void KStartupInfoData.setWMClass(QByteArray wmclass)'''
     def desktop(self):
         '''int KStartupInfoData.desktop()'''
         return int()
     def setDesktop(self, desktop):
         '''void KStartupInfoData.setDesktop(int desktop)'''
     def icon(self):
         '''QString KStartupInfoData.icon()'''
         return QString()
     def findIcon(self):
         '''QString KStartupInfoData.findIcon()'''
         return QString()
     def setIcon(self, icon):
         '''void KStartupInfoData.setIcon(QString icon)'''
     def description(self):
         '''QString KStartupInfoData.description()'''
         return QString()
     def findDescription(self):
         '''QString KStartupInfoData.findDescription()'''
         return QString()
     def setDescription(self, descr):
         '''void KStartupInfoData.setDescription(QString descr)'''
     def name(self):
         '''QString KStartupInfoData.name()'''
         return QString()
     def findName(self):
         '''QString KStartupInfoData.findName()'''
         return QString()
     def setName(self, name):
         '''void KStartupInfoData.setName(QString name)'''
     def bin(self):
         '''QString KStartupInfoData.bin()'''
         return QString()
     def setBin(self, bin):
         '''void KStartupInfoData.setBin(QString bin)'''
 
 
 class KStatusBar(QStatusBar):
     """"""
     def __init__(self, parent = None):
         '''void KStatusBar.__init__(QWidget parent = None)'''
     def eventFilter(self, object, event):
         '''bool KStatusBar.eventFilter(QObject object, QEvent event)'''
         return bool()
     released = pyqtSignal() # void released(int) - signal
     pressed = pyqtSignal() # void pressed(int) - signal
     def setItemFixed(self, id, width = None):
         '''void KStatusBar.setItemFixed(int id, int width = -1)'''
     def setItemAlignment(self, id, alignment):
         '''void KStatusBar.setItemAlignment(int id, Qt.Alignment alignment)'''
     def changeItem(self, text, id):
         '''void KStatusBar.changeItem(QString text, int id)'''
     def itemText(self, id):
         '''QString KStatusBar.itemText(int id)'''
         return QString()
     def hasItem(self, id):
         '''bool KStatusBar.hasItem(int id)'''
         return bool()
     def removeItem(self, id):
         '''void KStatusBar.removeItem(int id)'''
     def insertPermanentFixedItem(self, text, id):
         '''void KStatusBar.insertPermanentFixedItem(QString text, int id)'''
     def insertFixedItem(self, text, id):
         '''void KStatusBar.insertFixedItem(QString text, int id)'''
     def insertPermanentItem(self, text, id, stretch = 0):
         '''void KStatusBar.insertPermanentItem(QString text, int id, int stretch = 0)'''
     def insertItem(self, text, id, stretch = 0):
         '''void KStatusBar.insertItem(QString text, int id, int stretch = 0)'''
 
 
 class KStatusBarJobTracker(KAbstractWidgetJobTracker):
     """"""
     # Enum KStatusBarJobTracker.StatusBarMode
     NoInformation = 0
     LabelOnly = 0
     ProgressOnly = 0
 
     def __init__(self, parent = None, button = True):
         '''void KStatusBarJobTracker.__init__(QWidget parent = None, bool button = True)'''
     def slotClean(self, job):
         '''void KStatusBarJobTracker.slotClean(KJob job)'''
     def speed(self, job, value):
         '''void KStatusBarJobTracker.speed(KJob job, int value)'''
     def percent(self, job, percent):
         '''void KStatusBarJobTracker.percent(KJob job, int percent)'''
     def totalAmount(self, job, unit, amount):
         '''void KStatusBarJobTracker.totalAmount(KJob job, KJob.Unit unit, int amount)'''
     def description(self, job, title, field1, field2):
         '''void KStatusBarJobTracker.description(KJob job, QString title, unknown-type field1, unknown-type field2)'''
     def setStatusBarMode(self, statusBarMode):
         '''void KStatusBarJobTracker.setStatusBarMode(KStatusBarJobTracker.StatusBarModes statusBarMode)'''
     def widget(self, job):
         '''QWidget KStatusBarJobTracker.widget(KJob job)'''
         return QWidget()
     def unregisterJob(self, job):
         '''void KStatusBarJobTracker.unregisterJob(KJob job)'''
     def registerJob(self, job):
         '''void KStatusBarJobTracker.registerJob(KJob job)'''
     class StatusBarModes():
         """"""
         def __init__(self):
             '''KStatusBarJobTracker.StatusBarModes KStatusBarJobTracker.StatusBarModes.__init__()'''
             return KStatusBarJobTracker.StatusBarModes()
         def __init__(self):
             '''int KStatusBarJobTracker.StatusBarModes.__init__()'''
             return int()
         def __init__(self):
             '''void KStatusBarJobTracker.StatusBarModes.__init__()'''
         def __bool__(self):
             '''int KStatusBarJobTracker.StatusBarModes.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KStatusBarJobTracker.StatusBarModes.__ne__(KStatusBarJobTracker.StatusBarModes f)'''
             return bool()
         def __eq__(self, f):
             '''bool KStatusBarJobTracker.StatusBarModes.__eq__(KStatusBarJobTracker.StatusBarModes f)'''
             return bool()
         def __invert__(self):
             '''KStatusBarJobTracker.StatusBarModes KStatusBarJobTracker.StatusBarModes.__invert__()'''
             return KStatusBarJobTracker.StatusBarModes()
         def __and__(self, mask):
             '''KStatusBarJobTracker.StatusBarModes KStatusBarJobTracker.StatusBarModes.__and__(int mask)'''
             return KStatusBarJobTracker.StatusBarModes()
         def __xor__(self, f):
             '''KStatusBarJobTracker.StatusBarModes KStatusBarJobTracker.StatusBarModes.__xor__(KStatusBarJobTracker.StatusBarModes f)'''
             return KStatusBarJobTracker.StatusBarModes()
         def __xor__(self, f):
             '''KStatusBarJobTracker.StatusBarModes KStatusBarJobTracker.StatusBarModes.__xor__(int f)'''
             return KStatusBarJobTracker.StatusBarModes()
         def __or__(self, f):
             '''KStatusBarJobTracker.StatusBarModes KStatusBarJobTracker.StatusBarModes.__or__(KStatusBarJobTracker.StatusBarModes f)'''
             return KStatusBarJobTracker.StatusBarModes()
         def __or__(self, f):
             '''KStatusBarJobTracker.StatusBarModes KStatusBarJobTracker.StatusBarModes.__or__(int f)'''
             return KStatusBarJobTracker.StatusBarModes()
         def __int__(self):
             '''int KStatusBarJobTracker.StatusBarModes.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KStatusBarJobTracker.StatusBarModes KStatusBarJobTracker.StatusBarModes.__ixor__(KStatusBarJobTracker.StatusBarModes f)'''
             return KStatusBarJobTracker.StatusBarModes()
         def __ior__(self, f):
             '''KStatusBarJobTracker.StatusBarModes KStatusBarJobTracker.StatusBarModes.__ior__(KStatusBarJobTracker.StatusBarModes f)'''
             return KStatusBarJobTracker.StatusBarModes()
         def __iand__(self, mask):
             '''KStatusBarJobTracker.StatusBarModes KStatusBarJobTracker.StatusBarModes.__iand__(int mask)'''
             return KStatusBarJobTracker.StatusBarModes()
 
 
 class KStatusNotifierItem(QObject):
     """"""
     # Enum KStatusNotifierItem.ItemCategory
     ApplicationStatus = 0
     Communications = 0
     SystemServices = 0
     Hardware = 0
     Reserved = 0
 
     # Enum KStatusNotifierItem.ItemStatus
     Passive = 0
     Active = 0
     NeedsAttention = 0
 
     def __init__(self, parent = None):
         '''void KStatusNotifierItem.__init__(QObject parent = None)'''
     def __init__(self, id, parent = None):
         '''void KStatusNotifierItem.__init__(QString id, QObject parent = None)'''
     def attentionMovieName(self):
         '''QString KStatusNotifierItem.attentionMovieName()'''
         return QString()
     def setAttentionMovieByName(self, name):
         '''void KStatusNotifierItem.setAttentionMovieByName(QString name)'''
     def eventFilter(self, watched, event):
         '''bool KStatusNotifierItem.eventFilter(QObject watched, QEvent event)'''
         return bool()
     secondaryActivateRequested = pyqtSignal() # void secondaryActivateRequested(const QPointamp;) - signal
     activateRequested = pyqtSignal() # void activateRequested(bool,const QPointamp;) - signal
     scrollRequested = pyqtSignal() # void scrollRequested(int,Qt::Orientation) - signal
     def activate(self, pos = QPoint()):
         '''void KStatusNotifierItem.activate(QPoint pos = QPoint())'''
     def showMessage(self, title, message, icon, timeout = 10000):
         '''void KStatusNotifierItem.showMessage(QString title, QString message, QString icon, int timeout = 10000)'''
     def standardActionsEnabled(self):
         '''bool KStatusNotifierItem.standardActionsEnabled()'''
         return bool()
     def setStandardActionsEnabled(self, enabled):
         '''void KStatusNotifierItem.setStandardActionsEnabled(bool enabled)'''
     def actionCollection(self):
         '''KActionCollection KStatusNotifierItem.actionCollection()'''
         return KActionCollection()
     def associatedWidget(self):
         '''QWidget KStatusNotifierItem.associatedWidget()'''
         return QWidget()
     def setAssociatedWidget(self, parent):
         '''void KStatusNotifierItem.setAssociatedWidget(QWidget parent)'''
     def contextMenu(self):
         '''KMenu KStatusNotifierItem.contextMenu()'''
         return KMenu()
     def setContextMenu(self, menu):
         '''void KStatusNotifierItem.setContextMenu(KMenu menu)'''
     def toolTipSubTitle(self):
         '''QString KStatusNotifierItem.toolTipSubTitle()'''
         return QString()
     def setToolTipSubTitle(self, subTitle):
         '''void KStatusNotifierItem.setToolTipSubTitle(QString subTitle)'''
     def toolTipTitle(self):
         '''QString KStatusNotifierItem.toolTipTitle()'''
         return QString()
     def setToolTipTitle(self, title):
         '''void KStatusNotifierItem.setToolTipTitle(QString title)'''
     def toolTipIconPixmap(self):
         '''QIcon KStatusNotifierItem.toolTipIconPixmap()'''
         return QIcon()
     def setToolTipIconByPixmap(self, icon):
         '''void KStatusNotifierItem.setToolTipIconByPixmap(QIcon icon)'''
     def toolTipIconName(self):
         '''QString KStatusNotifierItem.toolTipIconName()'''
         return QString()
     def setToolTipIconByName(self, name):
         '''void KStatusNotifierItem.setToolTipIconByName(QString name)'''
     def setToolTip(self, iconName, title, subTitle):
         '''void KStatusNotifierItem.setToolTip(QString iconName, QString title, QString subTitle)'''
     def setToolTip(self, icon, title, subTitle):
         '''void KStatusNotifierItem.setToolTip(QIcon icon, QString title, QString subTitle)'''
     def attentionIconPixmap(self):
         '''QIcon KStatusNotifierItem.attentionIconPixmap()'''
         return QIcon()
     def setAttentionIconByPixmap(self, icon):
         '''void KStatusNotifierItem.setAttentionIconByPixmap(QIcon icon)'''
     def attentionIconName(self):
         '''QString KStatusNotifierItem.attentionIconName()'''
         return QString()
     def setAttentionIconByName(self, name):
         '''void KStatusNotifierItem.setAttentionIconByName(QString name)'''
     def overlayIconPixmap(self):
         '''QIcon KStatusNotifierItem.overlayIconPixmap()'''
         return QIcon()
     def setOverlayIconByPixmap(self, icon):
         '''void KStatusNotifierItem.setOverlayIconByPixmap(QIcon icon)'''
     def overlayIconName(self):
         '''QString KStatusNotifierItem.overlayIconName()'''
         return QString()
     def setOverlayIconByName(self, name):
         '''void KStatusNotifierItem.setOverlayIconByName(QString name)'''
     def iconPixmap(self):
         '''QIcon KStatusNotifierItem.iconPixmap()'''
         return QIcon()
     def setIconByPixmap(self, icon):
         '''void KStatusNotifierItem.setIconByPixmap(QIcon icon)'''
     def iconName(self):
         '''QString KStatusNotifierItem.iconName()'''
         return QString()
     def setIconByName(self, name):
         '''void KStatusNotifierItem.setIconByName(QString name)'''
     def status(self):
         '''KStatusNotifierItem.ItemStatus KStatusNotifierItem.status()'''
         return KStatusNotifierItem.ItemStatus()
     def setStatus(self, status):
         '''void KStatusNotifierItem.setStatus(KStatusNotifierItem.ItemStatus status)'''
     def title(self):
         '''QString KStatusNotifierItem.title()'''
         return QString()
     def setTitle(self, title):
         '''void KStatusNotifierItem.setTitle(QString title)'''
     def category(self):
         '''KStatusNotifierItem.ItemCategory KStatusNotifierItem.category()'''
         return KStatusNotifierItem.ItemCategory()
     def setCategory(self, category):
         '''void KStatusNotifierItem.setCategory(KStatusNotifierItem.ItemCategory category)'''
     def id(self):
         '''QString KStatusNotifierItem.id()'''
         return QString()
 
 
 class KStringListValidator(QValidator):
     """"""
     def __init__(self, list = QStringList(), rejecting = True, fixupEnabled = False, parent = None):
         '''void KStringListValidator.__init__(QStringList list = QStringList(), bool rejecting = True, bool fixupEnabled = False, QObject parent = None)'''
     def fixup(self, input):
         '''void KStringListValidator.fixup(QString input)'''
     def validate(self, input, pos):
         '''QValidator.State KStringListValidator.validate(QString input, int pos)'''
         return QValidator.State()
     def stringList(self):
         '''QStringList KStringListValidator.stringList()'''
         return QStringList()
     def setStringList(self, list):
         '''void KStringListValidator.setStringList(QStringList list)'''
     def isFixupEnabled(self):
         '''bool KStringListValidator.isFixupEnabled()'''
         return bool()
     def setFixupEnabled(self, fixupEnabled):
         '''void KStringListValidator.setFixupEnabled(bool fixupEnabled)'''
     def isRejecting(self):
         '''bool KStringListValidator.isRejecting()'''
         return bool()
     def setRejecting(self, rejecting):
         '''void KStringListValidator.setRejecting(bool rejecting)'''
 
 
 class KMimeTypeValidator(QValidator):
     """"""
     def __init__(self, parent = None):
         '''void KMimeTypeValidator.__init__(QObject parent = None)'''
     def fixup(self, input):
         '''void KMimeTypeValidator.fixup(QString input)'''
     def validate(self, input, pos):
         '''QValidator.State KMimeTypeValidator.validate(QString input, int pos)'''
         return QValidator.State()
 
 
 class KStyle(QStyle):
     """"""
     # Enum KStyle.MarginOffsets
     MainMargin = 0
     Top = 0
     Bot = 0
     Left = 0
     Right = 0
     MarginInc = 0
 
     # Enum KStyle.WidgetType
     WT_Generic = 0
     WT_PushButton = 0
     WT_Splitter = 0
     WT_CheckBox = 0
     WT_RadioButton = 0
     WT_DockWidget = 0
     WT_ProgressBar = 0
     WT_MenuBar = 0
     WT_MenuBarItem = 0
     WT_Menu = 0
     WT_MenuItem = 0
     WT_ScrollBar = 0
     WT_TabBar = 0
     WT_TabWidget = 0
     WT_Slider = 0
     WT_Tree = 0
     WT_SpinBox = 0
     WT_ComboBox = 0
     WT_Header = 0
     WT_LineEdit = 0
     WT_GroupBox = 0
     WT_StatusBar = 0
     WT_ToolBar = 0
     WT_ToolButton = 0
     WT_ToolBoxTab = 0
     WT_Window = 0
     WT_Limit = 0
 
     def __init__(self):
         '''void KStyle.__init__()'''
     def standardIconImplementation(self, standardIcon, option = None, widget = None):
         '''QIcon KStyle.standardIconImplementation(QStyle.StandardPixmap standardIcon, QStyleOption option = None, QWidget widget = None)'''
         return QIcon()
     def standardPixmap(self, standardPixmap, opt, widget = None):
         '''QPixmap KStyle.standardPixmap(QStyle.StandardPixmap standardPixmap, QStyleOption opt, QWidget widget = None)'''
         return QPixmap()
     def drawComplexControl(self, cc, opt, p, w):
         '''void KStyle.drawComplexControl(QStyle.ComplexControl cc, QStyleOptionComplex opt, QPainter p, QWidget w)'''
     def hitTestComplexControl(self, cc, opt, pt, w):
         '''QStyle.SubControl KStyle.hitTestComplexControl(QStyle.ComplexControl cc, QStyleOptionComplex opt, QPoint pt, QWidget w)'''
         return QStyle.SubControl()
     def subControlRect(self, control, opt, subControl, w):
         '''QRect KStyle.subControlRect(QStyle.ComplexControl control, QStyleOptionComplex opt, QStyle.SubControl subControl, QWidget w)'''
         return QRect()
     def styleHint(self, hint, opt, w, returnData):
         '''int KStyle.styleHint(QStyle.StyleHint hint, QStyleOption opt, QWidget w, QStyleHintReturn returnData)'''
         return int()
     def sizeFromContents(self, type, opt, contentsSize, w):
         '''QSize KStyle.sizeFromContents(QStyle.ContentsType type, QStyleOption opt, QSize contentsSize, QWidget w)'''
         return QSize()
     def subElementRect(self, subRect, opt, w):
         '''QRect KStyle.subElementRect(QStyle.SubElement subRect, QStyleOption opt, QWidget w)'''
         return QRect()
     def pixelMetric(self, metric, opt = None, w = None):
         '''int KStyle.pixelMetric(QStyle.PixelMetric metric, QStyleOption opt = None, QWidget w = None)'''
         return int()
     def drawPrimitive(self, elem, opt, p, w):
         '''void KStyle.drawPrimitive(QStyle.PrimitiveElement elem, QStyleOption opt, QPainter p, QWidget w)'''
     def drawControl(self, elem, opt, p, w):
         '''void KStyle.drawControl(QStyle.ControlElement elem, QStyleOption opt, QPainter p, QWidget w)'''
     def layoutSpacingImplementation(self, control1, control2, orientation, option, widget):
         '''int KStyle.layoutSpacingImplementation(QSizePolicy.ControlType control1, QSizePolicy.ControlType control2, Qt.Orientation orientation, QStyleOption option, QWidget widget)'''
         return int()
     def eventFilter(self):
         '''QEvent KStyle.eventFilter()'''
         return QEvent()
     def generatedIconPixmap(self, iconMode, pixmap, opt):
         '''QPixmap KStyle.generatedIconPixmap(QIcon.Mode iconMode, QPixmap pixmap, QStyleOption opt)'''
         return QPixmap()
     def standardPalette(self):
         '''QPalette KStyle.standardPalette()'''
         return QPalette()
     def drawItemPixmap(self, painter, rect, alignment, pixmap):
         '''void KStyle.drawItemPixmap(QPainter painter, QRect rect, int alignment, QPixmap pixmap)'''
     def drawItemText(self, painter, rect, flags, pal, enabled, text, textRole = None):
         '''void KStyle.drawItemText(QPainter painter, QRect rect, int flags, QPalette pal, bool enabled, QString text, QPalette.ColorRole textRole = QPalette.NoRole)'''
     def itemPixmapRect(self, r, flags, pixmap):
         '''QRect KStyle.itemPixmapRect(QRect r, int flags, QPixmap pixmap)'''
         return QRect()
     def itemTextRect(self, fm, r, flags, enabled, text):
         '''QRect KStyle.itemTextRect(QFontMetrics fm, QRect r, int flags, bool enabled, QString text)'''
         return QRect()
     def unpolish(self):
         '''QWidget KStyle.unpolish()'''
         return QWidget()
     def unpolish(self):
         '''QApplication KStyle.unpolish()'''
         return QApplication()
     def polish(self):
         '''QWidget KStyle.polish()'''
         return QWidget()
     def polish(self):
         '''QApplication KStyle.polish()'''
         return QApplication()
     def polish(self):
         '''QPalette KStyle.polish()'''
         return QPalette()
     def widgetLayoutProp(self, widgetType, metric, opt = None, w = None):
         '''int KStyle.widgetLayoutProp(KStyle.WidgetType widgetType, int metric, QStyleOption opt = None, QWidget w = None)'''
         return int()
     def setWidgetLayoutProp(self, widget, metric, value):
         '''void KStyle.setWidgetLayoutProp(KStyle.WidgetType widget, int metric, int value)'''
     def centerRect(self, in_, w, h):
         '''QRect KStyle.centerRect(QRect in, int w, int h)'''
         return QRect()
     def centerRect(self, in_, size):
         '''QRect KStyle.centerRect(QRect in, QSize size)'''
         return QRect()
     def drawInsideRect(self, p, r):
         '''void KStyle.drawInsideRect(QPainter p, QRect r)'''
     def newSubElement(self, element):
         '''QStyle.SubElement KStyle.newSubElement(QString element)'''
         return QStyle.SubElement()
     def newControlElement(self, element):
         '''QStyle.ControlElement KStyle.newControlElement(QString element)'''
         return QStyle.ControlElement()
     def newStyleHint(self, element):
         '''QStyle.StyleHint KStyle.newStyleHint(QString element)'''
         return QStyle.StyleHint()
     def customSubElement(self, element, widget):
         '''static QStyle.SubElement KStyle.customSubElement(QString element, QWidget widget)'''
         return QStyle.SubElement()
     def customControlElement(self, element, widget):
         '''static QStyle.ControlElement KStyle.customControlElement(QString element, QWidget widget)'''
         return QStyle.ControlElement()
     def customStyleHint(self, element, widget):
         '''static QStyle.StyleHint KStyle.customStyleHint(QString element, QWidget widget)'''
         return QStyle.StyleHint()
     def defaultStyle(self):
         '''static QString KStyle.defaultStyle()'''
         return QString()
 
 
 class KSvgRenderer(QSvgRenderer):
     """"""
     def __init__(self, parent = None):
         '''void KSvgRenderer.__init__(QObject parent = None)'''
     def __init__(self, filename, parent = None):
         '''void KSvgRenderer.__init__(QString filename, QObject parent = None)'''
     def __init__(self, contents, parent = None):
         '''void KSvgRenderer.__init__(QByteArray contents, QObject parent = None)'''
     def load(self, filename):
         '''bool KSvgRenderer.load(QString filename)'''
         return bool()
     def load(self, contents):
         '''bool KSvgRenderer.load(QByteArray contents)'''
         return bool()
 
 
 class KSystemEventFilter():
     """"""
     def removeEventFilter(self, filter):
         '''static void KSystemEventFilter.removeEventFilter(QWidget filter)'''
     def installEventFilter(self, filter):
         '''static void KSystemEventFilter.installEventFilter(QWidget filter)'''
 
 
 class KSystemTrayIcon(QSystemTrayIcon):
     """"""
     def __init__(self, parent = None):
         '''void KSystemTrayIcon.__init__(QWidget parent = None)'''
     def __init__(self, icon, parent = None):
         '''void KSystemTrayIcon.__init__(QString icon, QWidget parent = None)'''
     def __init__(self, icon, parent = None):
         '''void KSystemTrayIcon.__init__(QIcon icon, QWidget parent = None)'''
     def __init__(self, movie, parent):
         '''void KSystemTrayIcon.__init__(QMovie movie, QWidget parent)'''
     def toggleActive(self):
         '''void KSystemTrayIcon.toggleActive()'''
     quitSelected = pyqtSignal() # void quitSelected() - signal
     def contextMenuTitle(self):
         '''QAction KSystemTrayIcon.contextMenuTitle()'''
         return QAction()
     def setContextMenuTitle(self, action):
         '''void KSystemTrayIcon.setContextMenuTitle(QAction action)'''
     def loadIcon(self, icon, componentData = None):
         '''static QIcon KSystemTrayIcon.loadIcon(QString icon, KComponentData componentData = KGlobal.mainComponent())'''
         return QIcon()
     def parentWidgetTrayClose(self):
         '''bool KSystemTrayIcon.parentWidgetTrayClose()'''
         return bool()
     def parentWidget(self):
         '''QWidget KSystemTrayIcon.parentWidget()'''
         return QWidget()
     def actionCollection(self):
         '''KActionCollection KSystemTrayIcon.actionCollection()'''
         return KActionCollection()
     def movie(self):
         '''QMovie KSystemTrayIcon.movie()'''
         return QMovie()
     def setMovie(self, movie):
         '''void KSystemTrayIcon.setMovie(QMovie movie)'''
 
 
 class KTabBar(QTabBar):
     """"""
     def __init__(self, parent = None):
         '''void KTabBar.__init__(QWidget parent = None)'''
     def tabLayoutChange(self):
         '''void KTabBar.tabLayoutChange()'''
     def activateDragSwitchTab(self):
         '''void KTabBar.activateDragSwitchTab()'''
     def enableCloseButton(self):
         '''void KTabBar.enableCloseButton()'''
     def closeButtonClicked(self):
         '''void KTabBar.closeButtonClicked()'''
     def tabSizeHint(self, index):
         '''QSize KTabBar.tabSizeHint(int index)'''
         return QSize()
     def leaveEvent(self, event):
         '''void KTabBar.leaveEvent(QEvent event)'''
     def paintEvent(self, event):
         '''void KTabBar.paintEvent(QPaintEvent event)'''
     def dropEvent(self, event):
         '''void KTabBar.dropEvent(QDropEvent event)'''
     def dragMoveEvent(self, event):
         '''void KTabBar.dragMoveEvent(QDragMoveEvent event)'''
     def dragEnterEvent(self, event):
         '''void KTabBar.dragEnterEvent(QDragEnterEvent event)'''
     def wheelEvent(self, event):
         '''void KTabBar.wheelEvent(QWheelEvent event)'''
     def mouseReleaseEvent(self, event):
         '''void KTabBar.mouseReleaseEvent(QMouseEvent event)'''
     def mouseMoveEvent(self, event):
         '''void KTabBar.mouseMoveEvent(QMouseEvent event)'''
     def mousePressEvent(self, event):
         '''void KTabBar.mousePressEvent(QMouseEvent event)'''
     def mouseDoubleClickEvent(self, event):
         '''void KTabBar.mouseDoubleClickEvent(QMouseEvent event)'''
     wheelDelta = pyqtSignal() # void wheelDelta(int) - signal
     closeRequest = pyqtSignal() # void closeRequest(int) - signal
     moveTab = pyqtSignal() # void moveTab(int,int) - signal
     receivedDropEvent = pyqtSignal() # void receivedDropEvent(int,QDropEvent *) - signal
     initiateDrag = pyqtSignal() # void initiateDrag(int) - signal
     mouseMiddleClick = pyqtSignal() # void mouseMiddleClick(int) - signal
     newTabRequest = pyqtSignal() # void newTabRequest() - signal
     tabDoubleClicked = pyqtSignal() # void tabDoubleClicked(int) - signal
     mouseDoubleClick = pyqtSignal() # void mouseDoubleClick(int) - signal
     emptyAreaContextMenu = pyqtSignal() # void emptyAreaContextMenu(const QPointamp;) - signal
     contextMenu = pyqtSignal() # void contextMenu(int,const QPointamp;) - signal
     def selectTab(self, position):
         '''int KTabBar.selectTab(QPoint position)'''
         return int()
     def tabCloseActivatePrevious(self):
         '''bool KTabBar.tabCloseActivatePrevious()'''
         return bool()
     def setTabCloseActivatePrevious(self):
         '''bool KTabBar.setTabCloseActivatePrevious()'''
         return bool()
     def isCloseButtonEnabled(self):
         '''bool KTabBar.isCloseButtonEnabled()'''
         return bool()
     def setCloseButtonEnabled(self):
         '''bool KTabBar.setCloseButtonEnabled()'''
         return bool()
     def hoverCloseButtonDelayed(self):
         '''bool KTabBar.hoverCloseButtonDelayed()'''
         return bool()
     def setHoverCloseButtonDelayed(self):
         '''bool KTabBar.setHoverCloseButtonDelayed()'''
         return bool()
     def hoverCloseButton(self):
         '''bool KTabBar.hoverCloseButton()'''
         return bool()
     def setHoverCloseButton(self):
         '''bool KTabBar.setHoverCloseButton()'''
         return bool()
     def isTabReorderingEnabled(self):
         '''bool KTabBar.isTabReorderingEnabled()'''
         return bool()
     def setTabReorderingEnabled(self, enable):
         '''void KTabBar.setTabReorderingEnabled(bool enable)'''
 
 
 class KTabWidget(QTabWidget):
     """"""
     def __init__(self, parent = None, flags = 0):
         '''void KTabWidget.__init__(QWidget parent = None, Qt.WindowFlags flags = 0)'''
     def mouseReleaseEvent(self):
         '''QMouseEvent KTabWidget.mouseReleaseEvent()'''
         return QMouseEvent()
     def wheelDelta(self):
         '''int KTabWidget.wheelDelta()'''
         return int()
     def currentChanged(self):
         '''int KTabWidget.currentChanged()'''
         return int()
     def tabRemoved(self):
         '''int KTabWidget.tabRemoved()'''
         return int()
     def tabInserted(self):
         '''int KTabWidget.tabInserted()'''
         return int()
     def resizeEvent(self):
         '''QResizeEvent KTabWidget.resizeEvent()'''
         return QResizeEvent()
     def wheelEvent(self):
         '''QWheelEvent KTabWidget.wheelEvent()'''
         return QWheelEvent()
     def tabBarWidthForMaxChars(self):
         '''int KTabWidget.tabBarWidthForMaxChars()'''
         return int()
     def dropEvent(self):
         '''QDropEvent KTabWidget.dropEvent()'''
         return QDropEvent()
     def dragMoveEvent(self):
         '''QDragMoveEvent KTabWidget.dragMoveEvent()'''
         return QDragMoveEvent()
     def dragEnterEvent(self):
         '''QDragEnterEvent KTabWidget.dragEnterEvent()'''
         return QDragEnterEvent()
     def mousePressEvent(self):
         '''QMouseEvent KTabWidget.mousePressEvent()'''
         return QMouseEvent()
     def mouseDoubleClickEvent(self):
         '''QMouseEvent KTabWidget.mouseDoubleClickEvent()'''
         return QMouseEvent()
     closeRequest = pyqtSignal() # void closeRequest(QWidget *) - signal
     mouseMiddleClick = pyqtSignal() # void mouseMiddleClick() - signal
     mouseMiddleClick = pyqtSignal() # void mouseMiddleClick(QWidget *) - signal
     mouseDoubleClick = pyqtSignal() # void mouseDoubleClick() - signal
     mouseDoubleClick = pyqtSignal() # void mouseDoubleClick(QWidget *) - signal
     movedTab = pyqtSignal() # void movedTab(int,int) - signal
     contextMenu = pyqtSignal() # void contextMenu(QWidget *,const QPointamp;) - signal
     initiateDrag = pyqtSignal() # void initiateDrag(QWidget *) - signal
     receivedDropEvent = pyqtSignal() # void receivedDropEvent(QDropEvent *) - signal
     receivedDropEvent = pyqtSignal() # void receivedDropEvent(QWidget *,QDropEvent *) - signal
     def setAutomaticResizeTabs(self, enable):
         '''void KTabWidget.setAutomaticResizeTabs(bool enable)'''
     def setTabCloseActivatePrevious(self, previous):
         '''void KTabWidget.setTabCloseActivatePrevious(bool previous)'''
     def setCloseButtonEnabled(self):
         '''bool KTabWidget.setCloseButtonEnabled()'''
         return bool()
     def setHoverCloseButtonDelayed(self, delayed):
         '''void KTabWidget.setHoverCloseButtonDelayed(bool delayed)'''
     def setHoverCloseButton(self, enable):
         '''void KTabWidget.setHoverCloseButton(bool enable)'''
     def setTabReorderingEnabled(self, enable):
         '''void KTabWidget.setTabReorderingEnabled(bool enable)'''
     def removeTab(self, index):
         '''void KTabWidget.removeTab(int index)'''
     def removePage(self, w):
         '''void KTabWidget.removePage(QWidget w)'''
     def moveTab(self):
         '''int KTabWidget.moveTab()'''
         return int()
     def setTabText(self):
         '''QString KTabWidget.setTabText()'''
         return QString()
     def tabText(self):
         '''int KTabWidget.tabText()'''
         return int()
     def isTabBarHidden(self):
         '''bool KTabWidget.isTabBarHidden()'''
         return bool()
     def setTabBarHidden(self, hide):
         '''void KTabWidget.setTabBarHidden(bool hide)'''
     def automaticResizeTabs(self):
         '''bool KTabWidget.automaticResizeTabs()'''
         return bool()
     def tabCloseActivatePrevious(self):
         '''bool KTabWidget.tabCloseActivatePrevious()'''
         return bool()
     def isCloseButtonEnabled(self):
         '''bool KTabWidget.isCloseButtonEnabled()'''
         return bool()
     def hoverCloseButtonDelayed(self):
         '''bool KTabWidget.hoverCloseButtonDelayed()'''
         return bool()
     def hoverCloseButton(self):
         '''bool KTabWidget.hoverCloseButton()'''
         return bool()
     def isTabReorderingEnabled(self):
         '''bool KTabWidget.isTabReorderingEnabled()'''
         return bool()
     def tabTextColor(self, index):
         '''QColor KTabWidget.tabTextColor(int index)'''
         return QColor()
     def setTabTextColor(self, index, color):
         '''void KTabWidget.setTabTextColor(int index, QColor color)'''
 
 
 class KTextBrowser(QTextBrowser):
     """"""
     def __init__(self, parent = None, notifyClick = False):
         '''void KTextBrowser.__init__(QWidget parent = None, bool notifyClick = False)'''
     urlClick = pyqtSignal() # void urlClick(const QStringamp;) - signal
     mailClick = pyqtSignal() # void mailClick(const QStringamp;,const QStringamp;) - signal
     def contextMenuEvent(self, event):
         '''void KTextBrowser.contextMenuEvent(QContextMenuEvent event)'''
     def wheelEvent(self, event):
         '''void KTextBrowser.wheelEvent(QWheelEvent event)'''
     def keyPressEvent(self, event):
         '''void KTextBrowser.keyPressEvent(QKeyEvent event)'''
     def setSource(self, name):
         '''void KTextBrowser.setSource(QUrl name)'''
     def isNotifyClick(self):
         '''bool KTextBrowser.isNotifyClick()'''
         return bool()
     def setNotifyClick(self, notifyClick):
         '''void KTextBrowser.setNotifyClick(bool notifyClick)'''
 
 
 class KTextEditSpellInterface():
     """"""
     def __init__(self):
         '''void KTextEditSpellInterface.__init__()'''
     def __init__(self):
         '''KTextEditSpellInterface KTextEditSpellInterface.__init__()'''
         return KTextEditSpellInterface()
     def shouldBlockBeSpellChecked(self, block):
         '''abstract bool KTextEditSpellInterface.shouldBlockBeSpellChecked(QString block)'''
         return bool()
     def setSpellCheckingEnabled(self, enable):
         '''abstract void KTextEditSpellInterface.setSpellCheckingEnabled(bool enable)'''
     def isSpellCheckingEnabled(self):
         '''abstract bool KTextEditSpellInterface.isSpellCheckingEnabled()'''
         return bool()
 
 
 class KTimeComboBox(KComboBox):
     """"""
     # Enum KTimeComboBox.Option
     EditTime = 0
     SelectTime = 0
     ForceTime = 0
     WarnOnInvalid = 0
 
     def __init__(self, parent = None):
         '''void KTimeComboBox.__init__(QWidget parent = None)'''
     def displayFormat(self):
         '''KLocale.TimeFormatOptions KTimeComboBox.displayFormat()'''
         return KLocale.TimeFormatOptions()
     def isNull(self):
         '''bool KTimeComboBox.isNull()'''
         return bool()
     def setTimeList(self, timeList, minWarnMsg = QString(), maxWarnMsg = QString()):
         '''void KTimeComboBox.setTimeList(list-of-QTime timeList, QString minWarnMsg = QString(), QString maxWarnMsg = QString())'''
     def setTimeListInterval(self, minutes):
         '''void KTimeComboBox.setTimeListInterval(int minutes)'''
     def setMaximumTime(self, maxTime, maxWarnMsg = QString()):
         '''void KTimeComboBox.setMaximumTime(QTime maxTime, QString maxWarnMsg = QString())'''
     def setMinimumTime(self, minTime, minWarnMsg = QString()):
         '''void KTimeComboBox.setMinimumTime(QTime minTime, QString minWarnMsg = QString())'''
     def timeList(self):
         '''list-of-QTime KTimeComboBox.timeList()'''
         return [QTime()]
     def timeListInterval(self):
         '''int KTimeComboBox.timeListInterval()'''
         return int()
     def assignTime(self, time):
         '''void KTimeComboBox.assignTime(QTime time)'''
     def resizeEvent(self, event):
         '''void KTimeComboBox.resizeEvent(QResizeEvent event)'''
     def focusOutEvent(self, event):
         '''void KTimeComboBox.focusOutEvent(QFocusEvent event)'''
     def focusInEvent(self, event):
         '''void KTimeComboBox.focusInEvent(QFocusEvent event)'''
     def keyPressEvent(self, event):
         '''void KTimeComboBox.keyPressEvent(QKeyEvent event)'''
     def wheelEvent(self, event):
         '''void KTimeComboBox.wheelEvent(QWheelEvent event)'''
     def mousePressEvent(self, event):
         '''void KTimeComboBox.mousePressEvent(QMouseEvent event)'''
     def hidePopup(self):
         '''void KTimeComboBox.hidePopup()'''
     def showPopup(self):
         '''void KTimeComboBox.showPopup()'''
     def eventFilter(self, object, event):
         '''bool KTimeComboBox.eventFilter(QObject object, QEvent event)'''
         return bool()
     def setDisplayFormat(self, formatOptions):
         '''void KTimeComboBox.setDisplayFormat(KLocale.TimeFormatOptions formatOptions)'''
     def setOptions(self, options):
         '''void KTimeComboBox.setOptions(KTimeComboBox.Options options)'''
     def setTime(self, time):
         '''void KTimeComboBox.setTime(QTime time)'''
     timeEdited = pyqtSignal() # void timeEdited(const QTimeamp;) - signal
     timeChanged = pyqtSignal() # void timeChanged(const QTimeamp;) - signal
     timeEntered = pyqtSignal() # void timeEntered(const QTimeamp;) - signal
     def resetTimeRange(self):
         '''void KTimeComboBox.resetTimeRange()'''
     def setTimeRange(self, minTime, maxTime, minWarnMsg = QString(), maxWarnMsg = QString()):
         '''void KTimeComboBox.setTimeRange(QTime minTime, QTime maxTime, QString minWarnMsg = QString(), QString maxWarnMsg = QString())'''
     def resetMaximumTime(self):
         '''void KTimeComboBox.resetMaximumTime()'''
     def maximumTime(self):
         '''QTime KTimeComboBox.maximumTime()'''
         return QTime()
     def resetMinimumTime(self):
         '''void KTimeComboBox.resetMinimumTime()'''
     def minimumTime(self):
         '''QTime KTimeComboBox.minimumTime()'''
         return QTime()
     def options(self):
         '''KTimeComboBox.Options KTimeComboBox.options()'''
         return KTimeComboBox.Options()
     def isValid(self):
         '''bool KTimeComboBox.isValid()'''
         return bool()
     def time(self):
         '''QTime KTimeComboBox.time()'''
         return QTime()
     class Options():
         """"""
         def __init__(self):
             '''KTimeComboBox.Options KTimeComboBox.Options.__init__()'''
             return KTimeComboBox.Options()
         def __init__(self):
             '''int KTimeComboBox.Options.__init__()'''
             return int()
         def __init__(self):
             '''void KTimeComboBox.Options.__init__()'''
         def __bool__(self):
             '''int KTimeComboBox.Options.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KTimeComboBox.Options.__ne__(KTimeComboBox.Options f)'''
             return bool()
         def __eq__(self, f):
             '''bool KTimeComboBox.Options.__eq__(KTimeComboBox.Options f)'''
             return bool()
         def __invert__(self):
             '''KTimeComboBox.Options KTimeComboBox.Options.__invert__()'''
             return KTimeComboBox.Options()
         def __and__(self, mask):
             '''KTimeComboBox.Options KTimeComboBox.Options.__and__(int mask)'''
             return KTimeComboBox.Options()
         def __xor__(self, f):
             '''KTimeComboBox.Options KTimeComboBox.Options.__xor__(KTimeComboBox.Options f)'''
             return KTimeComboBox.Options()
         def __xor__(self, f):
             '''KTimeComboBox.Options KTimeComboBox.Options.__xor__(int f)'''
             return KTimeComboBox.Options()
         def __or__(self, f):
             '''KTimeComboBox.Options KTimeComboBox.Options.__or__(KTimeComboBox.Options f)'''
             return KTimeComboBox.Options()
         def __or__(self, f):
             '''KTimeComboBox.Options KTimeComboBox.Options.__or__(int f)'''
             return KTimeComboBox.Options()
         def __int__(self):
             '''int KTimeComboBox.Options.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KTimeComboBox.Options KTimeComboBox.Options.__ixor__(KTimeComboBox.Options f)'''
             return KTimeComboBox.Options()
         def __ior__(self, f):
             '''KTimeComboBox.Options KTimeComboBox.Options.__ior__(KTimeComboBox.Options f)'''
             return KTimeComboBox.Options()
         def __iand__(self, mask):
             '''KTimeComboBox.Options KTimeComboBox.Options.__iand__(int mask)'''
             return KTimeComboBox.Options()
 
 
 class KTimeZoneWidget(QTreeWidget):
     """"""
     def __init__(self, parent = None, timeZones = None):
         '''void KTimeZoneWidget.__init__(QWidget parent = None, KTimeZones timeZones = None)'''
     def clearSelection(self):
         '''void KTimeZoneWidget.clearSelection()'''
     def selectionMode(self):
         '''QAbstractItemView.SelectionMode KTimeZoneWidget.selectionMode()'''
         return QAbstractItemView.SelectionMode()
     def setSelectionMode(self, mode):
         '''void KTimeZoneWidget.setSelectionMode(QAbstractItemView.SelectionMode mode)'''
     def itemsCheckable(self):
         '''bool KTimeZoneWidget.itemsCheckable()'''
         return bool()
     def setItemsCheckable(self, enable):
         '''void KTimeZoneWidget.setItemsCheckable(bool enable)'''
     def displayName(self, zone):
         '''static QString KTimeZoneWidget.displayName(KTimeZone zone)'''
         return QString()
     def setSelected(self, zone, selected):
         '''void KTimeZoneWidget.setSelected(QString zone, bool selected)'''
     def selection(self):
         '''QStringList KTimeZoneWidget.selection()'''
         return QStringList()
 
 
 class KTipDatabase():
     """"""
     def __init__(self, tipFile = QString()):
         '''void KTipDatabase.__init__(QString tipFile = QString())'''
     def __init__(self, tipFiles):
         '''void KTipDatabase.__init__(QStringList tipFiles)'''
     def prevTip(self):
         '''void KTipDatabase.prevTip()'''
     def nextTip(self):
         '''void KTipDatabase.nextTip()'''
     def tip(self):
         '''QString KTipDatabase.tip()'''
         return QString()
 
 
 class KTipDialog(KDialog):
     """"""
     def __init__(self, database, parent = None):
         '''void KTipDialog.__init__(KTipDatabase database, QWidget parent = None)'''
     def eventFilter(self):
         '''QEvent KTipDialog.eventFilter()'''
         return QEvent()
     def setShowOnStart(self, show):
         '''static void KTipDialog.setShowOnStart(bool show)'''
     def showMultiTip(self, parent, tipFiles, force = False):
         '''static void KTipDialog.showMultiTip(QWidget parent, QStringList tipFiles, bool force = False)'''
     def showTip(self, parent, tipFile = QString(), force = False):
         '''static void KTipDialog.showTip(QWidget parent, QString tipFile = QString(), bool force = False)'''
     def showTip(self, tipFile = QString(), force = False):
         '''static void KTipDialog.showTip(QString tipFile = QString(), bool force = False)'''
 
 
 class KTitleWidget(QWidget):
     """"""
     # Enum KTitleWidget.MessageType
     PlainMessage = 0
     InfoMessage = 0
     WarningMessage = 0
     ErrorMessage = 0
 
     # Enum KTitleWidget.ImageAlignment
     ImageLeft = 0
     ImageRight = 0
 
     def __init__(self, parent = None):
         '''void KTitleWidget.__init__(QWidget parent = None)'''
     def eventFilter(self, object, event):
         '''bool KTitleWidget.eventFilter(QObject object, QEvent event)'''
         return bool()
     def showEvent(self, event):
         '''void KTitleWidget.showEvent(QShowEvent event)'''
     def changeEvent(self, e):
         '''void KTitleWidget.changeEvent(QEvent e)'''
     def setAutoHideTimeout(self, msecs):
         '''void KTitleWidget.setAutoHideTimeout(int msecs)'''
     def setPixmap(self, pixmap, alignment = None):
         '''void KTitleWidget.setPixmap(QPixmap pixmap, KTitleWidget.ImageAlignment alignment = KTitleWidget.ImageRight)'''
     def setPixmap(self, icon, alignment = None):
         '''void KTitleWidget.setPixmap(QString icon, KTitleWidget.ImageAlignment alignment = KTitleWidget.ImageRight)'''
     def setPixmap(self, icon, alignment = None):
         '''void KTitleWidget.setPixmap(QIcon icon, KTitleWidget.ImageAlignment alignment = KTitleWidget.ImageRight)'''
     def setPixmap(self, type, alignment = None):
         '''void KTitleWidget.setPixmap(KTitleWidget.MessageType type, KTitleWidget.ImageAlignment alignment = KTitleWidget.ImageRight)'''
     def setComment(self, comment, type = None):
         '''void KTitleWidget.setComment(QString comment, KTitleWidget.MessageType type = KTitleWidget.PlainMessage)'''
     def setText(self, text, alignment = None):
         '''void KTitleWidget.setText(QString text, Qt.Alignment alignment = Qt.AlignLeft|Qt.AlignVCenter)'''
     def setText(self, text, type):
         '''void KTitleWidget.setText(QString text, KTitleWidget.MessageType type)'''
     def autoHideTimeout(self):
         '''int KTitleWidget.autoHideTimeout()'''
         return int()
     def setBuddy(self, buddy):
         '''void KTitleWidget.setBuddy(QWidget buddy)'''
     def pixmap(self):
         '''QPixmap KTitleWidget.pixmap()'''
         return QPixmap()
     def comment(self):
         '''QString KTitleWidget.comment()'''
         return QString()
     def text(self):
         '''QString KTitleWidget.text()'''
         return QString()
     def setWidget(self, widget):
         '''void KTitleWidget.setWidget(QWidget widget)'''
 
 
 class KToggleAction(KAction):
     """"""
     def __init__(self, parent):
         '''void KToggleAction.__init__(QObject parent)'''
     def __init__(self, text, parent):
         '''void KToggleAction.__init__(QString text, QObject parent)'''
     def __init__(self, icon, text, parent):
         '''void KToggleAction.__init__(KIcon icon, QString text, QObject parent)'''
     def slotToggled(self, checked):
         '''void KToggleAction.slotToggled(bool checked)'''
     def setCheckedState(self, checkedItem):
         '''void KToggleAction.setCheckedState(KGuiItem checkedItem)'''
 
 
 class KToggleFullScreenAction(KToggleAction):
     """"""
     def __init__(self, parent):
         '''void KToggleFullScreenAction.__init__(QObject parent)'''
     def __init__(self, window, parent):
         '''void KToggleFullScreenAction.__init__(QWidget window, QObject parent)'''
     def eventFilter(self, object, event):
         '''bool KToggleFullScreenAction.eventFilter(QObject object, QEvent event)'''
         return bool()
     def setFullScreen(self, window, set):
         '''static void KToggleFullScreenAction.setFullScreen(QWidget window, bool set)'''
     def setWindow(self, window):
         '''void KToggleFullScreenAction.setWindow(QWidget window)'''
 
 
 class KToggleToolBarAction(KToggleAction):
     """"""
     def __init__(self, toolBarName, text, parent):
         '''void KToggleToolBarAction.__init__(str toolBarName, QString text, QObject parent)'''
     def __init__(self, toolBar, text, parent):
         '''void KToggleToolBarAction.__init__(KToolBar toolBar, QString text, QObject parent)'''
     def eventFilter(self, watched, event):
         '''bool KToggleToolBarAction.eventFilter(QObject watched, QEvent event)'''
         return bool()
     def toolBar(self):
         '''KToolBar KToggleToolBarAction.toolBar()'''
         return KToolBar()
 
 
 class KToolBar(QToolBar):
     """"""
     def __init__(self, parent, isMainToolBar = False, readConfig = True):
         '''void KToolBar.__init__(QWidget parent, bool isMainToolBar = False, bool readConfig = True)'''
     def __init__(self, objectName, parentWindow, area, newLine = False, isMainToolBar = False, readConfig = True):
         '''void KToolBar.__init__(QString objectName, QMainWindow parentWindow, Qt.ToolBarArea area, bool newLine = False, bool isMainToolBar = False, bool readConfig = True)'''
     def __init__(self, objectName, parent, readConfig = True):
         '''void KToolBar.__init__(QString objectName, QWidget parent, bool readConfig = True)'''
     def addXMLGUIClient(self, client):
         '''void KToolBar.addXMLGUIClient(KXMLGUIClient client)'''
     def mouseReleaseEvent(self):
         '''QMouseEvent KToolBar.mouseReleaseEvent()'''
         return QMouseEvent()
     def mouseMoveEvent(self):
         '''QMouseEvent KToolBar.mouseMoveEvent()'''
         return QMouseEvent()
     def mousePressEvent(self):
         '''QMouseEvent KToolBar.mousePressEvent()'''
         return QMouseEvent()
     def dropEvent(self):
         '''QDropEvent KToolBar.dropEvent()'''
         return QDropEvent()
     def dragLeaveEvent(self):
         '''QDragLeaveEvent KToolBar.dragLeaveEvent()'''
         return QDragLeaveEvent()
     def dragMoveEvent(self):
         '''QDragMoveEvent KToolBar.dragMoveEvent()'''
         return QDragMoveEvent()
     def dragEnterEvent(self):
         '''QDragEnterEvent KToolBar.dragEnterEvent()'''
         return QDragEnterEvent()
     def actionEvent(self):
         '''QActionEvent KToolBar.actionEvent()'''
         return QActionEvent()
     def contextMenuEvent(self):
         '''QContextMenuEvent KToolBar.contextMenuEvent()'''
         return QContextMenuEvent()
     def slotMovableChanged(self, movable):
         '''void KToolBar.slotMovableChanged(bool movable)'''
     def setToolBarsLocked(self, locked):
         '''static void KToolBar.setToolBarsLocked(bool locked)'''
     def toolBarsLocked(self):
         '''static bool KToolBar.toolBarsLocked()'''
         return bool()
     def setToolBarsEditable(self, editable):
         '''static void KToolBar.setToolBarsEditable(bool editable)'''
     def toolBarsEditable(self):
         '''static bool KToolBar.toolBarsEditable()'''
         return bool()
     def toolButtonStyleSetting(self):
         '''static Qt.ToolButtonStyle KToolBar.toolButtonStyleSetting()'''
         return Qt.ToolButtonStyle()
     def eventFilter(self, watched, event):
         '''bool KToolBar.eventFilter(QObject watched, QEvent event)'''
         return bool()
     def saveState(self, element):
         '''void KToolBar.saveState(QDomElement element)'''
     def loadState(self, element):
         '''void KToolBar.loadState(QDomElement element)'''
     def setXMLGUIClient(self, client):
         '''void KToolBar.setXMLGUIClient(KXMLGUIClient client)'''
     def applySettings(self, cg, forceGlobal = False):
         '''void KToolBar.applySettings(KConfigGroup cg, bool forceGlobal = False)'''
     def saveSettings(self, cg):
         '''void KToolBar.saveSettings(KConfigGroup cg)'''
     def contextMenuEnabled(self):
         '''bool KToolBar.contextMenuEnabled()'''
         return bool()
     def setContextMenuEnabled(self, enable = True):
         '''void KToolBar.setContextMenuEnabled(bool enable = True)'''
     def iconSizeDefault(self):
         '''int KToolBar.iconSizeDefault()'''
         return int()
     def setIconDimensions(self, size):
         '''void KToolBar.setIconDimensions(int size)'''
     def mainWindow(self):
         '''KMainWindow KToolBar.mainWindow()'''
         return KMainWindow()
 
 
 class KToolBarLabelAction(KAction):
     """"""
     def __init__(self, text, parent):
         '''void KToolBarLabelAction.__init__(QString text, QObject parent)'''
     def __init__(self, buddy, text, parent):
         '''void KToolBarLabelAction.__init__(QAction buddy, QString text, QObject parent)'''
     def eventFilter(self, watched, event):
         '''bool KToolBarLabelAction.eventFilter(QObject watched, QEvent event)'''
         return bool()
     def event(self):
         '''QEvent KToolBarLabelAction.event()'''
         return QEvent()
     textChanged = pyqtSignal() # void textChanged(const QStringamp;) - signal
     def createWidget(self, parent):
         '''QWidget KToolBarLabelAction.createWidget(QWidget parent)'''
         return QWidget()
     def buddy(self):
         '''QAction KToolBarLabelAction.buddy()'''
         return QAction()
     def setBuddy(self, buddy):
         '''void KToolBarLabelAction.setBuddy(QAction buddy)'''
 
 
 class KToolBarPopupAction(KAction):
     """"""
     def __init__(self, icon, text, parent):
         '''void KToolBarPopupAction.__init__(KIcon icon, QString text, QObject parent)'''
     def createWidget(self, parent):
         '''QWidget KToolBarPopupAction.createWidget(QWidget parent)'''
         return QWidget()
     def setStickyMenu(self, sticky):
         '''void KToolBarPopupAction.setStickyMenu(bool sticky)'''
     def stickyMenu(self):
         '''bool KToolBarPopupAction.stickyMenu()'''
         return bool()
     def setDelayed(self, delayed):
         '''void KToolBarPopupAction.setDelayed(bool delayed)'''
     def delayed(self):
         '''bool KToolBarPopupAction.delayed()'''
         return bool()
     def popupMenu(self):
         '''KMenu KToolBarPopupAction.popupMenu()'''
         return KMenu()
 
 
 class KToolBarSpacerAction(KAction):
     """"""
     def __init__(self, parent):
         '''void KToolBarSpacerAction.__init__(QObject parent)'''
     def deleteWidget(self, widget):
         '''void KToolBarSpacerAction.deleteWidget(QWidget widget)'''
     def createWidget(self, parent):
         '''QWidget KToolBarSpacerAction.createWidget(QWidget parent)'''
         return QWidget()
     def setMaximumWidth(self, width):
         '''void KToolBarSpacerAction.setMaximumWidth(int width)'''
     def maximumWidth(self):
         '''int KToolBarSpacerAction.maximumWidth()'''
         return int()
     def setMinimumWidth(self, width):
         '''void KToolBarSpacerAction.setMinimumWidth(int width)'''
     def minimumWidth(self):
         '''int KToolBarSpacerAction.minimumWidth()'''
         return int()
     def setWidth(self, width):
         '''void KToolBarSpacerAction.setWidth(int width)'''
     def width(self):
         '''int KToolBarSpacerAction.width()'''
         return int()
 
 
 class KTreeWidgetSearchLine(KLineEdit):
     """"""
     def __init__(self, parent = None, treeWidget = None):
         '''void KTreeWidgetSearchLine.__init__(QWidget parent = None, QTreeWidget treeWidget = None)'''
     def __init__(self, parent, treeWidgets):
         '''void KTreeWidgetSearchLine.__init__(QWidget parent, list-of-QTreeWidget treeWidgets)'''
     def event(self, event):
         '''bool KTreeWidgetSearchLine.event(QEvent event)'''
         return bool()
     def canChooseColumnsCheck(self):
         '''bool KTreeWidgetSearchLine.canChooseColumnsCheck()'''
         return bool()
     def disconnectTreeWidget(self):
         '''QTreeWidget KTreeWidgetSearchLine.disconnectTreeWidget()'''
         return QTreeWidget()
     def connectTreeWidget(self):
         '''QTreeWidget KTreeWidgetSearchLine.connectTreeWidget()'''
         return QTreeWidget()
     def contextMenuEvent(self):
         '''QContextMenuEvent KTreeWidgetSearchLine.contextMenuEvent()'''
         return QContextMenuEvent()
     def itemMatches(self, item, pattern):
         '''bool KTreeWidgetSearchLine.itemMatches(QTreeWidgetItem item, QString pattern)'''
         return bool()
     def setTreeWidgets(self, treeWidgets):
         '''void KTreeWidgetSearchLine.setTreeWidgets(list-of-QTreeWidget treeWidgets)'''
     def setTreeWidget(self, treeWidget):
         '''void KTreeWidgetSearchLine.setTreeWidget(QTreeWidget treeWidget)'''
     def setSearchColumns(self, columns):
         '''void KTreeWidgetSearchLine.setSearchColumns(list-of-int columns)'''
     def setKeepParentsVisible(self, value):
         '''void KTreeWidgetSearchLine.setKeepParentsVisible(bool value)'''
     def setCaseSensitivity(self, caseSensitivity):
         '''void KTreeWidgetSearchLine.setCaseSensitivity(Qt.CaseSensitivity caseSensitivity)'''
     def updateSearch(self, pattern = QString()):
         '''void KTreeWidgetSearchLine.updateSearch(QString pattern = QString())'''
     def updateSearch(self, treeWidget):
         '''void KTreeWidgetSearchLine.updateSearch(QTreeWidget treeWidget)'''
     def removeTreeWidget(self, treeWidget):
         '''void KTreeWidgetSearchLine.removeTreeWidget(QTreeWidget treeWidget)'''
     def addTreeWidget(self, treeWidget):
         '''void KTreeWidgetSearchLine.addTreeWidget(QTreeWidget treeWidget)'''
     hiddenChanged = pyqtSignal() # void hiddenChanged(QTreeWidgetItem *,bool) - signal
     def treeWidgets(self):
         '''list-of-QTreeWidget KTreeWidgetSearchLine.treeWidgets()'''
         return [QTreeWidget()]
     def treeWidget(self):
         '''QTreeWidget KTreeWidgetSearchLine.treeWidget()'''
         return QTreeWidget()
     def keepParentsVisible(self):
         '''bool KTreeWidgetSearchLine.keepParentsVisible()'''
         return bool()
     def searchColumns(self):
         '''list-of-int KTreeWidgetSearchLine.searchColumns()'''
         return [int()]
     def caseSensitivity(self):
         '''Qt.CaseSensitivity KTreeWidgetSearchLine.caseSensitivity()'''
         return Qt.CaseSensitivity()
 
 
 class KTreeWidgetSearchLineWidget(QWidget):
     """"""
     def __init__(self, parent = None, treeWidget = None):
         '''void KTreeWidgetSearchLineWidget.__init__(QWidget parent = None, QTreeWidget treeWidget = None)'''
     def createSearchLine(self, treeWidget):
         '''KTreeWidgetSearchLine KTreeWidgetSearchLineWidget.createSearchLine(QTreeWidget treeWidget)'''
         return KTreeWidgetSearchLine()
     def createWidgets(self):
         '''void KTreeWidgetSearchLineWidget.createWidgets()'''
     def searchLine(self):
         '''KTreeWidgetSearchLine KTreeWidgetSearchLineWidget.searchLine()'''
         return KTreeWidgetSearchLine()
 
 
 class KUiServerJobTracker(KJobTrackerInterface):
     """"""
     def __init__(self, parent = None):
         '''void KUiServerJobTracker.__init__(QObject parent = None)'''
     def speed(self, job, value):
         '''void KUiServerJobTracker.speed(KJob job, int value)'''
     def percent(self, job, percent):
         '''void KUiServerJobTracker.percent(KJob job, int percent)'''
     def processedAmount(self, job, unit, amount):
         '''void KUiServerJobTracker.processedAmount(KJob job, KJob.Unit unit, int amount)'''
     def totalAmount(self, job, unit, amount):
         '''void KUiServerJobTracker.totalAmount(KJob job, KJob.Unit unit, int amount)'''
     def infoMessage(self, job, plain, rich):
         '''void KUiServerJobTracker.infoMessage(KJob job, QString plain, QString rich)'''
     def description(self, job, title, field1, field2):
         '''void KUiServerJobTracker.description(KJob job, QString title, unknown-type field1, unknown-type field2)'''
     def resumed(self, job):
         '''void KUiServerJobTracker.resumed(KJob job)'''
     def suspended(self, job):
         '''void KUiServerJobTracker.suspended(KJob job)'''
     def finished(self, job):
         '''void KUiServerJobTracker.finished(KJob job)'''
     def unregisterJob(self, job):
         '''void KUiServerJobTracker.unregisterJob(KJob job)'''
     def registerJob(self, job):
         '''void KUiServerJobTracker.registerJob(KJob job)'''
 
 
 class KUndoStack(QUndoStack):
     """"""
     def __init__(self, parent = None):
         '''void KUndoStack.__init__(QObject parent = None)'''
     def createUndoAction(self, actionCollection, actionName = QString()):
         '''QAction KUndoStack.createUndoAction(KActionCollection actionCollection, QString actionName = QString())'''
         return QAction()
     def createRedoAction(self, actionCollection, actionName = QString()):
         '''QAction KUndoStack.createRedoAction(KActionCollection actionCollection, QString actionName = QString())'''
         return QAction()
 
 
 class KUniqueApplication(KApplication):
     """"""
     # Enum KUniqueApplication.StartFlag
     NonUniqueInstance = 0
 
     def __init__(self, GUIenabled = True, configUnique = False):
         '''void KUniqueApplication.__init__(bool GUIenabled = True, bool configUnique = False)'''
     def __init__(self, display, visual = 0, colormap = 0, configUnique = False):
         '''void KUniqueApplication.__init__(Display display, int visual = 0, int colormap = 0, bool configUnique = False)'''
     def setHandleAutoStarted(self):
         '''static void KUniqueApplication.setHandleAutoStarted()'''
     def restoringSession(self):
         '''bool KUniqueApplication.restoringSession()'''
         return bool()
     def newInstance(self):
         '''int KUniqueApplication.newInstance()'''
         return int()
     def start(self, flags):
         '''static bool KUniqueApplication.start(KUniqueApplication.StartFlags flags)'''
         return bool()
     def start(self):
         '''static bool KUniqueApplication.start()'''
         return bool()
     def addCmdLineOptions(self):
         '''static void KUniqueApplication.addCmdLineOptions()'''
     class StartFlags():
         """"""
         def __init__(self):
             '''KUniqueApplication.StartFlags KUniqueApplication.StartFlags.__init__()'''
             return KUniqueApplication.StartFlags()
         def __init__(self):
             '''int KUniqueApplication.StartFlags.__init__()'''
             return int()
         def __init__(self):
             '''void KUniqueApplication.StartFlags.__init__()'''
         def __bool__(self):
             '''int KUniqueApplication.StartFlags.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KUniqueApplication.StartFlags.__ne__(KUniqueApplication.StartFlags f)'''
             return bool()
         def __eq__(self, f):
             '''bool KUniqueApplication.StartFlags.__eq__(KUniqueApplication.StartFlags f)'''
             return bool()
         def __invert__(self):
             '''KUniqueApplication.StartFlags KUniqueApplication.StartFlags.__invert__()'''
             return KUniqueApplication.StartFlags()
         def __and__(self, mask):
             '''KUniqueApplication.StartFlags KUniqueApplication.StartFlags.__and__(int mask)'''
             return KUniqueApplication.StartFlags()
         def __xor__(self, f):
             '''KUniqueApplication.StartFlags KUniqueApplication.StartFlags.__xor__(KUniqueApplication.StartFlags f)'''
             return KUniqueApplication.StartFlags()
         def __xor__(self, f):
             '''KUniqueApplication.StartFlags KUniqueApplication.StartFlags.__xor__(int f)'''
             return KUniqueApplication.StartFlags()
         def __or__(self, f):
             '''KUniqueApplication.StartFlags KUniqueApplication.StartFlags.__or__(KUniqueApplication.StartFlags f)'''
             return KUniqueApplication.StartFlags()
         def __or__(self, f):
             '''KUniqueApplication.StartFlags KUniqueApplication.StartFlags.__or__(int f)'''
             return KUniqueApplication.StartFlags()
         def __int__(self):
             '''int KUniqueApplication.StartFlags.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KUniqueApplication.StartFlags KUniqueApplication.StartFlags.__ixor__(KUniqueApplication.StartFlags f)'''
             return KUniqueApplication.StartFlags()
         def __ior__(self, f):
             '''KUniqueApplication.StartFlags KUniqueApplication.StartFlags.__ior__(KUniqueApplication.StartFlags f)'''
             return KUniqueApplication.StartFlags()
         def __iand__(self, mask):
             '''KUniqueApplication.StartFlags KUniqueApplication.StartFlags.__iand__(int mask)'''
             return KUniqueApplication.StartFlags()
 
 
 class KUrlLabel(QLabel):
     """"""
     def __init__(self, parent = None):
         '''void KUrlLabel.__init__(QWidget parent = None)'''
     def __init__(self, url, text = QString(), parent = None):
         '''void KUrlLabel.__init__(QString url, QString text = QString(), QWidget parent = None)'''
     def event(self):
         '''QEvent KUrlLabel.event()'''
         return QEvent()
     def leaveEvent(self):
         '''QEvent KUrlLabel.leaveEvent()'''
         return QEvent()
     def enterEvent(self):
         '''QEvent KUrlLabel.enterEvent()'''
         return QEvent()
     def mouseReleaseEvent(self):
         '''QMouseEvent KUrlLabel.mouseReleaseEvent()'''
         return QMouseEvent()
     middleClickedUrl = pyqtSignal() # void middleClickedUrl(const QStringamp;) - signal
     middleClickedUrl = pyqtSignal() # void middleClickedUrl() - signal
     rightClickedUrl = pyqtSignal() # void rightClickedUrl(const QStringamp;) - signal
     rightClickedUrl = pyqtSignal() # void rightClickedUrl() - signal
     leftClickedUrl = pyqtSignal() # void leftClickedUrl(const QStringamp;) - signal
     leftClickedUrl = pyqtSignal() # void leftClickedUrl() - signal
     leftUrl = pyqtSignal() # void leftUrl(const QStringamp;) - signal
     leftUrl = pyqtSignal() # void leftUrl() - signal
     enteredUrl = pyqtSignal() # void enteredUrl(const QStringamp;) - signal
     enteredUrl = pyqtSignal() # void enteredUrl() - signal
     def setAlternatePixmap(self, pixmap):
         '''void KUrlLabel.setAlternatePixmap(QPixmap pixmap)'''
     def setFloatEnabled(self, do_float = True):
         '''void KUrlLabel.setFloatEnabled(bool do_float = True)'''
     def setGlowEnabled(self, glow = True):
         '''void KUrlLabel.setGlowEnabled(bool glow = True)'''
     def setUseCursor(self, on, cursor = None):
         '''void KUrlLabel.setUseCursor(bool on, QCursor cursor = None)'''
     def setSelectedColor(self, color):
         '''void KUrlLabel.setSelectedColor(QColor color)'''
     def setSelectedColor(self, color):
         '''void KUrlLabel.setSelectedColor(QString color)'''
     def setHighlightedColor(self, highcolor):
         '''void KUrlLabel.setHighlightedColor(QColor highcolor)'''
     def setHighlightedColor(self, highcolor):
         '''void KUrlLabel.setHighlightedColor(QString highcolor)'''
     def setTipText(self, tip):
         '''void KUrlLabel.setTipText(QString tip)'''
     def setUseTips(self, on = True):
         '''void KUrlLabel.setUseTips(bool on = True)'''
     def setFont(self, font):
         '''void KUrlLabel.setFont(QFont font)'''
     def setUrl(self, url):
         '''void KUrlLabel.setUrl(QString url)'''
     def setUnderline(self, on = True):
         '''void KUrlLabel.setUnderline(bool on = True)'''
     def alternatePixmap(self):
         '''QPixmap KUrlLabel.alternatePixmap()'''
         return QPixmap()
     def isFloatEnabled(self):
         '''bool KUrlLabel.isFloatEnabled()'''
         return bool()
     def isGlowEnabled(self):
         '''bool KUrlLabel.isGlowEnabled()'''
         return bool()
     def useCursor(self):
         '''bool KUrlLabel.useCursor()'''
         return bool()
     def useTips(self):
         '''bool KUrlLabel.useTips()'''
         return bool()
     def tipText(self):
         '''QString KUrlLabel.tipText()'''
         return QString()
     def url(self):
         '''QString KUrlLabel.url()'''
         return QString()
 
 
 class KVBox(KHBox):
     """"""
     def __init__(self, parent = None):
         '''void KVBox.__init__(QWidget parent = None)'''
 
 
 class KViewStateMaintainerBase(QObject):
     """"""
     def __init__(self, configGroup, parent = None):
         '''void KViewStateMaintainerBase.__init__(KConfigGroup configGroup, QObject parent = None)'''
     def configGroup(self):
         '''KConfigGroup KViewStateMaintainerBase.configGroup()'''
         return KConfigGroup()
     def restoreState(self):
         '''abstract void KViewStateMaintainerBase.restoreState()'''
     def saveState(self):
         '''abstract void KViewStateMaintainerBase.saveState()'''
     def view(self):
         '''QAbstractItemView KViewStateMaintainerBase.view()'''
         return QAbstractItemView()
     def setView(self, view):
         '''void KViewStateMaintainerBase.setView(QAbstractItemView view)'''
     def selectionModel(self):
         '''QItemSelectionModel KViewStateMaintainerBase.selectionModel()'''
         return QItemSelectionModel()
     def setSelectionModel(self, selectionModel):
         '''void KViewStateMaintainerBase.setSelectionModel(QItemSelectionModel selectionModel)'''
 
 
 class KViewStateSaver(QObject):
     """"""
     def __init__(self, parent = None):
         '''void KViewStateSaver.__init__(QObject parent = None)'''
     def indexToConfigString(self, index):
         '''abstract QString KViewStateSaver.indexToConfigString(QModelIndex index)'''
         return QString()
     def indexFromConfigString(self, model, key):
         '''abstract QModelIndex KViewStateSaver.indexFromConfigString(QAbstractItemModel model, QString key)'''
         return QModelIndex()
     def restoreScrollState(self, verticalScoll, horizontalScroll):
         '''void KViewStateSaver.restoreScrollState(int verticalScoll, int horizontalScroll)'''
     def restoreExpanded(self, indexStrings):
         '''void KViewStateSaver.restoreExpanded(QStringList indexStrings)'''
     def restoreCurrentItem(self, indexString):
         '''void KViewStateSaver.restoreCurrentItem(QString indexString)'''
     def restoreSelection(self, indexStrings):
         '''void KViewStateSaver.restoreSelection(QStringList indexStrings)'''
     def scrollState(self):
         '''tuple-of-int-int KViewStateSaver.scrollState()'''
         return tuple-of-int-int()
     def currentIndexKey(self):
         '''QString KViewStateSaver.currentIndexKey()'''
         return QString()
     def expansionKeys(self):
         '''QStringList KViewStateSaver.expansionKeys()'''
         return QStringList()
     def selectionKeys(self):
         '''QStringList KViewStateSaver.selectionKeys()'''
         return QStringList()
     def restoreState(self, configGroup):
         '''void KViewStateSaver.restoreState(KConfigGroup configGroup)'''
     def saveState(self, configGroup):
         '''void KViewStateSaver.saveState(KConfigGroup configGroup)'''
     def setSelectionModel(self, selectionModel):
         '''void KViewStateSaver.setSelectionModel(QItemSelectionModel selectionModel)'''
     def selectionModel(self):
         '''QItemSelectionModel KViewStateSaver.selectionModel()'''
         return QItemSelectionModel()
     def setView(self, view):
         '''void KViewStateSaver.setView(QAbstractItemView view)'''
     def view(self):
         '''QAbstractItemView KViewStateSaver.view()'''
         return QAbstractItemView()
 
 
 class KWallet():
     """"""
     class Wallet(QObject):
         """"""
         # Enum KWallet.Wallet.OpenType
         Synchronous = 0
         Asynchronous = 0
         Path = 0
         OpenTypeUnused = 0
     
         # Enum KWallet.Wallet.EntryType
         Unknown = 0
         Password = 0
         Stream = 0
         Map = 0
         Unused = 0
     
         def __init__(self, handle, name):
             '''void KWallet.Wallet.__init__(int handle, QString name)'''
         def isUsingKSecretsService(self):
             '''static bool KWallet.Wallet.isUsingKSecretsService()'''
             return bool()
         walletOpened = pyqtSignal() # void walletOpened(bool) - signal
         folderRemoved = pyqtSignal() # void folderRemoved(const QStringamp;) - signal
         folderListUpdated = pyqtSignal() # void folderListUpdated() - signal
         folderUpdated = pyqtSignal() # void folderUpdated(const QStringamp;) - signal
         walletClosed = pyqtSignal() # void walletClosed() - signal
         def keyDoesNotExist(self, wallet, folder, key):
             '''static bool KWallet.Wallet.keyDoesNotExist(QString wallet, QString folder, QString key)'''
             return bool()
         def folderDoesNotExist(self, wallet, folder):
             '''static bool KWallet.Wallet.folderDoesNotExist(QString wallet, QString folder)'''
             return bool()
         def entryType(self, key):
             '''KWallet.Wallet.EntryType KWallet.Wallet.entryType(QString key)'''
             return KWallet.Wallet.EntryType()
         def removeEntry(self, key):
             '''int KWallet.Wallet.removeEntry(QString key)'''
             return int()
         def hasEntry(self, key):
             '''bool KWallet.Wallet.hasEntry(QString key)'''
             return bool()
         def writePassword(self, key, value):
             '''int KWallet.Wallet.writePassword(QString key, QString value)'''
             return int()
         def writeMap(self, key, value):
             '''int KWallet.Wallet.writeMap(QString key, dict-of-QString-QString value)'''
             return int()
         def writeEntry(self, key, value, entryType):
             '''int KWallet.Wallet.writeEntry(QString key, QByteArray value, KWallet.Wallet.EntryType entryType)'''
             return int()
         def writeEntry(self, key, value):
             '''int KWallet.Wallet.writeEntry(QString key, QByteArray value)'''
             return int()
         def readPasswordList(self, key, value):
             '''int KWallet.Wallet.readPasswordList(QString key, dict-of-QString-QString value)'''
             return int()
         def readEntryList(self, key, value):
             '''int KWallet.Wallet.readEntryList(QString key, dict-of-QString-QByteArray value)'''
             return int()
         def readPassword(self, key, value):
             '''int KWallet.Wallet.readPassword(QString key, QString value)'''
             return int()
         def readMap(self, key, value):
             '''int KWallet.Wallet.readMap(QString key, dict-of-QString-QString value)'''
             return int()
         def readEntry(self, key, value):
             '''int KWallet.Wallet.readEntry(QString key, QByteArray value)'''
             return int()
         def renameEntry(self, oldName, newName):
             '''int KWallet.Wallet.renameEntry(QString oldName, QString newName)'''
             return int()
         def entryList(self):
             '''QStringList KWallet.Wallet.entryList()'''
             return QStringList()
         def currentFolder(self):
             '''QString KWallet.Wallet.currentFolder()'''
             return QString()
         def createFolder(self, f):
             '''bool KWallet.Wallet.createFolder(QString f)'''
             return bool()
         def removeFolder(self, f):
             '''bool KWallet.Wallet.removeFolder(QString f)'''
             return bool()
         def setFolder(self, f):
             '''bool KWallet.Wallet.setFolder(QString f)'''
             return bool()
         def hasFolder(self, f):
             '''bool KWallet.Wallet.hasFolder(QString f)'''
             return bool()
         def folderList(self):
             '''QStringList KWallet.Wallet.folderList()'''
             return QStringList()
         def requestChangePassword(self, w):
             '''void KWallet.Wallet.requestChangePassword(int w)'''
         def walletName(self):
             '''QString KWallet.Wallet.walletName()'''
             return QString()
         def lockWallet(self):
             '''int KWallet.Wallet.lockWallet()'''
             return int()
         def sync(self):
             '''int KWallet.Wallet.sync()'''
             return int()
         def changePassword(self, name, w):
             '''static void KWallet.Wallet.changePassword(QString name, int w)'''
         def FormDataFolder(self):
             '''static QString KWallet.Wallet.FormDataFolder()'''
             return QString()
         def PasswordFolder(self):
             '''static QString KWallet.Wallet.PasswordFolder()'''
             return QString()
         def NetworkWallet(self):
             '''static QString KWallet.Wallet.NetworkWallet()'''
             return QString()
         def LocalWallet(self):
             '''static QString KWallet.Wallet.LocalWallet()'''
             return QString()
         def users(self, wallet):
             '''static QStringList KWallet.Wallet.users(QString wallet)'''
             return QStringList()
         def openWallet(self, name, w, ot = None):
             '''static KWallet.Wallet KWallet.Wallet.openWallet(QString name, int w, KWallet.Wallet.OpenType ot = KWallet.Wallet.Synchronous)'''
             return KWallet.Wallet()
         def disconnectApplication(self, wallet, app):
             '''static bool KWallet.Wallet.disconnectApplication(QString wallet, QString app)'''
             return bool()
         def deleteWallet(self, name):
             '''static int KWallet.Wallet.deleteWallet(QString name)'''
             return int()
         def closeWallet(self, name, force):
             '''static int KWallet.Wallet.closeWallet(QString name, bool force)'''
             return int()
         def isOpen(self, name):
             '''static bool KWallet.Wallet.isOpen(QString name)'''
             return bool()
         def isOpen(self):
             '''bool KWallet.Wallet.isOpen()'''
             return bool()
         def isEnabled(self):
             '''static bool KWallet.Wallet.isEnabled()'''
             return bool()
         def walletList(self):
             '''static QStringList KWallet.Wallet.walletList()'''
             return QStringList()
 
 
 class KWidgetItemDelegate(QAbstractItemDelegate):
     """"""
     def __init__(self, itemView, parent = None):
         '''void KWidgetItemDelegate.__init__(QAbstractItemView itemView, QObject parent = None)'''
     def blockedEventTypes(self, widget):
         '''unknown-type KWidgetItemDelegate.blockedEventTypes(QWidget widget)'''
         return unknown-type()
     def setBlockedEventTypes(self, widget, types):
         '''void KWidgetItemDelegate.setBlockedEventTypes(QWidget widget, unknown-type types)'''
     def paintWidgets(self, painter, option, index):
         '''void KWidgetItemDelegate.paintWidgets(QPainter painter, QStyleOptionViewItem option, QPersistentModelIndex index)'''
     def updateItemWidgets(self, widgets, option, index):
         '''abstract void KWidgetItemDelegate.updateItemWidgets(list-of-QWidget widgets, QStyleOptionViewItem option, QPersistentModelIndex index)'''
     def createItemWidgets(self):
         '''abstract list-of-QWidget KWidgetItemDelegate.createItemWidgets()'''
         return [QWidget()]
     def focusedIndex(self):
         '''QPersistentModelIndex KWidgetItemDelegate.focusedIndex()'''
         return QPersistentModelIndex()
     def itemView(self):
         '''QAbstractItemView KWidgetItemDelegate.itemView()'''
         return QAbstractItemView()
 
 
 class KWidgetJobTracker(KAbstractWidgetJobTracker):
     """"""
     def __init__(self, parent = None):
         '''void KWidgetJobTracker.__init__(QWidget parent = None)'''
     def resumed(self, job):
         '''void KWidgetJobTracker.resumed(KJob job)'''
     def suspended(self, job):
         '''void KWidgetJobTracker.suspended(KJob job)'''
     def slotClean(self, job):
         '''void KWidgetJobTracker.slotClean(KJob job)'''
     def speed(self, job, value):
         '''void KWidgetJobTracker.speed(KJob job, int value)'''
     def percent(self, job, percent):
         '''void KWidgetJobTracker.percent(KJob job, int percent)'''
     def processedAmount(self, job, unit, amount):
         '''void KWidgetJobTracker.processedAmount(KJob job, KJob.Unit unit, int amount)'''
     def totalAmount(self, job, unit, amount):
         '''void KWidgetJobTracker.totalAmount(KJob job, KJob.Unit unit, int amount)'''
     def description(self, job, title, field1, field2):
         '''void KWidgetJobTracker.description(KJob job, QString title, unknown-type field1, unknown-type field2)'''
     def infoMessage(self, job, plain, rich):
         '''void KWidgetJobTracker.infoMessage(KJob job, QString plain, QString rich)'''
     def keepOpen(self, job):
         '''bool KWidgetJobTracker.keepOpen(KJob job)'''
         return bool()
     def unregisterJob(self, job):
         '''void KWidgetJobTracker.unregisterJob(KJob job)'''
     def registerJob(self, job):
         '''void KWidgetJobTracker.registerJob(KJob job)'''
     def widget(self, job):
         '''QWidget KWidgetJobTracker.widget(KJob job)'''
         return QWidget()
 
 
 class KWindowInfo():
     """"""
     def __init__(self, window, properties, properties2 = 0):
         '''void KWindowInfo.__init__(int window, int properties, int properties2 = 0)'''
     def __init__(self):
         '''void KWindowInfo.__init__()'''
     def __init__(self):
         '''KWindowInfo KWindowInfo.__init__()'''
         return KWindowInfo()
     def actionSupported(self, action):
         '''bool KWindowInfo.actionSupported(NET.Action action)'''
         return bool()
     def clientMachine(self):
         '''QByteArray KWindowInfo.clientMachine()'''
         return QByteArray()
     def windowRole(self):
         '''QByteArray KWindowInfo.windowRole()'''
         return QByteArray()
     def windowClassName(self):
         '''QByteArray KWindowInfo.windowClassName()'''
         return QByteArray()
     def windowClassClass(self):
         '''QByteArray KWindowInfo.windowClassClass()'''
         return QByteArray()
     def groupLeader(self):
         '''int KWindowInfo.groupLeader()'''
         return int()
     def transientFor(self):
         '''int KWindowInfo.transientFor()'''
         return int()
     def frameGeometry(self):
         '''QRect KWindowInfo.frameGeometry()'''
         return QRect()
     def geometry(self):
         '''QRect KWindowInfo.geometry()'''
         return QRect()
     def desktop(self):
         '''int KWindowInfo.desktop()'''
         return int()
     def onAllDesktops(self):
         '''bool KWindowInfo.onAllDesktops()'''
         return bool()
     def isOnDesktop(self, desktop):
         '''bool KWindowInfo.isOnDesktop(int desktop)'''
         return bool()
     def isOnCurrentDesktop(self):
         '''bool KWindowInfo.isOnCurrentDesktop()'''
         return bool()
     def iconName(self):
         '''QString KWindowInfo.iconName()'''
         return QString()
     def visibleIconNameWithState(self):
         '''QString KWindowInfo.visibleIconNameWithState()'''
         return QString()
     def visibleIconName(self):
         '''QString KWindowInfo.visibleIconName()'''
         return QString()
     def name(self):
         '''QString KWindowInfo.name()'''
         return QString()
     def visibleNameWithState(self):
         '''QString KWindowInfo.visibleNameWithState()'''
         return QString()
     def visibleName(self):
         '''QString KWindowInfo.visibleName()'''
         return QString()
     def windowType(self, supported_types):
         '''NET.WindowType KWindowInfo.windowType(int supported_types)'''
         return NET.WindowType()
     def extendedStrut(self):
         '''NETExtendedStrut KWindowInfo.extendedStrut()'''
         return NETExtendedStrut()
     def mappingState(self):
         '''NET.MappingState KWindowInfo.mappingState()'''
         return NET.MappingState()
     def isMinimized(self):
         '''bool KWindowInfo.isMinimized()'''
         return bool()
     def hasState(self, s):
         '''bool KWindowInfo.hasState(int s)'''
         return bool()
     def state(self):
         '''int KWindowInfo.state()'''
         return int()
     def win(self):
         '''int KWindowInfo.win()'''
         return int()
     def valid(self, withdrawn_is_valid = False):
         '''bool KWindowInfo.valid(bool withdrawn_is_valid = False)'''
         return bool()
 
 
 class NET():
     """"""
     # Enum NET.DesktopLayoutCorner
     DesktopLayoutCornerTopLeft = 0
     DesktopLayoutCornerTopRight = 0
     DesktopLayoutCornerBottomLeft = 0
     DesktopLayoutCornerBottomRight = 0
 
     # Enum NET.Orientation
     OrientationHorizontal = 0
     OrientationVertical = 0
 
     # Enum NET.RequestSource
     FromUnknown = 0
     FromApplication = 0
     FromTool = 0
 
     OnAllDesktops = None # int - member
     # Enum NET.Property2
     WM2UserTime = 0
     WM2StartupId = 0
     WM2TransientFor = 0
     WM2GroupLeader = 0
     WM2AllowedActions = 0
     WM2RestackWindow = 0
     WM2MoveResizeWindow = 0
     WM2ExtendedStrut = 0
     WM2TakeActivity = 0
     WM2KDETemporaryRules = 0
     WM2WindowClass = 0
     WM2WindowRole = 0
     WM2ClientMachine = 0
     WM2ShowingDesktop = 0
     WM2Opacity = 0
     WM2DesktopLayout = 0
     WM2FullPlacement = 0
     WM2FullscreenMonitors = 0
     WM2FrameOverlap = 0
     WM2Activities = 0
     WM2BlockCompositing = 0
     WM2KDEShadow = 0
 
     # Enum NET.Property
     Supported = 0
     ClientList = 0
     ClientListStacking = 0
     NumberOfDesktops = 0
     DesktopGeometry = 0
     DesktopViewport = 0
     CurrentDesktop = 0
     DesktopNames = 0
     ActiveWindow = 0
     WorkArea = 0
     SupportingWMCheck = 0
     VirtualRoots = 0
     CloseWindow = 0
     WMMoveResize = 0
     WMName = 0
     WMVisibleName = 0
     WMDesktop = 0
     WMWindowType = 0
     WMState = 0
     WMStrut = 0
     WMIconGeometry = 0
     WMIcon = 0
     WMPid = 0
     WMHandledIcons = 0
     WMPing = 0
     XAWMState = 0
     WMFrameExtents = 0
     WMIconName = 0
     WMVisibleIconName = 0
     WMGeometry = 0
 
     # Enum NET.Action
     ActionMove = 0
     ActionResize = 0
     ActionMinimize = 0
     ActionShade = 0
     ActionStick = 0
     ActionMaxVert = 0
     ActionMaxHoriz = 0
     ActionMax = 0
     ActionFullScreen = 0
     ActionChangeDesktop = 0
     ActionClose = 0
 
     # Enum NET.MappingState
     Visible = 0
     Withdrawn = 0
     Iconic = 0
 
     # Enum NET.Direction
     TopLeft = 0
     Top = 0
     TopRight = 0
     Right = 0
     BottomRight = 0
     Bottom = 0
     BottomLeft = 0
     Left = 0
     Move = 0
     KeyboardSize = 0
     KeyboardMove = 0
     MoveResizeCancel = 0
 
     # Enum NET.State
     Modal = 0
     Sticky = 0
     MaxVert = 0
     MaxHoriz = 0
     Max = 0
     Shaded = 0
     SkipTaskbar = 0
     KeepAbove = 0
     StaysOnTop = 0
     SkipPager = 0
     Hidden = 0
     FullScreen = 0
     KeepBelow = 0
     DemandsAttention = 0
 
     # Enum NET.WindowTypeMask
     NormalMask = 0
     DesktopMask = 0
     DockMask = 0
     ToolbarMask = 0
     MenuMask = 0
     DialogMask = 0
     OverrideMask = 0
     TopMenuMask = 0
     UtilityMask = 0
     SplashMask = 0
     DropdownMenuMask = 0
     PopupMenuMask = 0
     TooltipMask = 0
     NotificationMask = 0
     ComboBoxMask = 0
     DNDIconMask = 0
     AllTypesMask = 0
 
     # Enum NET.WindowType
     Unknown = 0
     Normal = 0
     Desktop = 0
     Dock = 0
     Toolbar = 0
     Menu = 0
     Dialog = 0
     Override = 0
     TopMenu = 0
     Utility = 0
     Splash = 0
     DropdownMenu = 0
     PopupMenu = 0
     Tooltip = 0
     Notification = 0
     ComboBox = 0
     DNDIcon = 0
 
     # Enum NET.Role
     Client = 0
     WindowManager = 0
 
     def __init__(self):
         '''void NET.__init__()'''
     def __init__(self):
         '''NET NET.__init__()'''
         return NET()
     def timestampDiff(self, time1, time2):
         '''static int NET.timestampDiff(int time1, int time2)'''
         return int()
     def timestampCompare(self, time1, time2):
         '''static int NET.timestampCompare(int time1, int time2)'''
         return int()
     def typeMatchesMask(self, type, mask):
         '''static bool NET.typeMatchesMask(NET.WindowType type, int mask)'''
         return bool()
 
 
 class KWindowSystem(QObject, NET):
     """"""
     # Enum KWindowSystem.IconSource
     NETWM = 0
     WMHints = 0
     ClassHint = 0
     XApp = 0
 
     compositingChanged = pyqtSignal() # void compositingChanged(bool) - signal
     def setBlockingCompositing(self, window, active):
         '''static void KWindowSystem.setBlockingCompositing(int window, bool active)'''
     def allowExternalProcessWindowActivation(self, pid = None):
         '''static void KWindowSystem.allowExternalProcessWindowActivation(int pid = -1)'''
     def connectNotify(self):
         '''SIGNAL() KWindowSystem.connectNotify()'''
         return SIGNAL()()
     showingDesktopChanged = pyqtSignal() # void showingDesktopChanged(bool) - signal
     windowChanged = pyqtSignal() # void windowChanged(WId,uint) - signal
     windowChanged = pyqtSignal() # void windowChanged(WId) - signal
     stackingOrderChanged = pyqtSignal() # void stackingOrderChanged() - signal
     strutChanged = pyqtSignal() # void strutChanged() - signal
     workAreaChanged = pyqtSignal() # void workAreaChanged() - signal
     numberOfDesktopsChanged = pyqtSignal() # void numberOfDesktopsChanged(int) - signal
     desktopNamesChanged = pyqtSignal() # void desktopNamesChanged() - signal
     activeWindowChanged = pyqtSignal() # void activeWindowChanged(WId) - signal
     windowRemoved = pyqtSignal() # void windowRemoved(WId) - signal
     windowAdded = pyqtSignal() # void windowAdded(WId) - signal
     currentDesktopChanged = pyqtSignal() # void currentDesktopChanged(int) - signal
     def constrainViewportRelativePosition(self, pos):
         '''static QPoint KWindowSystem.constrainViewportRelativePosition(QPoint pos)'''
         return QPoint()
     def desktopToViewport(self, desktop, absolute):
         '''static QPoint KWindowSystem.desktopToViewport(int desktop, bool absolute)'''
         return QPoint()
     def viewportWindowToDesktop(self, r):
         '''static int KWindowSystem.viewportWindowToDesktop(QRect r)'''
         return int()
     def viewportToDesktop(self, pos):
         '''static int KWindowSystem.viewportToDesktop(QPoint pos)'''
         return int()
     def mapViewport(self):
         '''static bool KWindowSystem.mapViewport()'''
         return bool()
     def doNotManage(self, title):
         '''static void KWindowSystem.doNotManage(QString title)'''
     def readNameProperty(self, window, atom):
         '''static QString KWindowSystem.readNameProperty(int window, int atom)'''
         return QString()
     def allowedActionsSupported(self):
         '''static bool KWindowSystem.allowedActionsSupported()'''
         return bool()
     def setStrut(self, win, left, right, top, bottom):
         '''static void KWindowSystem.setStrut(int win, int left, int right, int top, int bottom)'''
     def setExtendedStrut(self, win, left_width, left_start, left_end, right_width, right_start, right_end, top_width, top_start, top_end, bottom_width, bottom_start, bottom_end):
         '''static void KWindowSystem.setExtendedStrut(int win, int left_width, int left_start, int left_end, int right_width, int right_start, int right_end, int top_width, int top_start, int top_end, int bottom_width, int bottom_start, int bottom_end)'''
     def setUserTime(self, win, time):
         '''static void KWindowSystem.setUserTime(int win, int time)'''
     def showingDesktop(self):
         '''static bool KWindowSystem.showingDesktop()'''
         return bool()
     def setDesktopName(self, desktop, name):
         '''static void KWindowSystem.setDesktopName(int desktop, QString name)'''
     def desktopName(self, desktop):
         '''static QString KWindowSystem.desktopName(int desktop)'''
         return QString()
     def workArea(self, desktop = None):
         '''static QRect KWindowSystem.workArea(int desktop = -1)'''
         return QRect()
     def workArea(self, excludes, desktop = None):
         '''static QRect KWindowSystem.workArea(unknown-type excludes, int desktop = -1)'''
         return QRect()
     def icccmCompliantMappingState(self):
         '''static bool KWindowSystem.icccmCompliantMappingState()'''
         return bool()
     def lowerWindow(self, win):
         '''static void KWindowSystem.lowerWindow(int win)'''
     def raiseWindow(self, win):
         '''static void KWindowSystem.raiseWindow(int win)'''
     def unminimizeWindow(self, win, animation = True):
         '''static void KWindowSystem.unminimizeWindow(int win, bool animation = True)'''
     def minimizeWindow(self, win, animation = True):
         '''static void KWindowSystem.minimizeWindow(int win, bool animation = True)'''
     def clearState(self, win, state):
         '''static void KWindowSystem.clearState(int win, int state)'''
     def setState(self, win, state):
         '''static void KWindowSystem.setState(int win, int state)'''
     def setType(self, win, windowType):
         '''static void KWindowSystem.setType(int win, NET.WindowType windowType)'''
     def setIcons(self, win, icon, miniIcon):
         '''static void KWindowSystem.setIcons(int win, QPixmap icon, QPixmap miniIcon)'''
     def icon(self, win, width = None, height = None, scale = False):
         '''static QPixmap KWindowSystem.icon(int win, int width = -1, int height = -1, bool scale = False)'''
         return QPixmap()
     def icon(self, win, width, height, scale, flags):
         '''static QPixmap KWindowSystem.icon(int win, int width, int height, bool scale, int flags)'''
         return QPixmap()
     def groupLeader(self, window):
         '''static int KWindowSystem.groupLeader(int window)'''
         return int()
     def transientFor(self, window):
         '''static int KWindowSystem.transientFor(int window)'''
         return int()
     def setMainWindow(self, subwindow, mainwindow):
         '''static void KWindowSystem.setMainWindow(QWidget subwindow, int mainwindow)'''
     def setOnDesktop(self, win, desktop):
         '''static void KWindowSystem.setOnDesktop(int win, int desktop)'''
     def setOnAllDesktops(self, win, b):
         '''static void KWindowSystem.setOnAllDesktops(int win, bool b)'''
     def setCurrentDesktop(self, desktop):
         '''static void KWindowSystem.setCurrentDesktop(int desktop)'''
     def numberOfDesktops(self):
         '''static int KWindowSystem.numberOfDesktops()'''
         return int()
     def currentDesktop(self):
         '''static int KWindowSystem.currentDesktop()'''
         return int()
     def compositingActive(self):
         '''static bool KWindowSystem.compositingActive()'''
         return bool()
     def demandAttention(self, win, set = True):
         '''static void KWindowSystem.demandAttention(int win, bool set = True)'''
     def forceActiveWindow(self, win, time = 0):
         '''static void KWindowSystem.forceActiveWindow(int win, int time = 0)'''
     def activateWindow(self, win, time = 0):
         '''static void KWindowSystem.activateWindow(int win, int time = 0)'''
     def activeWindow(self):
         '''static int KWindowSystem.activeWindow()'''
         return int()
     def stackingOrder(self):
         '''static unknown-type KWindowSystem.stackingOrder()'''
         return unknown-type()
     def windowInfo(self, win, properties, properties2 = 0):
         '''static KWindowInfo KWindowSystem.windowInfo(int win, int properties, int properties2 = 0)'''
         return KWindowInfo()
     def hasWId(self, id):
         '''static bool KWindowSystem.hasWId(int id)'''
         return bool()
     def windows(self):
         '''static unknown-type KWindowSystem.windows()'''
         return unknown-type()
     def self(self):
         '''static KWindowSystem KWindowSystem.self()'''
         return KWindowSystem()
 
 
 class KWordWrap():
     """"""
     FadeOut = None # int - member
     Truncate = None # int - member
     def drawTruncateText(self, p, x, y, maxW, t):
         '''static void KWordWrap.drawTruncateText(QPainter p, int x, int y, int maxW, QString t)'''
     def drawFadeoutText(self, p, x, y, maxW, t):
         '''static void KWordWrap.drawFadeoutText(QPainter p, int x, int y, int maxW, QString t)'''
     def drawText(self, painter, x, y, flags = None):
         '''void KWordWrap.drawText(QPainter painter, int x, int y, int flags = Qt.AlignLeft)'''
     def truncatedString(self, dots = True):
         '''QString KWordWrap.truncatedString(bool dots = True)'''
         return QString()
     def wrappedString(self):
         '''QString KWordWrap.wrappedString()'''
         return QString()
     def boundingRect(self):
         '''QRect KWordWrap.boundingRect()'''
         return QRect()
     def formatText(self, fm, r, flags, str, len = None):
         '''static KWordWrap KWordWrap.formatText(QFontMetrics fm, QRect r, int flags, QString str, int len = -1)'''
         return KWordWrap()
 
 
 class KXMessages(QWidget):
     """"""
     def __init__(self, accept_broadcast, parent, obsolete):
         '''void KXMessages.__init__(str accept_broadcast, QWidget parent, bool obsolete)'''
     def __init__(self, accept_broadcast = None, parent = None):
         '''void KXMessages.__init__(str accept_broadcast = None, QWidget parent = None)'''
     gotMessage = pyqtSignal() # void gotMessage(const QStringamp;) - signal
     def broadcastMessageX(self, disp, msg_type, message, screen, obsolete):
         '''static bool KXMessages.broadcastMessageX(Display disp, str msg_type, QString message, int screen, bool obsolete)'''
         return bool()
     def broadcastMessageX(self, disp, msg_type, message):
         '''static bool KXMessages.broadcastMessageX(Display disp, str msg_type, QString message)'''
         return bool()
     def sendMessageX(self, disp, w, msg_type, message, obsolete):
         '''static bool KXMessages.sendMessageX(Display disp, int w, str msg_type, QString message, bool obsolete)'''
         return bool()
     def sendMessageX(self, disp, w, msg_type, message):
         '''static bool KXMessages.sendMessageX(Display disp, int w, str msg_type, QString message)'''
         return bool()
     def broadcastMessage(self, msg_type, message, screen, obsolete):
         '''void KXMessages.broadcastMessage(str msg_type, QString message, int screen, bool obsolete)'''
     def broadcastMessage(self, msg_type, message):
         '''void KXMessages.broadcastMessage(str msg_type, QString message)'''
     def sendMessage(self, w, msg_type, message, obsolete):
         '''void KXMessages.sendMessage(int w, str msg_type, QString message, bool obsolete)'''
     def sendMessage(self, w, msg_type, message):
         '''void KXMessages.sendMessage(int w, str msg_type, QString message)'''
 
 
 class KXMLGUIBuilder():
     """"""
     def __init__(self, widget):
         '''void KXMLGUIBuilder.__init__(QWidget widget)'''
     def finalizeGUI(self, client):
         '''void KXMLGUIBuilder.finalizeGUI(KXMLGUIClient client)'''
     def removeCustomElement(self, parent, action):
         '''void KXMLGUIBuilder.removeCustomElement(QWidget parent, QAction action)'''
     def createCustomElement(self, parent, index, element):
         '''QAction KXMLGUIBuilder.createCustomElement(QWidget parent, int index, QDomElement element)'''
         return QAction()
     def customTags(self):
         '''QStringList KXMLGUIBuilder.customTags()'''
         return QStringList()
     def removeContainer(self, container, parent, element, containerAction):
         '''void KXMLGUIBuilder.removeContainer(QWidget container, QWidget parent, QDomElement element, QAction containerAction)'''
     def createContainer(self, parent, index, element):
         '''tuple KXMLGUIBuilder.createContainer(QWidget parent, int index, QDomElement element)'''
         return tuple()
     def containerTags(self):
         '''QStringList KXMLGUIBuilder.containerTags()'''
         return QStringList()
     def widget(self):
         '''QWidget KXMLGUIBuilder.widget()'''
         return QWidget()
     def setBuilderComponentData(self, componentData):
         '''void KXMLGUIBuilder.setBuilderComponentData(KComponentData componentData)'''
     def builderComponentData(self):
         '''KComponentData KXMLGUIBuilder.builderComponentData()'''
         return KComponentData()
     def setBuilderClient(self, client):
         '''void KXMLGUIBuilder.setBuilderClient(KXMLGUIClient client)'''
     def builderClient(self):
         '''KXMLGUIClient KXMLGUIBuilder.builderClient()'''
         return KXMLGUIClient()
 
 
 class KXMLGUIClient():
     """"""
     # Enum KXMLGUIClient.ReverseStateChange
     StateNoReverse = 0
     StateReverse = 0
 
     def __init__(self):
         '''void KXMLGUIClient.__init__()'''
     def __init__(self, parent):
         '''void KXMLGUIClient.__init__(KXMLGUIClient parent)'''
     def loadStandardsXmlFile(self):
         '''void KXMLGUIClient.loadStandardsXmlFile()'''
     def replaceXMLFile(self, xmlfile, localxmlfile, merge = False):
         '''void KXMLGUIClient.replaceXMLFile(QString xmlfile, QString localxmlfile, bool merge = False)'''
     def stateChanged(self, newstate, reverse = None):
         '''void KXMLGUIClient.stateChanged(QString newstate, KXMLGUIClient.ReverseStateChange reverse = KXMLGUIClient.StateNoReverse)'''
     def setDOMDocument(self, document, merge = False):
         '''void KXMLGUIClient.setDOMDocument(QDomDocument document, bool merge = False)'''
     def setXML(self, document, merge = False):
         '''void KXMLGUIClient.setXML(QString document, bool merge = False)'''
     def setLocalXMLFile(self, file):
         '''void KXMLGUIClient.setLocalXMLFile(QString file)'''
     def setXMLFile(self, file, merge = False, setXMLDoc = True):
         '''void KXMLGUIClient.setXMLFile(QString file, bool merge = False, bool setXMLDoc = True)'''
     def setComponentData(self, componentData):
         '''void KXMLGUIClient.setComponentData(KComponentData componentData)'''
     def prepareXMLUnplug(self):
         '''QWidget KXMLGUIClient.prepareXMLUnplug()'''
         return QWidget()
     def endXMLPlug(self):
         '''void KXMLGUIClient.endXMLPlug()'''
     def beginXMLPlug(self):
         '''QWidget KXMLGUIClient.beginXMLPlug()'''
         return QWidget()
     def getActionsToChangeForState(self, state):
         '''KXMLGUIClient.StateChange KXMLGUIClient.getActionsToChangeForState(QString state)'''
         return KXMLGUIClient.StateChange()
     def addStateActionDisabled(self, state, action):
         '''void KXMLGUIClient.addStateActionDisabled(QString state, QString action)'''
     def addStateActionEnabled(self, state, action):
         '''void KXMLGUIClient.addStateActionEnabled(QString state, QString action)'''
     def findMostRecentXMLFile(self, files, doc):
         '''static QString KXMLGUIClient.findMostRecentXMLFile(QStringList files, QString doc)'''
         return QString()
     def unplugActionList(self, name):
         '''void KXMLGUIClient.unplugActionList(QString name)'''
     def plugActionList(self, name, actionList):
         '''void KXMLGUIClient.plugActionList(QString name, list-of-QAction actionList)'''
     def reloadXML(self):
         '''void KXMLGUIClient.reloadXML()'''
     def clientBuilder(self):
         '''KXMLGUIBuilder KXMLGUIClient.clientBuilder()'''
         return KXMLGUIBuilder()
     def setClientBuilder(self, builder):
         '''void KXMLGUIClient.setClientBuilder(KXMLGUIBuilder builder)'''
     def childClients(self):
         '''list-of-KXMLGUIClient KXMLGUIClient.childClients()'''
         return [KXMLGUIClient()]
     def removeChildClient(self, child):
         '''void KXMLGUIClient.removeChildClient(KXMLGUIClient child)'''
     def insertChildClient(self, child):
         '''void KXMLGUIClient.insertChildClient(KXMLGUIClient child)'''
     def parentClient(self):
         '''KXMLGUIClient KXMLGUIClient.parentClient()'''
         return KXMLGUIClient()
     def factory(self):
         '''KXMLGUIFactory KXMLGUIClient.factory()'''
         return KXMLGUIFactory()
     def setFactory(self, factory):
         '''void KXMLGUIClient.setFactory(KXMLGUIFactory factory)'''
     def xmlguiBuildDocument(self):
         '''QDomDocument KXMLGUIClient.xmlguiBuildDocument()'''
         return QDomDocument()
     def setXMLGUIBuildDocument(self, doc):
         '''void KXMLGUIClient.setXMLGUIBuildDocument(QDomDocument doc)'''
     def localXMLFile(self):
         '''QString KXMLGUIClient.localXMLFile()'''
         return QString()
     def xmlFile(self):
         '''QString KXMLGUIClient.xmlFile()'''
         return QString()
     def domDocument(self):
         '''QDomDocument KXMLGUIClient.domDocument()'''
         return QDomDocument()
     def componentData(self):
         '''KComponentData KXMLGUIClient.componentData()'''
         return KComponentData()
     def actionCollection(self):
         '''KActionCollection KXMLGUIClient.actionCollection()'''
         return KActionCollection()
     def action(self, name):
         '''QAction KXMLGUIClient.action(str name)'''
         return QAction()
     def action(self, element):
         '''QAction KXMLGUIClient.action(QDomElement element)'''
         return QAction()
     class StateChange():
         """"""
         actionsToDisable = None # QStringList - member
         actionsToEnable = None # QStringList - member
         def __init__(self):
             '''void KXMLGUIClient.StateChange.__init__()'''
         def __init__(self):
             '''KXMLGUIClient.StateChange KXMLGUIClient.StateChange.__init__()'''
             return KXMLGUIClient.StateChange()
 
 
 class KXMLGUIFactory(QObject):
     """"""
     def __init__(self, builder, parent = None):
         '''void KXMLGUIFactory.__init__(KXMLGUIBuilder builder, QObject parent = None)'''
     makingChanges = pyqtSignal() # void makingChanges(bool) - signal
     clientRemoved = pyqtSignal() # void clientRemoved(KXMLGUIClient *) - signal
     clientAdded = pyqtSignal() # void clientAdded(KXMLGUIClient *) - signal
     def changeShortcutScheme(self, scheme):
         '''void KXMLGUIFactory.changeShortcutScheme(QString scheme)'''
     def configureShortcuts(self, bAllowLetterShortcuts = True, bSaveSettings = True):
         '''int KXMLGUIFactory.configureShortcuts(bool bAllowLetterShortcuts = True, bool bSaveSettings = True)'''
         return int()
     def refreshActionProperties(self):
         '''void KXMLGUIFactory.refreshActionProperties()'''
     def resetContainer(self, containerName, useTagName = False):
         '''void KXMLGUIFactory.resetContainer(QString containerName, bool useTagName = False)'''
     def reset(self):
         '''void KXMLGUIFactory.reset()'''
     def containers(self, tagName):
         '''list-of-QWidget KXMLGUIFactory.containers(QString tagName)'''
         return [QWidget()]
     def container(self, containerName, client, useTagName = False):
         '''QWidget KXMLGUIFactory.container(QString containerName, KXMLGUIClient client, bool useTagName = False)'''
         return QWidget()
     def clients(self):
         '''list-of-KXMLGUIClient KXMLGUIFactory.clients()'''
         return [KXMLGUIClient()]
     def unplugActionList(self, client, name):
         '''void KXMLGUIFactory.unplugActionList(KXMLGUIClient client, QString name)'''
     def plugActionList(self, client, name, actionList):
         '''void KXMLGUIFactory.plugActionList(KXMLGUIClient client, QString name, list-of-QAction actionList)'''
     def removeClient(self, client):
         '''void KXMLGUIFactory.removeClient(KXMLGUIClient client)'''
     def addClient(self, client):
         '''void KXMLGUIFactory.addClient(KXMLGUIClient client)'''
     def findActionByName(self, elem, sName, create):
         '''static QDomElement KXMLGUIFactory.findActionByName(QDomElement elem, QString sName, bool create)'''
         return QDomElement()
     def actionPropertiesElement(self, doc):
         '''static QDomElement KXMLGUIFactory.actionPropertiesElement(QDomDocument doc)'''
         return QDomElement()
     def saveConfigFile(self, doc, filename, componentData = KComponentData()):
         '''static bool KXMLGUIFactory.saveConfigFile(QDomDocument doc, QString filename, KComponentData componentData = KComponentData())'''
         return bool()
     def readConfigFile(self, filename, componentData = KComponentData()):
         '''static QString KXMLGUIFactory.readConfigFile(QString filename, KComponentData componentData = KComponentData())'''
         return QString()
 
 
 class KXmlGuiWindow(KMainWindow, KXMLGUIBuilder, KXMLGUIClient):
     """"""
     # Enum KXmlGuiWindow.StandardWindowOption
     ToolBar = 0
     Keys = 0
     StatusBar = 0
     Save = 0
     Create = 0
     Default = 0
 
     def __init__(self, parent = None, f = 0):
         '''void KXmlGuiWindow.__init__(QWidget parent = None, Qt.WindowFlags f = 0)'''
     def saveNewToolbarConfig(self):
         '''void KXmlGuiWindow.saveNewToolbarConfig()'''
     def event(self, event):
         '''bool KXmlGuiWindow.event(QEvent event)'''
         return bool()
     def slotStateChanged(self, newstate):
         '''void KXmlGuiWindow.slotStateChanged(QString newstate)'''
     def slotStateChanged(self, newstate, reverse):
         '''void KXmlGuiWindow.slotStateChanged(QString newstate, bool reverse)'''
     def configureToolbars(self):
         '''void KXmlGuiWindow.configureToolbars()'''
     def applyMainWindowSettings(self, config, force = False):
         '''void KXmlGuiWindow.applyMainWindowSettings(KConfigGroup config, bool force = False)'''
     def finalizeGUI(self, client):
         '''void KXmlGuiWindow.finalizeGUI(KXMLGUIClient client)'''
     def finalizeGUI(self, force):
         '''void KXmlGuiWindow.finalizeGUI(bool force)'''
     def setupToolbarMenuActions(self):
         '''void KXmlGuiWindow.setupToolbarMenuActions()'''
     def toolBarMenuAction(self):
         '''QAction KXmlGuiWindow.toolBarMenuAction()'''
         return QAction()
     def setupGUI(self, options = None, xmlfile = QString()):
         '''void KXmlGuiWindow.setupGUI(KXmlGuiWindow.StandardWindowOptions options = KXmlGuiWindow.Default, QString xmlfile = QString())'''
     def setupGUI(self, defaultSize, options = None, xmlfile = QString()):
         '''void KXmlGuiWindow.setupGUI(QSize defaultSize, KXmlGuiWindow.StandardWindowOptions options = KXmlGuiWindow.Default, QString xmlfile = QString())'''
     def createStandardStatusBarAction(self):
         '''void KXmlGuiWindow.createStandardStatusBarAction()'''
     def isStandardToolBarMenuEnabled(self):
         '''bool KXmlGuiWindow.isStandardToolBarMenuEnabled()'''
         return bool()
     def setStandardToolBarMenuEnabled(self, enable):
         '''void KXmlGuiWindow.setStandardToolBarMenuEnabled(bool enable)'''
     def createGUI(self, xmlfile = QString()):
         '''void KXmlGuiWindow.createGUI(QString xmlfile = QString())'''
     def guiFactory(self):
         '''KXMLGUIFactory KXmlGuiWindow.guiFactory()'''
         return KXMLGUIFactory()
     def isHelpMenuEnabled(self):
         '''bool KXmlGuiWindow.isHelpMenuEnabled()'''
         return bool()
     def setHelpMenuEnabled(self, showHelpMenu = True):
         '''void KXmlGuiWindow.setHelpMenuEnabled(bool showHelpMenu = True)'''
     class StandardWindowOptions():
         """"""
         def __init__(self):
             '''KXmlGuiWindow.StandardWindowOptions KXmlGuiWindow.StandardWindowOptions.__init__()'''
             return KXmlGuiWindow.StandardWindowOptions()
         def __init__(self):
             '''int KXmlGuiWindow.StandardWindowOptions.__init__()'''
             return int()
         def __init__(self):
             '''void KXmlGuiWindow.StandardWindowOptions.__init__()'''
         def __bool__(self):
             '''int KXmlGuiWindow.StandardWindowOptions.__bool__()'''
             return int()
         def __ne__(self, f):
             '''bool KXmlGuiWindow.StandardWindowOptions.__ne__(KXmlGuiWindow.StandardWindowOptions f)'''
             return bool()
         def __eq__(self, f):
             '''bool KXmlGuiWindow.StandardWindowOptions.__eq__(KXmlGuiWindow.StandardWindowOptions f)'''
             return bool()
         def __invert__(self):
             '''KXmlGuiWindow.StandardWindowOptions KXmlGuiWindow.StandardWindowOptions.__invert__()'''
             return KXmlGuiWindow.StandardWindowOptions()
         def __and__(self, mask):
             '''KXmlGuiWindow.StandardWindowOptions KXmlGuiWindow.StandardWindowOptions.__and__(int mask)'''
             return KXmlGuiWindow.StandardWindowOptions()
         def __xor__(self, f):
             '''KXmlGuiWindow.StandardWindowOptions KXmlGuiWindow.StandardWindowOptions.__xor__(KXmlGuiWindow.StandardWindowOptions f)'''
             return KXmlGuiWindow.StandardWindowOptions()
         def __xor__(self, f):
             '''KXmlGuiWindow.StandardWindowOptions KXmlGuiWindow.StandardWindowOptions.__xor__(int f)'''
             return KXmlGuiWindow.StandardWindowOptions()
         def __or__(self, f):
             '''KXmlGuiWindow.StandardWindowOptions KXmlGuiWindow.StandardWindowOptions.__or__(KXmlGuiWindow.StandardWindowOptions f)'''
             return KXmlGuiWindow.StandardWindowOptions()
         def __or__(self, f):
             '''KXmlGuiWindow.StandardWindowOptions KXmlGuiWindow.StandardWindowOptions.__or__(int f)'''
             return KXmlGuiWindow.StandardWindowOptions()
         def __int__(self):
             '''int KXmlGuiWindow.StandardWindowOptions.__int__()'''
             return int()
         def __ixor__(self, f):
             '''KXmlGuiWindow.StandardWindowOptions KXmlGuiWindow.StandardWindowOptions.__ixor__(KXmlGuiWindow.StandardWindowOptions f)'''
             return KXmlGuiWindow.StandardWindowOptions()
         def __ior__(self, f):
             '''KXmlGuiWindow.StandardWindowOptions KXmlGuiWindow.StandardWindowOptions.__ior__(KXmlGuiWindow.StandardWindowOptions f)'''
             return KXmlGuiWindow.StandardWindowOptions()
         def __iand__(self, mask):
             '''KXmlGuiWindow.StandardWindowOptions KXmlGuiWindow.StandardWindowOptions.__iand__(int mask)'''
             return KXmlGuiWindow.StandardWindowOptions()
 
 
 class KXUtils():
     """"""
     def timestampDiff(self, time1, time2):
         '''static int KXUtils.timestampDiff(int time1, int time2)'''
         return int()
     def timestampCompare(self, time1, time2):
         '''static int KXUtils.timestampCompare(int time1, int time2)'''
         return int()
     def createPixmapFromHandle(self, pixmap, mask = 0):
         '''static QPixmap KXUtils.createPixmapFromHandle(int pixmap, int mask = 0)'''
         return QPixmap()
 
 
 class KRatingPainter():
     """"""
     def __init__(self):
         '''void KRatingPainter.__init__()'''
     def getRatingFromPosition(self, rect, align, direction, pos):
         '''static int KRatingPainter.getRatingFromPosition(QRect rect, Qt.Alignment align, Qt.LayoutDirection direction, QPoint pos)'''
         return int()
     def paintRating(self, p, rect, align, rating, hoverRating = None):
         '''static void KRatingPainter.paintRating(QPainter p, QRect rect, Qt.Alignment align, int rating, int hoverRating = -1)'''
     def ratingFromPosition(self, rect, pos):
         '''int KRatingPainter.ratingFromPosition(QRect rect, QPoint pos)'''
         return int()
     def paint(self, painter, rect, rating, hoverRating = None):
         '''void KRatingPainter.paint(QPainter painter, QRect rect, int rating, int hoverRating = -1)'''
     def setSpacing(self, spacing):
         '''void KRatingPainter.setSpacing(int spacing)'''
     def setCustomPixmap(self, pixmap):
         '''void KRatingPainter.setCustomPixmap(QPixmap pixmap)'''
     def setEnabled(self, enabled):
         '''void KRatingPainter.setEnabled(bool enabled)'''
     def setIcon(self, icon):
         '''void KRatingPainter.setIcon(QIcon icon)'''
     def setLayoutDirection(self, direction):
         '''void KRatingPainter.setLayoutDirection(Qt.LayoutDirection direction)'''
     def setAlignment(self, align):
         '''void KRatingPainter.setAlignment(Qt.Alignment align)'''
     def setHalfStepsEnabled(self, enabled):
         '''void KRatingPainter.setHalfStepsEnabled(bool enabled)'''
     def setMaxRating(self, max):
         '''void KRatingPainter.setMaxRating(int max)'''
     def spacing(self):
         '''int KRatingPainter.spacing()'''
         return int()
     def customPixmap(self):
         '''QPixmap KRatingPainter.customPixmap()'''
         return QPixmap()
     def isEnabled(self):
         '''bool KRatingPainter.isEnabled()'''
         return bool()
     def icon(self):
         '''QIcon KRatingPainter.icon()'''
         return QIcon()
     def layoutDirection(self):
         '''Qt.LayoutDirection KRatingPainter.layoutDirection()'''
         return Qt.LayoutDirection()
     def alignment(self):
         '''Qt.Alignment KRatingPainter.alignment()'''
         return Qt.Alignment()
     def halfStepsEnabled(self):
         '''bool KRatingPainter.halfStepsEnabled()'''
         return bool()
     def maxRating(self):
         '''int KRatingPainter.maxRating()'''
         return int()
 
 
 class KRatingWidget(QFrame):
     """"""
     def __init__(self, parent = None):
         '''void KRatingWidget.__init__(QWidget parent = None)'''
     def resizeEvent(self, e):
         '''void KRatingWidget.resizeEvent(QResizeEvent e)'''
     def paintEvent(self, e):
         '''void KRatingWidget.paintEvent(QPaintEvent e)'''
     def leaveEvent(self, e):
         '''void KRatingWidget.leaveEvent(QEvent e)'''
     def mouseMoveEvent(self, e):
         '''void KRatingWidget.mouseMoveEvent(QMouseEvent e)'''
     def mousePressEvent(self, e):
         '''void KRatingWidget.mousePressEvent(QMouseEvent e)'''
     def setPixmapSize(self, size):
         '''void KRatingWidget.setPixmapSize(int size)'''
     def setPixmap(self):
         '''QPixmap KRatingWidget.setPixmap()'''
         return QPixmap()
     def setCustomPixmap(self, pixmap):
         '''void KRatingWidget.setCustomPixmap(QPixmap pixmap)'''
     def setIcon(self, icon):
         '''void KRatingWidget.setIcon(QIcon icon)'''
     def setLayoutDirection(self, direction):
         '''void KRatingWidget.setLayoutDirection(Qt.LayoutDirection direction)'''
     def setAlignment(self, align):
         '''void KRatingWidget.setAlignment(Qt.Alignment align)'''
     def setSpacing(self):
         '''int KRatingWidget.setSpacing()'''
         return int()
     def setOnlyPaintFullSteps(self):
         '''bool KRatingWidget.setOnlyPaintFullSteps()'''
         return bool()
     def setHalfStepsEnabled(self, enabled):
         '''void KRatingWidget.setHalfStepsEnabled(bool enabled)'''
     def setMaxRating(self, max):
         '''void KRatingWidget.setMaxRating(int max)'''
     def setRating(self, rating):
         '''void KRatingWidget.setRating(int rating)'''
     ratingChanged = pyqtSignal() # void ratingChanged(int) - signal
     def icon(self):
         '''QIcon KRatingWidget.icon()'''
         return QIcon()
     def halfStepsEnabled(self):
         '''bool KRatingWidget.halfStepsEnabled()'''
         return bool()
     def sizeHint(self):
         '''QSize KRatingWidget.sizeHint()'''
         return QSize()
     def spacing(self):
         '''int KRatingWidget.spacing()'''
         return int()
     def layoutDirection(self):
         '''Qt.LayoutDirection KRatingWidget.layoutDirection()'''
         return Qt.LayoutDirection()
     def alignment(self):
         '''Qt.Alignment KRatingWidget.alignment()'''
         return Qt.Alignment()
     def maxRating(self):
         '''int KRatingWidget.maxRating()'''
         return int()
     def rating(self):
         '''int KRatingWidget.rating()'''
         return int()
 
 
 class NETRootInfo(NET):
     """"""
     PROTOCOLS = None # int - member
     WINDOW_TYPES = None # int - member
     STATES = None # int - member
     PROTOCOLS2 = None # int - member
     ACTIONS = None # int - member
     PROPERTIES_SIZE = None # int - member
     def __init__(self, display, supportWindow, wmName, properties, screen = None, doACtivate = True):
         '''void NETRootInfo.__init__(Display display, int supportWindow, str wmName, list properties, int screen = -1, bool doACtivate = True)'''
     def __init__(self, display, properties, screen = None, doActivate = True):
         '''void NETRootInfo.__init__(Display display, list properties, int screen = -1, bool doActivate = True)'''
     def __init__(self, display, properties, screen = None, doActivate = True):
         '''void NETRootInfo.__init__(Display display, int properties, int screen = -1, bool doActivate = True)'''
     def __init__(self, rootinfo):
         '''void NETRootInfo.__init__(NETRootInfo rootinfo)'''
     def setSupported(self, property, on = True):
         '''void NETRootInfo.setSupported(NET.Property property, bool on = True)'''
     def setSupported(self, property, on = True):
         '''void NETRootInfo.setSupported(NET.Property2 property, bool on = True)'''
     def setSupported(self, property, on = True):
         '''void NETRootInfo.setSupported(NET.WindowType property, bool on = True)'''
     def setSupported(self, property, on = True):
         '''void NETRootInfo.setSupported(NET.State property, bool on = True)'''
     def setSupported(self, property, on = True):
         '''void NETRootInfo.setSupported(NET.Action property, bool on = True)'''
     def changeShowingDesktop(self, showing):
         '''void NETRootInfo.changeShowingDesktop(bool showing)'''
     def gotTakeActivity(self, window, timestamp, flags):
         '''void NETRootInfo.gotTakeActivity(int window, int timestamp, int flags)'''
     def restackWindow(self, window, source, above, detail, timestamp):
         '''void NETRootInfo.restackWindow(int window, NET.RequestSource source, int above, int detail, int timestamp)'''
     def moveResizeWindow(self, window, flags, x, y, width, height):
         '''void NETRootInfo.moveResizeWindow(int window, int flags, int x, int y, int width, int height)'''
     def changeActiveWindow(self, window, src, timestamp, active_window):
         '''void NETRootInfo.changeActiveWindow(int window, NET.RequestSource src, int timestamp, int active_window)'''
     def gotPing(self, window, timestamp):
         '''void NETRootInfo.gotPing(int window, int timestamp)'''
     def moveResize(self, window, x_root, y_root, direction):
         '''void NETRootInfo.moveResize(int window, int x_root, int y_root, int direction)'''
     def closeWindow(self, window):
         '''void NETRootInfo.closeWindow(int window)'''
     def changeCurrentDesktop(self, desktop):
         '''void NETRootInfo.changeCurrentDesktop(int desktop)'''
     def changeDesktopViewport(self, desktop, viewport):
         '''void NETRootInfo.changeDesktopViewport(int desktop, NETPoint viewport)'''
     def changeDesktopGeometry(self, desktop, geom):
         '''void NETRootInfo.changeDesktopGeometry(int desktop, NETSize geom)'''
     def changeNumberOfDesktops(self, numberOfDesktops):
         '''void NETRootInfo.changeNumberOfDesktops(int numberOfDesktops)'''
     def removeClient(self, window):
         '''void NETRootInfo.removeClient(int window)'''
     def addClient(self, window):
         '''void NETRootInfo.addClient(int window)'''
     def takeActivity(self, window, timestamp, flags):
         '''void NETRootInfo.takeActivity(int window, int timestamp, int flags)'''
     def sendPing(self, window, timestamp):
         '''void NETRootInfo.sendPing(int window, int timestamp)'''
     def restackRequest(self, window, source, above, detail, timestamp):
         '''void NETRootInfo.restackRequest(int window, NET.RequestSource source, int above, int detail, int timestamp)'''
     def moveResizeWindowRequest(self, window, flags, x, y, width, height):
         '''void NETRootInfo.moveResizeWindowRequest(int window, int flags, int x, int y, int width, int height)'''
     def moveResizeRequest(self, window, x_root, y_root, direction):
         '''void NETRootInfo.moveResizeRequest(int window, int x_root, int y_root, NET.Direction direction)'''
     def closeWindowRequest(self, window):
         '''void NETRootInfo.closeWindowRequest(int window)'''
     def showingDesktop(self):
         '''bool NETRootInfo.showingDesktop()'''
         return bool()
     def setShowingDesktop(self, showing):
         '''void NETRootInfo.setShowingDesktop(bool showing)'''
     def setDesktopLayout(self, orientation, columns, rows, corner):
         '''void NETRootInfo.setDesktopLayout(NET.Orientation orientation, int columns, int rows, NET.DesktopLayoutCorner corner)'''
     def setVirtualRoots(self, windows, count):
         '''void NETRootInfo.setVirtualRoots(int windows, int count)'''
     def setWorkArea(self, desktop, workArea):
         '''void NETRootInfo.setWorkArea(int desktop, NETRect workArea)'''
     def setActiveWindow(self, window, src, timestamp, active_window):
         '''void NETRootInfo.setActiveWindow(int window, NET.RequestSource src, int timestamp, int active_window)'''
     def setActiveWindow(self, window):
         '''void NETRootInfo.setActiveWindow(int window)'''
     def setDesktopName(self, desktop, desktopName):
         '''void NETRootInfo.setDesktopName(int desktop, str desktopName)'''
     def setNumberOfDesktops(self, numberOfDesktops):
         '''void NETRootInfo.setNumberOfDesktops(int numberOfDesktops)'''
     def setDesktopViewport(self, desktop, viewport):
         '''void NETRootInfo.setDesktopViewport(int desktop, NETPoint viewport)'''
     def setDesktopGeometry(self, desktop, geometry):
         '''void NETRootInfo.setDesktopGeometry(int desktop, NETSize geometry)'''
     def setCurrentDesktop(self, desktop, ignore_viewport = False):
         '''void NETRootInfo.setCurrentDesktop(int desktop, bool ignore_viewport = False)'''
     def setClientListStacking(self, windows, count):
         '''void NETRootInfo.setClientListStacking(int windows, int count)'''
     def setClientList(self, windows, count):
         '''void NETRootInfo.setClientList(int windows, int count)'''
     def activate(self):
         '''void NETRootInfo.activate()'''
     def activeWindow(self):
         '''int NETRootInfo.activeWindow()'''
         return int()
     def currentDesktop(self, ignore_viewport = False):
         '''int NETRootInfo.currentDesktop(bool ignore_viewport = False)'''
         return int()
     def numberOfDesktops(self, ignore_viewport = False):
         '''int NETRootInfo.numberOfDesktops(bool ignore_viewport = False)'''
         return int()
     def desktopLayoutCorner(self):
         '''NET.DesktopLayoutCorner NETRootInfo.desktopLayoutCorner()'''
         return NET.DesktopLayoutCorner()
     def desktopLayoutColumnsRows(self):
         '''QSize NETRootInfo.desktopLayoutColumnsRows()'''
         return QSize()
     def desktopLayoutOrientation(self):
         '''NET.Orientation NETRootInfo.desktopLayoutOrientation()'''
         return NET.Orientation()
     def virtualRootsCount(self):
         '''int NETRootInfo.virtualRootsCount()'''
         return int()
     def desktopName(self, desktop):
         '''str NETRootInfo.desktopName(int desktop)'''
         return str()
     def workArea(self, desktop):
         '''NETRect NETRootInfo.workArea(int desktop)'''
         return NETRect()
     def desktopViewport(self, desktop):
         '''NETPoint NETRootInfo.desktopViewport(int desktop)'''
         return NETPoint()
     def desktopGeometry(self, desktop):
         '''NETSize NETRootInfo.desktopGeometry(int desktop)'''
         return NETSize()
     def clientListStackingCount(self):
         '''int NETRootInfo.clientListStackingCount()'''
         return int()
     def clientListCount(self):
         '''int NETRootInfo.clientListCount()'''
         return int()
     def isSupported(self, property):
         '''bool NETRootInfo.isSupported(NET.Property property)'''
         return bool()
     def isSupported(self, property):
         '''bool NETRootInfo.isSupported(NET.Property2 property)'''
         return bool()
     def isSupported(self, type):
         '''bool NETRootInfo.isSupported(NET.WindowType type)'''
         return bool()
     def isSupported(self, state):
         '''bool NETRootInfo.isSupported(NET.State state)'''
         return bool()
     def isSupported(self, action):
         '''bool NETRootInfo.isSupported(NET.Action action)'''
         return bool()
     def screenNumber(self):
         '''int NETRootInfo.screenNumber()'''
         return int()
     def wmName(self):
         '''str NETRootInfo.wmName()'''
         return str()
     def supportWindow(self):
         '''int NETRootInfo.supportWindow()'''
         return int()
     def rootWindow(self):
         '''int NETRootInfo.rootWindow()'''
         return int()
     def x11Display(self):
         '''Display NETRootInfo.x11Display()'''
         return Display()
 
 
 class NETWinInfo(NET):
     """"""
     PROTOCOLS = None # int - member
     PROTOCOLS2 = None # int - member
     PROPERTIES_SIZE = None # int - member
     OnAllDesktops = None # int - member
     def __init__(self, display, window, rootWindow, properties, role = None):
         '''void NETWinInfo.__init__(Display display, int window, int rootWindow, list properties, NET.Role role = NET.Client)'''
     def __init__(self, display, window, rootWindow, properties, role = None):
         '''void NETWinInfo.__init__(Display display, int window, int rootWindow, int properties, NET.Role role = NET.Client)'''
     def __init__(self, wininfo):
         '''void NETWinInfo.__init__(NETWinInfo wininfo)'''
     def isBlockingCompositing(self):
         '''bool NETWinInfo.isBlockingCompositing()'''
         return bool()
     def setBlockingCompositing(self, active):
         '''void NETWinInfo.setBlockingCompositing(bool active)'''
     def activities(self):
         '''str NETWinInfo.activities()'''
         return str()
     def frameOverlap(self):
         '''NETStrut NETWinInfo.frameOverlap()'''
         return NETStrut()
     def setFrameOverlap(self, strut):
         '''void NETWinInfo.setFrameOverlap(NETStrut strut)'''
     def changeState(self, state, mask):
         '''void NETWinInfo.changeState(int state, int mask)'''
     def changeDesktop(self, desktop):
         '''void NETWinInfo.changeDesktop(int desktop)'''
     def kdeGeometry(self, frame, window):
         '''void NETWinInfo.kdeGeometry(NETRect frame, NETRect window)'''
     def clientMachine(self):
         '''str NETWinInfo.clientMachine()'''
         return str()
     def windowRole(self):
         '''str NETWinInfo.windowRole()'''
         return str()
     def windowClassName(self):
         '''str NETWinInfo.windowClassName()'''
         return str()
     def windowClassClass(self):
         '''str NETWinInfo.windowClassClass()'''
         return str()
     def groupLeader(self):
         '''int NETWinInfo.groupLeader()'''
         return int()
     def transientFor(self):
         '''int NETWinInfo.transientFor()'''
         return int()
     def allowedActions(self):
         '''int NETWinInfo.allowedActions()'''
         return int()
     def setAllowedActions(self, actions):
         '''void NETWinInfo.setAllowedActions(int actions)'''
     def opacity(self):
         '''int NETWinInfo.opacity()'''
         return int()
     def setOpacity(self, opacity):
         '''void NETWinInfo.setOpacity(int opacity)'''
     def startupId(self):
         '''str NETWinInfo.startupId()'''
         return str()
     def setStartupId(self, startup_id):
         '''void NETWinInfo.setStartupId(str startup_id)'''
     def userTime(self):
         '''int NETWinInfo.userTime()'''
         return int()
     def setUserTime(self, time):
         '''void NETWinInfo.setUserTime(int time)'''
     def setFrameExtents(self, strut):
         '''void NETWinInfo.setFrameExtents(NETStrut strut)'''
     def setHandledIcons(self, handled):
         '''void NETWinInfo.setHandledIcons(bool handled)'''
     def setPid(self, pid):
         '''void NETWinInfo.setPid(int pid)'''
     def setDesktop(self, desktop, ignore_viewport = False):
         '''void NETWinInfo.setDesktop(int desktop, bool ignore_viewport = False)'''
     def setVisibleIconName(self, name):
         '''void NETWinInfo.setVisibleIconName(str name)'''
     def setIconName(self, name):
         '''void NETWinInfo.setIconName(str name)'''
     def setVisibleName(self, visibleName):
         '''void NETWinInfo.setVisibleName(str visibleName)'''
     def setName(self, name):
         '''void NETWinInfo.setName(str name)'''
     def setWindowType(self, type):
         '''void NETWinInfo.setWindowType(NET.WindowType type)'''
     def setState(self, state, mask):
         '''void NETWinInfo.setState(int state, int mask)'''
     def setStrut(self, strut):
         '''void NETWinInfo.setStrut(NETStrut strut)'''
     def setExtendedStrut(self, extended_strut):
         '''void NETWinInfo.setExtendedStrut(NETExtendedStrut extended_strut)'''
     def setIconGeometry(self, geometry):
         '''void NETWinInfo.setIconGeometry(NETRect geometry)'''
     def mappingState(self):
         '''NET.MappingState NETWinInfo.mappingState()'''
         return NET.MappingState()
     def handledIcons(self):
         '''bool NETWinInfo.handledIcons()'''
         return bool()
     def pid(self):
         '''int NETWinInfo.pid()'''
         return int()
     def desktop(self, ignore_viewport = False):
         '''int NETWinInfo.desktop(bool ignore_viewport = False)'''
         return int()
     def visibleIconName(self):
         '''str NETWinInfo.visibleIconName()'''
         return str()
     def iconName(self):
         '''str NETWinInfo.iconName()'''
         return str()
     def visibleName(self):
         '''str NETWinInfo.visibleName()'''
         return str()
     def name(self):
         '''str NETWinInfo.name()'''
         return str()
     def hasWindowType(self):
         '''bool NETWinInfo.hasWindowType()'''
         return bool()
     def windowType(self, supported_types):
         '''NET.WindowType NETWinInfo.windowType(int supported_types)'''
         return NET.WindowType()
     def strut(self):
         '''NETStrut NETWinInfo.strut()'''
         return NETStrut()
     def extendedStrut(self):
         '''NETExtendedStrut NETWinInfo.extendedStrut()'''
         return NETExtendedStrut()
     def state(self):
         '''int NETWinInfo.state()'''
         return int()
     def iconGeometry(self):
         '''NETRect NETWinInfo.iconGeometry()'''
         return NETRect()
     def hasNETSupport(self):
         '''bool NETWinInfo.hasNETSupport()'''
         return bool()
 
 
 class NETPoint():
     """"""
     x = None # int - member
     y = None # int - member
     def __init__(self):
         '''void NETPoint.__init__()'''
     def __init__(self):
         '''NETPoint NETPoint.__init__()'''
         return NETPoint()
 
 
 class NETSize():
     """"""
     height = None # int - member
     width = None # int - member
     def __init__(self):
         '''void NETSize.__init__()'''
     def __init__(self):
         '''NETSize NETSize.__init__()'''
         return NETSize()
 
 
 class NETRect():
     """"""
     pos = None # NETPoint - member
     size = None # NETSize - member
     def __init__(self):
         '''void NETRect.__init__()'''
     def __init__(self):
         '''NETRect NETRect.__init__()'''
         return NETRect()
 
 
 class NETIcon():
     """"""
     data = None # str - member
     size = None # NETSize - member
     def __init__(self):
         '''void NETIcon.__init__()'''
     def __init__(self):
         '''NETIcon NETIcon.__init__()'''
         return NETIcon()
 
 
 class NETExtendedStrut():
     """"""
     bottom_end = None # int - member
     bottom_start = None # int - member
     bottom_width = None # int - member
     left_end = None # int - member
     left_start = None # int - member
     left_width = None # int - member
     right_end = None # int - member
     right_start = None # int - member
     right_width = None # int - member
     top_end = None # int - member
     top_start = None # int - member
     top_width = None # int - member
     def __init__(self):
         '''void NETExtendedStrut.__init__()'''
     def __init__(self):
         '''NETExtendedStrut NETExtendedStrut.__init__()'''
         return NETExtendedStrut()
 
 
 class NETStrut():
     """"""
     bottom = None # int - member
     left = None # int - member
     right = None # int - member
     top = None # int - member
     def __init__(self):
         '''void NETStrut.__init__()'''
     def __init__(self):
         '''NETStrut NETStrut.__init__()'''
         return NETStrut()
 
 
 class NETFullscreenMonitors():
     """"""
     bottom = None # int - member
     left = None # int - member
     right = None # int - member
     top = None # int - member
     def __init__(self):
         '''void NETFullscreenMonitors.__init__()'''
     def __init__(self):
         '''NETFullscreenMonitors NETFullscreenMonitors.__init__()'''
         return NETFullscreenMonitors()
     def isSet(self):
         '''bool NETFullscreenMonitors.isSet()'''
         return bool()
 
 
 class Sonnet():
     """"""
     class ConfigWidget(QWidget):
         """"""
         def __init__(self, config, parent):
             '''void Sonnet.ConfigWidget.__init__(KConfig config, QWidget parent)'''
         configChanged = pyqtSignal() # void configChanged() - signal
         def slotChanged(self):
             '''void Sonnet.ConfigWidget.slotChanged()'''
         def slotDefault(self):
             '''void Sonnet.ConfigWidget.slotDefault()'''
         def setBackgroundCheckingButtonShown(self):
             '''bool Sonnet.ConfigWidget.setBackgroundCheckingButtonShown()'''
             return bool()
         def save(self):
             '''void Sonnet.ConfigWidget.save()'''
         def language(self):
             '''QString Sonnet.ConfigWidget.language()'''
             return QString()
         def setLanguage(self, language):
             '''void Sonnet.ConfigWidget.setLanguage(QString language)'''
         def backgroundCheckingButtonShown(self):
             '''bool Sonnet.ConfigWidget.backgroundCheckingButtonShown()'''
             return bool()
     class Dialog(KDialog):
         """"""
         def __init__(self, checker, parent):
             '''void Sonnet.Dialog.__init__(Sonnet.BackgroundChecker checker, QWidget parent)'''
         def setSpellCheckContinuedAfterReplacement(self, b):
             '''void Sonnet.Dialog.setSpellCheckContinuedAfterReplacement(bool b)'''
         def showSpellCheckCompletionMessage(self, b = True):
             '''void Sonnet.Dialog.showSpellCheckCompletionMessage(bool b = True)'''
         def showProgressDialog(self, timeout = 500):
             '''void Sonnet.Dialog.showProgressDialog(int timeout = 500)'''
         languageChanged = pyqtSignal() # void languageChanged(const QStringamp;) - signal
         spellCheckStatus = pyqtSignal() # void spellCheckStatus(const QStringamp;) - signal
         autoCorrect = pyqtSignal() # void autoCorrect(const QStringamp;,const QStringamp;) - signal
         cancel = pyqtSignal() # void cancel() - signal
         stop = pyqtSignal() # void stop() - signal
         replace = pyqtSignal() # void replace(const QStringamp;,int,const QStringamp;) - signal
         misspelling = pyqtSignal() # void misspelling(const QStringamp;,int) - signal
         done = pyqtSignal() # void done(const QStringamp;) - signal
         def setBuffer(self):
             '''QString Sonnet.Dialog.setBuffer()'''
             return QString()
         def activeAutoCorrect(self, _active):
             '''void Sonnet.Dialog.activeAutoCorrect(bool _active)'''
         def show(self):
             '''void Sonnet.Dialog.show()'''
         def buffer(self):
             '''QString Sonnet.Dialog.buffer()'''
             return QString()
         def originalBuffer(self):
             '''QString Sonnet.Dialog.originalBuffer()'''
             return QString()
     class ConfigDialog(KDialog):
         """"""
         def __init__(self, config, parent):
             '''void Sonnet.ConfigDialog.__init__(KConfig config, QWidget parent)'''
         configChanged = pyqtSignal() # void configChanged() - signal
         def language(self):
             '''QString Sonnet.ConfigDialog.language()'''
             return QString()
         languageChanged = pyqtSignal() # void languageChanged(const QStringamp;) - signal
         def slotApply(self):
             '''void Sonnet.ConfigDialog.slotApply()'''
         def slotOk(self):
             '''void Sonnet.ConfigDialog.slotOk()'''
         def setLanguage(self, language):
             '''void Sonnet.ConfigDialog.setLanguage(QString language)'''
     class DictionaryComboBox(KComboBox):
         """"""
         def __init__(self, parent = None):
             '''void Sonnet.DictionaryComboBox.__init__(QWidget parent = None)'''
         dictionaryNameChanged = pyqtSignal() # void dictionaryNameChanged(const QStringamp;) - signal
         dictionaryChanged = pyqtSignal() # void dictionaryChanged(const QStringamp;) - signal
         def setCurrentByDictionary(self, dictionary):
             '''void Sonnet.DictionaryComboBox.setCurrentByDictionary(QString dictionary)'''
         def setCurrentByDictionaryName(self, dictionaryName):
             '''void Sonnet.DictionaryComboBox.setCurrentByDictionaryName(QString dictionaryName)'''
         def currentDictionary(self):
             '''QString Sonnet.DictionaryComboBox.currentDictionary()'''
             return QString()
         def currentDictionaryName(self):
             '''QString Sonnet.DictionaryComboBox.currentDictionaryName()'''
             return QString()
         def reloadCombo(self):
             '''void Sonnet.DictionaryComboBox.reloadCombo()'''
     class Highlighter(QSyntaxHighlighter):
         """"""
         def __init__(self, textEdit, configFile = QString(), col = QColor()):
             '''void Sonnet.Highlighter.__init__(QTextEdit textEdit, QString configFile = QString(), QColor col = QColor())'''
         def checkerEnabledByDefault(self):
             '''bool Sonnet.Highlighter.checkerEnabledByDefault()'''
             return bool()
         def slotRehighlight(self):
             '''void Sonnet.Highlighter.slotRehighlight()'''
         def slotAutoDetection(self):
             '''void Sonnet.Highlighter.slotAutoDetection()'''
         def setIntraWordEditing(self, editing):
             '''void Sonnet.Highlighter.setIntraWordEditing(bool editing)'''
         def intraWordEditing(self):
             '''bool Sonnet.Highlighter.intraWordEditing()'''
             return bool()
         def eventFilter(self, o, e):
             '''bool Sonnet.Highlighter.eventFilter(QObject o, QEvent e)'''
             return bool()
         def unsetMisspelled(self, start, count):
             '''void Sonnet.Highlighter.unsetMisspelled(int start, int count)'''
         def setMisspelled(self, start, count):
             '''void Sonnet.Highlighter.setMisspelled(int start, int count)'''
         def highlightBlock(self, text):
             '''void Sonnet.Highlighter.highlightBlock(QString text)'''
         newSuggestions = pyqtSignal() # void newSuggestions(const QStringamp;,const QStringListamp;) - signal
         activeChanged = pyqtSignal() # void activeChanged(const QStringamp;) - signal
         def setMisspelledColor(self, color):
             '''void Sonnet.Highlighter.setMisspelledColor(QColor color)'''
         def isWordMisspelled(self, word):
             '''bool Sonnet.Highlighter.isWordMisspelled(QString word)'''
             return bool()
         def suggestionsForWord(self, word, max = 10):
             '''QStringList Sonnet.Highlighter.suggestionsForWord(QString word, int max = 10)'''
             return QStringList()
         def ignoreWord(self, word):
             '''void Sonnet.Highlighter.ignoreWord(QString word)'''
         def addWordToDictionary(self, word):
             '''void Sonnet.Highlighter.addWordToDictionary(QString word)'''
         def setAutomatic(self, automatic):
             '''void Sonnet.Highlighter.setAutomatic(bool automatic)'''
         def automatic(self):
             '''bool Sonnet.Highlighter.automatic()'''
             return bool()
         def isActive(self):
             '''bool Sonnet.Highlighter.isActive()'''
             return bool()
         def setActive(self, active):
             '''void Sonnet.Highlighter.setActive(bool active)'''
         def personalWords(self):
             '''static QStringList Sonnet.Highlighter.personalWords()'''
             return QStringList()
         def setCurrentLanguage(self, lang):
             '''void Sonnet.Highlighter.setCurrentLanguage(QString lang)'''
         def currentLanguage(self):
             '''QString Sonnet.Highlighter.currentLanguage()'''
             return QString()
         def spellCheckerFound(self):
             '''bool Sonnet.Highlighter.spellCheckerFound()'''
             return bool()
 
 
 # Enum KColorChooserMode
 ChooserClassic = 0
 ChooserHue = 0
 ChooserSaturation = 0
 ChooserValue = 0
 ChooserRed = 0
 ChooserGreen = 0
 ChooserBlue = 0
 
 
 def UserIconSet(name):
     '''static QIcon UserIconSet(QString name)'''
     return QIcon()
 
 def UserIcon(name, state = None, overlays = QStringList()):
     '''static QPixmap UserIcon(QString name, int state = KIconLoader.DefaultState, QStringList overlays = QStringList())'''
     return QPixmap()
 
 def MainBarIconSet(name, size = 0):
     '''static QIcon MainBarIconSet(QString name, int size = 0)'''
     return QIcon()
 
 def MainBarIcon(name, size = 0, state = None, overlays = QStringList()):
     '''static QPixmap MainBarIcon(QString name, int size = 0, int state = KIconLoader.DefaultState, QStringList overlays = QStringList())'''
     return QPixmap()
 
 def SmallIconSet(name, size = 0):
     '''static QIcon SmallIconSet(QString name, int size = 0)'''
     return QIcon()
 
 def SmallIcon(name, size = 0, state = None, overlays = QStringList()):
     '''static QPixmap SmallIcon(QString name, int size = 0, int state = KIconLoader.DefaultState, QStringList overlays = QStringList())'''
     return QPixmap()
 
 def BarIconSet(name, size = 0):
     '''static QIcon BarIconSet(QString name, int size = 0)'''
     return QIcon()
 
 def BarIcon(name, size = 0, state = None, overlays = QStringList()):
     '''static QPixmap BarIcon(QString name, int size = 0, int state = KIconLoader.DefaultState, QStringList overlays = QStringList())'''
     return QPixmap()
 
 def DesktopIconSet(name, size = 0):
     '''static QIcon DesktopIconSet(QString name, int size = 0)'''
     return QIcon()
 
 def DesktopIcon(name, size = 0, state = None, overlays = QStringList()):
     '''static QPixmap DesktopIcon(QString name, int size = 0, int state = KIconLoader.DefaultState, QStringList overlays = QStringList())'''
     return QPixmap()
 
 def qHash(key):
     '''static int qHash(KShapeGesture key)'''
     return int()
 
 def qHash(key):
     '''static int qHash(KRockerGesture key)'''
     return int()
 
 def qHash():
     '''static int qHash()'''
     return int()
 
 def qHash(key):
     '''static int qHash(KShortcut key)'''
     return int()
 
 def qHash(key):
     '''static int qHash(QKeySequence key)'''
     return int()