# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.7
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.




"""
pyFltk, the Python bindings to the FLTK GUI toolkit.
This is an easy to use and light-weight GUI toolkit
offering basic capabilities for the creation of
graphical user interfaces.
"""


from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_fltk', [dirname(__file__)])
        except ImportError:
            import _fltk
            return _fltk
        if fp is not None:
            try:
                _mod = imp.load_module('_fltk', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _fltk = swig_import_helper()
    del swig_import_helper
else:
    import _fltk
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x



import sys
if sys.version > '3':
  print("Python2 required!")
  exit(1)


_fltk.FL_MAJOR_VERSION_swigconstant(_fltk)
FL_MAJOR_VERSION = _fltk.FL_MAJOR_VERSION

_fltk.FL_MINOR_VERSION_swigconstant(_fltk)
FL_MINOR_VERSION = _fltk.FL_MINOR_VERSION

_fltk.FL_PATCH_VERSION_swigconstant(_fltk)
FL_PATCH_VERSION = _fltk.FL_PATCH_VERSION

_fltk.FL_NO_EVENT_swigconstant(_fltk)
FL_NO_EVENT = _fltk.FL_NO_EVENT

_fltk.FL_PUSH_swigconstant(_fltk)
FL_PUSH = _fltk.FL_PUSH

_fltk.FL_RELEASE_swigconstant(_fltk)
FL_RELEASE = _fltk.FL_RELEASE

_fltk.FL_ENTER_swigconstant(_fltk)
FL_ENTER = _fltk.FL_ENTER

_fltk.FL_LEAVE_swigconstant(_fltk)
FL_LEAVE = _fltk.FL_LEAVE

_fltk.FL_DRAG_swigconstant(_fltk)
FL_DRAG = _fltk.FL_DRAG

_fltk.FL_FOCUS_swigconstant(_fltk)
FL_FOCUS = _fltk.FL_FOCUS

_fltk.FL_UNFOCUS_swigconstant(_fltk)
FL_UNFOCUS = _fltk.FL_UNFOCUS

_fltk.FL_KEYDOWN_swigconstant(_fltk)
FL_KEYDOWN = _fltk.FL_KEYDOWN

_fltk.FL_KEYBOARD_swigconstant(_fltk)
FL_KEYBOARD = _fltk.FL_KEYBOARD

_fltk.FL_KEYUP_swigconstant(_fltk)
FL_KEYUP = _fltk.FL_KEYUP

_fltk.FL_CLOSE_swigconstant(_fltk)
FL_CLOSE = _fltk.FL_CLOSE

_fltk.FL_MOVE_swigconstant(_fltk)
FL_MOVE = _fltk.FL_MOVE

_fltk.FL_SHORTCUT_swigconstant(_fltk)
FL_SHORTCUT = _fltk.FL_SHORTCUT

_fltk.FL_DEACTIVATE_swigconstant(_fltk)
FL_DEACTIVATE = _fltk.FL_DEACTIVATE

_fltk.FL_ACTIVATE_swigconstant(_fltk)
FL_ACTIVATE = _fltk.FL_ACTIVATE

_fltk.FL_HIDE_swigconstant(_fltk)
FL_HIDE = _fltk.FL_HIDE

_fltk.FL_SHOW_swigconstant(_fltk)
FL_SHOW = _fltk.FL_SHOW

_fltk.FL_PASTE_swigconstant(_fltk)
FL_PASTE = _fltk.FL_PASTE

_fltk.FL_SELECTIONCLEAR_swigconstant(_fltk)
FL_SELECTIONCLEAR = _fltk.FL_SELECTIONCLEAR

_fltk.FL_MOUSEWHEEL_swigconstant(_fltk)
FL_MOUSEWHEEL = _fltk.FL_MOUSEWHEEL

_fltk.FL_DND_ENTER_swigconstant(_fltk)
FL_DND_ENTER = _fltk.FL_DND_ENTER

_fltk.FL_DND_DRAG_swigconstant(_fltk)
FL_DND_DRAG = _fltk.FL_DND_DRAG

_fltk.FL_DND_LEAVE_swigconstant(_fltk)
FL_DND_LEAVE = _fltk.FL_DND_LEAVE

_fltk.FL_DND_RELEASE_swigconstant(_fltk)
FL_DND_RELEASE = _fltk.FL_DND_RELEASE

_fltk.FL_SCREEN_CONFIGURATION_CHANGED_swigconstant(_fltk)
FL_SCREEN_CONFIGURATION_CHANGED = _fltk.FL_SCREEN_CONFIGURATION_CHANGED

_fltk.FL_FULLSCREEN_swigconstant(_fltk)
FL_FULLSCREEN = _fltk.FL_FULLSCREEN

_fltk.FL_WHEN_NEVER_swigconstant(_fltk)
FL_WHEN_NEVER = _fltk.FL_WHEN_NEVER

_fltk.FL_WHEN_CHANGED_swigconstant(_fltk)
FL_WHEN_CHANGED = _fltk.FL_WHEN_CHANGED

_fltk.FL_WHEN_NOT_CHANGED_swigconstant(_fltk)
FL_WHEN_NOT_CHANGED = _fltk.FL_WHEN_NOT_CHANGED

_fltk.FL_WHEN_RELEASE_swigconstant(_fltk)
FL_WHEN_RELEASE = _fltk.FL_WHEN_RELEASE

_fltk.FL_WHEN_RELEASE_ALWAYS_swigconstant(_fltk)
FL_WHEN_RELEASE_ALWAYS = _fltk.FL_WHEN_RELEASE_ALWAYS

_fltk.FL_WHEN_ENTER_KEY_swigconstant(_fltk)
FL_WHEN_ENTER_KEY = _fltk.FL_WHEN_ENTER_KEY

_fltk.FL_WHEN_ENTER_KEY_ALWAYS_swigconstant(_fltk)
FL_WHEN_ENTER_KEY_ALWAYS = _fltk.FL_WHEN_ENTER_KEY_ALWAYS

_fltk.FL_WHEN_ENTER_KEY_CHANGED_swigconstant(_fltk)
FL_WHEN_ENTER_KEY_CHANGED = _fltk.FL_WHEN_ENTER_KEY_CHANGED

_fltk.FL_Button_swigconstant(_fltk)
FL_Button = _fltk.FL_Button

_fltk.FL_BackSpace_swigconstant(_fltk)
FL_BackSpace = _fltk.FL_BackSpace

_fltk.FL_Tab_swigconstant(_fltk)
FL_Tab = _fltk.FL_Tab

_fltk.FL_Iso_Key_swigconstant(_fltk)
FL_Iso_Key = _fltk.FL_Iso_Key

_fltk.FL_Enter_swigconstant(_fltk)
FL_Enter = _fltk.FL_Enter

_fltk.FL_Pause_swigconstant(_fltk)
FL_Pause = _fltk.FL_Pause

_fltk.FL_Scroll_Lock_swigconstant(_fltk)
FL_Scroll_Lock = _fltk.FL_Scroll_Lock

_fltk.FL_Escape_swigconstant(_fltk)
FL_Escape = _fltk.FL_Escape

_fltk.FL_Kana_swigconstant(_fltk)
FL_Kana = _fltk.FL_Kana

_fltk.FL_Eisu_swigconstant(_fltk)
FL_Eisu = _fltk.FL_Eisu

_fltk.FL_Yen_swigconstant(_fltk)
FL_Yen = _fltk.FL_Yen

_fltk.FL_JIS_Underscore_swigconstant(_fltk)
FL_JIS_Underscore = _fltk.FL_JIS_Underscore

_fltk.FL_Home_swigconstant(_fltk)
FL_Home = _fltk.FL_Home

_fltk.FL_Left_swigconstant(_fltk)
FL_Left = _fltk.FL_Left

_fltk.FL_Up_swigconstant(_fltk)
FL_Up = _fltk.FL_Up

_fltk.FL_Right_swigconstant(_fltk)
FL_Right = _fltk.FL_Right

_fltk.FL_Down_swigconstant(_fltk)
FL_Down = _fltk.FL_Down

_fltk.FL_Page_Up_swigconstant(_fltk)
FL_Page_Up = _fltk.FL_Page_Up

_fltk.FL_Page_Down_swigconstant(_fltk)
FL_Page_Down = _fltk.FL_Page_Down

_fltk.FL_End_swigconstant(_fltk)
FL_End = _fltk.FL_End

_fltk.FL_Print_swigconstant(_fltk)
FL_Print = _fltk.FL_Print

_fltk.FL_Insert_swigconstant(_fltk)
FL_Insert = _fltk.FL_Insert

_fltk.FL_Menu_swigconstant(_fltk)
FL_Menu = _fltk.FL_Menu

_fltk.FL_Help_swigconstant(_fltk)
FL_Help = _fltk.FL_Help

_fltk.FL_Num_Lock_swigconstant(_fltk)
FL_Num_Lock = _fltk.FL_Num_Lock

_fltk.FL_KP_swigconstant(_fltk)
FL_KP = _fltk.FL_KP

_fltk.FL_KP_Enter_swigconstant(_fltk)
FL_KP_Enter = _fltk.FL_KP_Enter

_fltk.FL_KP_Last_swigconstant(_fltk)
FL_KP_Last = _fltk.FL_KP_Last

_fltk.FL_F_swigconstant(_fltk)
FL_F = _fltk.FL_F

_fltk.FL_F_Last_swigconstant(_fltk)
FL_F_Last = _fltk.FL_F_Last

_fltk.FL_Shift_L_swigconstant(_fltk)
FL_Shift_L = _fltk.FL_Shift_L

_fltk.FL_Shift_R_swigconstant(_fltk)
FL_Shift_R = _fltk.FL_Shift_R

_fltk.FL_Control_L_swigconstant(_fltk)
FL_Control_L = _fltk.FL_Control_L

_fltk.FL_Control_R_swigconstant(_fltk)
FL_Control_R = _fltk.FL_Control_R

_fltk.FL_Caps_Lock_swigconstant(_fltk)
FL_Caps_Lock = _fltk.FL_Caps_Lock

_fltk.FL_Meta_L_swigconstant(_fltk)
FL_Meta_L = _fltk.FL_Meta_L

_fltk.FL_Meta_R_swigconstant(_fltk)
FL_Meta_R = _fltk.FL_Meta_R

_fltk.FL_Alt_L_swigconstant(_fltk)
FL_Alt_L = _fltk.FL_Alt_L

_fltk.FL_Alt_R_swigconstant(_fltk)
FL_Alt_R = _fltk.FL_Alt_R

_fltk.FL_Delete_swigconstant(_fltk)
FL_Delete = _fltk.FL_Delete

_fltk.FL_Volume_Down_swigconstant(_fltk)
FL_Volume_Down = _fltk.FL_Volume_Down

_fltk.FL_Volume_Mute_swigconstant(_fltk)
FL_Volume_Mute = _fltk.FL_Volume_Mute

_fltk.FL_Volume_Up_swigconstant(_fltk)
FL_Volume_Up = _fltk.FL_Volume_Up

_fltk.FL_Media_Play_swigconstant(_fltk)
FL_Media_Play = _fltk.FL_Media_Play

_fltk.FL_Media_Stop_swigconstant(_fltk)
FL_Media_Stop = _fltk.FL_Media_Stop

_fltk.FL_Media_Prev_swigconstant(_fltk)
FL_Media_Prev = _fltk.FL_Media_Prev

_fltk.FL_Media_Next_swigconstant(_fltk)
FL_Media_Next = _fltk.FL_Media_Next

_fltk.FL_Home_Page_swigconstant(_fltk)
FL_Home_Page = _fltk.FL_Home_Page

_fltk.FL_Mail_swigconstant(_fltk)
FL_Mail = _fltk.FL_Mail

_fltk.FL_Search_swigconstant(_fltk)
FL_Search = _fltk.FL_Search

_fltk.FL_Back_swigconstant(_fltk)
FL_Back = _fltk.FL_Back

_fltk.FL_Forward_swigconstant(_fltk)
FL_Forward = _fltk.FL_Forward

_fltk.FL_Stop_swigconstant(_fltk)
FL_Stop = _fltk.FL_Stop

_fltk.FL_Refresh_swigconstant(_fltk)
FL_Refresh = _fltk.FL_Refresh

_fltk.FL_Sleep_swigconstant(_fltk)
FL_Sleep = _fltk.FL_Sleep

_fltk.FL_Favorites_swigconstant(_fltk)
FL_Favorites = _fltk.FL_Favorites

_fltk.FL_LEFT_MOUSE_swigconstant(_fltk)
FL_LEFT_MOUSE = _fltk.FL_LEFT_MOUSE

_fltk.FL_MIDDLE_MOUSE_swigconstant(_fltk)
FL_MIDDLE_MOUSE = _fltk.FL_MIDDLE_MOUSE

_fltk.FL_RIGHT_MOUSE_swigconstant(_fltk)
FL_RIGHT_MOUSE = _fltk.FL_RIGHT_MOUSE

_fltk.FL_SHIFT_swigconstant(_fltk)
FL_SHIFT = _fltk.FL_SHIFT

_fltk.FL_CAPS_LOCK_swigconstant(_fltk)
FL_CAPS_LOCK = _fltk.FL_CAPS_LOCK

_fltk.FL_CTRL_swigconstant(_fltk)
FL_CTRL = _fltk.FL_CTRL

_fltk.FL_ALT_swigconstant(_fltk)
FL_ALT = _fltk.FL_ALT

_fltk.FL_NUM_LOCK_swigconstant(_fltk)
FL_NUM_LOCK = _fltk.FL_NUM_LOCK

_fltk.FL_META_swigconstant(_fltk)
FL_META = _fltk.FL_META

_fltk.FL_SCROLL_LOCK_swigconstant(_fltk)
FL_SCROLL_LOCK = _fltk.FL_SCROLL_LOCK

_fltk.FL_BUTTON1_swigconstant(_fltk)
FL_BUTTON1 = _fltk.FL_BUTTON1

_fltk.FL_BUTTON2_swigconstant(_fltk)
FL_BUTTON2 = _fltk.FL_BUTTON2

_fltk.FL_BUTTON3_swigconstant(_fltk)
FL_BUTTON3 = _fltk.FL_BUTTON3

_fltk.FL_BUTTONS_swigconstant(_fltk)
FL_BUTTONS = _fltk.FL_BUTTONS

_fltk.FL_KEY_MASK_swigconstant(_fltk)
FL_KEY_MASK = _fltk.FL_KEY_MASK

_fltk.FL_COMMAND_swigconstant(_fltk)
FL_COMMAND = _fltk.FL_COMMAND

_fltk.FL_CONTROL_swigconstant(_fltk)
FL_CONTROL = _fltk.FL_CONTROL

_fltk.FL_NO_BOX_swigconstant(_fltk)
FL_NO_BOX = _fltk.FL_NO_BOX

_fltk.FL_FLAT_BOX_swigconstant(_fltk)
FL_FLAT_BOX = _fltk.FL_FLAT_BOX

_fltk.FL_UP_BOX_swigconstant(_fltk)
FL_UP_BOX = _fltk.FL_UP_BOX

_fltk.FL_DOWN_BOX_swigconstant(_fltk)
FL_DOWN_BOX = _fltk.FL_DOWN_BOX

_fltk.FL_UP_FRAME_swigconstant(_fltk)
FL_UP_FRAME = _fltk.FL_UP_FRAME

_fltk.FL_DOWN_FRAME_swigconstant(_fltk)
FL_DOWN_FRAME = _fltk.FL_DOWN_FRAME

_fltk.FL_THIN_UP_BOX_swigconstant(_fltk)
FL_THIN_UP_BOX = _fltk.FL_THIN_UP_BOX

_fltk.FL_THIN_DOWN_BOX_swigconstant(_fltk)
FL_THIN_DOWN_BOX = _fltk.FL_THIN_DOWN_BOX

_fltk.FL_THIN_UP_FRAME_swigconstant(_fltk)
FL_THIN_UP_FRAME = _fltk.FL_THIN_UP_FRAME

_fltk.FL_THIN_DOWN_FRAME_swigconstant(_fltk)
FL_THIN_DOWN_FRAME = _fltk.FL_THIN_DOWN_FRAME

_fltk.FL_ENGRAVED_BOX_swigconstant(_fltk)
FL_ENGRAVED_BOX = _fltk.FL_ENGRAVED_BOX

_fltk.FL_EMBOSSED_BOX_swigconstant(_fltk)
FL_EMBOSSED_BOX = _fltk.FL_EMBOSSED_BOX

_fltk.FL_ENGRAVED_FRAME_swigconstant(_fltk)
FL_ENGRAVED_FRAME = _fltk.FL_ENGRAVED_FRAME

_fltk.FL_EMBOSSED_FRAME_swigconstant(_fltk)
FL_EMBOSSED_FRAME = _fltk.FL_EMBOSSED_FRAME

_fltk.FL_BORDER_BOX_swigconstant(_fltk)
FL_BORDER_BOX = _fltk.FL_BORDER_BOX

_fltk._FL_SHADOW_BOX_swigconstant(_fltk)
_FL_SHADOW_BOX = _fltk._FL_SHADOW_BOX

_fltk.FL_BORDER_FRAME_swigconstant(_fltk)
FL_BORDER_FRAME = _fltk.FL_BORDER_FRAME

_fltk._FL_SHADOW_FRAME_swigconstant(_fltk)
_FL_SHADOW_FRAME = _fltk._FL_SHADOW_FRAME

_fltk._FL_ROUNDED_BOX_swigconstant(_fltk)
_FL_ROUNDED_BOX = _fltk._FL_ROUNDED_BOX

_fltk._FL_RSHADOW_BOX_swigconstant(_fltk)
_FL_RSHADOW_BOX = _fltk._FL_RSHADOW_BOX

_fltk._FL_ROUNDED_FRAME_swigconstant(_fltk)
_FL_ROUNDED_FRAME = _fltk._FL_ROUNDED_FRAME

_fltk._FL_RFLAT_BOX_swigconstant(_fltk)
_FL_RFLAT_BOX = _fltk._FL_RFLAT_BOX

_fltk._FL_ROUND_UP_BOX_swigconstant(_fltk)
_FL_ROUND_UP_BOX = _fltk._FL_ROUND_UP_BOX

_fltk._FL_ROUND_DOWN_BOX_swigconstant(_fltk)
_FL_ROUND_DOWN_BOX = _fltk._FL_ROUND_DOWN_BOX

_fltk._FL_DIAMOND_UP_BOX_swigconstant(_fltk)
_FL_DIAMOND_UP_BOX = _fltk._FL_DIAMOND_UP_BOX

_fltk._FL_DIAMOND_DOWN_BOX_swigconstant(_fltk)
_FL_DIAMOND_DOWN_BOX = _fltk._FL_DIAMOND_DOWN_BOX

_fltk._FL_OVAL_BOX_swigconstant(_fltk)
_FL_OVAL_BOX = _fltk._FL_OVAL_BOX

_fltk._FL_OSHADOW_BOX_swigconstant(_fltk)
_FL_OSHADOW_BOX = _fltk._FL_OSHADOW_BOX

_fltk._FL_OVAL_FRAME_swigconstant(_fltk)
_FL_OVAL_FRAME = _fltk._FL_OVAL_FRAME

_fltk._FL_OFLAT_BOX_swigconstant(_fltk)
_FL_OFLAT_BOX = _fltk._FL_OFLAT_BOX

_fltk._FL_PLASTIC_UP_BOX_swigconstant(_fltk)
_FL_PLASTIC_UP_BOX = _fltk._FL_PLASTIC_UP_BOX

_fltk._FL_PLASTIC_DOWN_BOX_swigconstant(_fltk)
_FL_PLASTIC_DOWN_BOX = _fltk._FL_PLASTIC_DOWN_BOX

_fltk._FL_PLASTIC_UP_FRAME_swigconstant(_fltk)
_FL_PLASTIC_UP_FRAME = _fltk._FL_PLASTIC_UP_FRAME

_fltk._FL_PLASTIC_DOWN_FRAME_swigconstant(_fltk)
_FL_PLASTIC_DOWN_FRAME = _fltk._FL_PLASTIC_DOWN_FRAME

_fltk._FL_PLASTIC_THIN_UP_BOX_swigconstant(_fltk)
_FL_PLASTIC_THIN_UP_BOX = _fltk._FL_PLASTIC_THIN_UP_BOX

_fltk._FL_PLASTIC_THIN_DOWN_BOX_swigconstant(_fltk)
_FL_PLASTIC_THIN_DOWN_BOX = _fltk._FL_PLASTIC_THIN_DOWN_BOX

_fltk._FL_PLASTIC_ROUND_UP_BOX_swigconstant(_fltk)
_FL_PLASTIC_ROUND_UP_BOX = _fltk._FL_PLASTIC_ROUND_UP_BOX

_fltk._FL_PLASTIC_ROUND_DOWN_BOX_swigconstant(_fltk)
_FL_PLASTIC_ROUND_DOWN_BOX = _fltk._FL_PLASTIC_ROUND_DOWN_BOX

_fltk._FL_GTK_UP_BOX_swigconstant(_fltk)
_FL_GTK_UP_BOX = _fltk._FL_GTK_UP_BOX

_fltk._FL_GTK_DOWN_BOX_swigconstant(_fltk)
_FL_GTK_DOWN_BOX = _fltk._FL_GTK_DOWN_BOX

_fltk._FL_GTK_UP_FRAME_swigconstant(_fltk)
_FL_GTK_UP_FRAME = _fltk._FL_GTK_UP_FRAME

_fltk._FL_GTK_DOWN_FRAME_swigconstant(_fltk)
_FL_GTK_DOWN_FRAME = _fltk._FL_GTK_DOWN_FRAME

_fltk._FL_GTK_THIN_UP_BOX_swigconstant(_fltk)
_FL_GTK_THIN_UP_BOX = _fltk._FL_GTK_THIN_UP_BOX

_fltk._FL_GTK_THIN_DOWN_BOX_swigconstant(_fltk)
_FL_GTK_THIN_DOWN_BOX = _fltk._FL_GTK_THIN_DOWN_BOX

_fltk._FL_GTK_THIN_UP_FRAME_swigconstant(_fltk)
_FL_GTK_THIN_UP_FRAME = _fltk._FL_GTK_THIN_UP_FRAME

_fltk._FL_GTK_THIN_DOWN_FRAME_swigconstant(_fltk)
_FL_GTK_THIN_DOWN_FRAME = _fltk._FL_GTK_THIN_DOWN_FRAME

_fltk._FL_GTK_ROUND_UP_BOX_swigconstant(_fltk)
_FL_GTK_ROUND_UP_BOX = _fltk._FL_GTK_ROUND_UP_BOX

_fltk._FL_GTK_ROUND_DOWN_BOX_swigconstant(_fltk)
_FL_GTK_ROUND_DOWN_BOX = _fltk._FL_GTK_ROUND_DOWN_BOX

_fltk._FL_GLEAM_UP_BOX_swigconstant(_fltk)
_FL_GLEAM_UP_BOX = _fltk._FL_GLEAM_UP_BOX

_fltk._FL_GLEAM_DOWN_BOX_swigconstant(_fltk)
_FL_GLEAM_DOWN_BOX = _fltk._FL_GLEAM_DOWN_BOX

_fltk._FL_GLEAM_UP_FRAME_swigconstant(_fltk)
_FL_GLEAM_UP_FRAME = _fltk._FL_GLEAM_UP_FRAME

_fltk._FL_GLEAM_DOWN_FRAME_swigconstant(_fltk)
_FL_GLEAM_DOWN_FRAME = _fltk._FL_GLEAM_DOWN_FRAME

_fltk._FL_GLEAM_THIN_UP_BOX_swigconstant(_fltk)
_FL_GLEAM_THIN_UP_BOX = _fltk._FL_GLEAM_THIN_UP_BOX

_fltk._FL_GLEAM_THIN_DOWN_BOX_swigconstant(_fltk)
_FL_GLEAM_THIN_DOWN_BOX = _fltk._FL_GLEAM_THIN_DOWN_BOX

_fltk._FL_GLEAM_ROUND_UP_BOX_swigconstant(_fltk)
_FL_GLEAM_ROUND_UP_BOX = _fltk._FL_GLEAM_ROUND_UP_BOX

_fltk._FL_GLEAM_ROUND_DOWN_BOX_swigconstant(_fltk)
_FL_GLEAM_ROUND_DOWN_BOX = _fltk._FL_GLEAM_ROUND_DOWN_BOX

_fltk.FL_FREE_BOXTYPE_swigconstant(_fltk)
FL_FREE_BOXTYPE = _fltk.FL_FREE_BOXTYPE

def fl_define_FL_ROUND_UP_BOX(*args):
    """fl_define_FL_ROUND_UP_BOX() -> Fl_Boxtype"""
    return _fltk.fl_define_FL_ROUND_UP_BOX(*args)

def fl_define_FL_SHADOW_BOX(*args):
    """fl_define_FL_SHADOW_BOX() -> Fl_Boxtype"""
    return _fltk.fl_define_FL_SHADOW_BOX(*args)

def fl_define_FL_ROUNDED_BOX(*args):
    """fl_define_FL_ROUNDED_BOX() -> Fl_Boxtype"""
    return _fltk.fl_define_FL_ROUNDED_BOX(*args)

def fl_define_FL_RFLAT_BOX(*args):
    """fl_define_FL_RFLAT_BOX() -> Fl_Boxtype"""
    return _fltk.fl_define_FL_RFLAT_BOX(*args)

def fl_define_FL_RSHADOW_BOX(*args):
    """fl_define_FL_RSHADOW_BOX() -> Fl_Boxtype"""
    return _fltk.fl_define_FL_RSHADOW_BOX(*args)

def fl_define_FL_DIAMOND_BOX(*args):
    """fl_define_FL_DIAMOND_BOX() -> Fl_Boxtype"""
    return _fltk.fl_define_FL_DIAMOND_BOX(*args)

def fl_define_FL_OVAL_BOX(*args):
    """fl_define_FL_OVAL_BOX() -> Fl_Boxtype"""
    return _fltk.fl_define_FL_OVAL_BOX(*args)

def fl_define_FL_PLASTIC_UP_BOX(*args):
    """fl_define_FL_PLASTIC_UP_BOX() -> Fl_Boxtype"""
    return _fltk.fl_define_FL_PLASTIC_UP_BOX(*args)

def fl_define_FL_GTK_UP_BOX(*args):
    """fl_define_FL_GTK_UP_BOX() -> Fl_Boxtype"""
    return _fltk.fl_define_FL_GTK_UP_BOX(*args)

def fl_define_FL_GLEAM_UP_BOX(*args):
    """fl_define_FL_GLEAM_UP_BOX() -> Fl_Boxtype"""
    return _fltk.fl_define_FL_GLEAM_UP_BOX(*args)

def fl_box(*args):
    """fl_box(Fl_Boxtype b) -> Fl_Boxtype"""
    return _fltk.fl_box(*args)

def fl_down(*args):
    """fl_down(Fl_Boxtype b) -> Fl_Boxtype"""
    return _fltk.fl_down(*args)

_fltk.FL_NORMAL_LABEL_swigconstant(_fltk)
FL_NORMAL_LABEL = _fltk.FL_NORMAL_LABEL

_fltk.FL_NO_LABEL_swigconstant(_fltk)
FL_NO_LABEL = _fltk.FL_NO_LABEL

_fltk._FL_SHADOW_LABEL_swigconstant(_fltk)
_FL_SHADOW_LABEL = _fltk._FL_SHADOW_LABEL

_fltk._FL_ENGRAVED_LABEL_swigconstant(_fltk)
_FL_ENGRAVED_LABEL = _fltk._FL_ENGRAVED_LABEL

_fltk._FL_EMBOSSED_LABEL_swigconstant(_fltk)
_FL_EMBOSSED_LABEL = _fltk._FL_EMBOSSED_LABEL

_fltk._FL_MULTI_LABEL_swigconstant(_fltk)
_FL_MULTI_LABEL = _fltk._FL_MULTI_LABEL

_fltk._FL_ICON_LABEL_swigconstant(_fltk)
_FL_ICON_LABEL = _fltk._FL_ICON_LABEL

_fltk._FL_IMAGE_LABEL_swigconstant(_fltk)
_FL_IMAGE_LABEL = _fltk._FL_IMAGE_LABEL

_fltk.FL_FREE_LABELTYPE_swigconstant(_fltk)
FL_FREE_LABELTYPE = _fltk.FL_FREE_LABELTYPE

def fl_define_FL_SHADOW_LABEL(*args):
    """fl_define_FL_SHADOW_LABEL() -> Fl_Labeltype"""
    return _fltk.fl_define_FL_SHADOW_LABEL(*args)

def fl_define_FL_ENGRAVED_LABEL(*args):
    """fl_define_FL_ENGRAVED_LABEL() -> Fl_Labeltype"""
    return _fltk.fl_define_FL_ENGRAVED_LABEL(*args)

def fl_define_FL_EMBOSSED_LABEL(*args):
    """fl_define_FL_EMBOSSED_LABEL() -> Fl_Labeltype"""
    return _fltk.fl_define_FL_EMBOSSED_LABEL(*args)

_fltk.FL_NUM_FREE_COLOR_swigconstant(_fltk)
FL_NUM_FREE_COLOR = _fltk.FL_NUM_FREE_COLOR

_fltk.FL_NUM_GRAY_swigconstant(_fltk)
FL_NUM_GRAY = _fltk.FL_NUM_GRAY

_fltk.FL_NUM_RED_swigconstant(_fltk)
FL_NUM_RED = _fltk.FL_NUM_RED

_fltk.FL_NUM_GREEN_swigconstant(_fltk)
FL_NUM_GREEN = _fltk.FL_NUM_GREEN

_fltk.FL_NUM_BLUE_swigconstant(_fltk)
FL_NUM_BLUE = _fltk.FL_NUM_BLUE

def fl_inactive(*args):
    """fl_inactive(Fl_Color c) -> Fl_Color"""
    return _fltk.fl_inactive(*args)

def fl_contrast(*args):
    """fl_contrast(Fl_Color fg, Fl_Color bg) -> Fl_Color"""
    return _fltk.fl_contrast(*args)

def fl_color_average(*args):
    """fl_color_average(Fl_Color c1, Fl_Color c2, float weight) -> Fl_Color"""
    return _fltk.fl_color_average(*args)

def fl_lighter(*args):
    """fl_lighter(Fl_Color c) -> Fl_Color"""
    return _fltk.fl_lighter(*args)

def fl_darker(*args):
    """fl_darker(Fl_Color c) -> Fl_Color"""
    return _fltk.fl_darker(*args)

def fl_rgb_color(*args):
    """
    fl_rgb_color(uchar r, uchar g, uchar b) -> Fl_Color
    fl_rgb_color(uchar g) -> Fl_Color
    """
    return _fltk.fl_rgb_color(*args)

def fl_gray_ramp(*args):
    """fl_gray_ramp(int i) -> Fl_Color"""
    return _fltk.fl_gray_ramp(*args)

def fl_color_cube(*args):
    """fl_color_cube(int r, int g, int b) -> Fl_Color"""
    return _fltk.fl_color_cube(*args)

_fltk.FL_CURSOR_DEFAULT_swigconstant(_fltk)
FL_CURSOR_DEFAULT = _fltk.FL_CURSOR_DEFAULT

_fltk.FL_CURSOR_ARROW_swigconstant(_fltk)
FL_CURSOR_ARROW = _fltk.FL_CURSOR_ARROW

_fltk.FL_CURSOR_CROSS_swigconstant(_fltk)
FL_CURSOR_CROSS = _fltk.FL_CURSOR_CROSS

_fltk.FL_CURSOR_WAIT_swigconstant(_fltk)
FL_CURSOR_WAIT = _fltk.FL_CURSOR_WAIT

_fltk.FL_CURSOR_INSERT_swigconstant(_fltk)
FL_CURSOR_INSERT = _fltk.FL_CURSOR_INSERT

_fltk.FL_CURSOR_HAND_swigconstant(_fltk)
FL_CURSOR_HAND = _fltk.FL_CURSOR_HAND

_fltk.FL_CURSOR_HELP_swigconstant(_fltk)
FL_CURSOR_HELP = _fltk.FL_CURSOR_HELP

_fltk.FL_CURSOR_MOVE_swigconstant(_fltk)
FL_CURSOR_MOVE = _fltk.FL_CURSOR_MOVE

_fltk.FL_CURSOR_NS_swigconstant(_fltk)
FL_CURSOR_NS = _fltk.FL_CURSOR_NS

_fltk.FL_CURSOR_WE_swigconstant(_fltk)
FL_CURSOR_WE = _fltk.FL_CURSOR_WE

_fltk.FL_CURSOR_NWSE_swigconstant(_fltk)
FL_CURSOR_NWSE = _fltk.FL_CURSOR_NWSE

_fltk.FL_CURSOR_NESW_swigconstant(_fltk)
FL_CURSOR_NESW = _fltk.FL_CURSOR_NESW

_fltk.FL_CURSOR_N_swigconstant(_fltk)
FL_CURSOR_N = _fltk.FL_CURSOR_N

_fltk.FL_CURSOR_NE_swigconstant(_fltk)
FL_CURSOR_NE = _fltk.FL_CURSOR_NE

_fltk.FL_CURSOR_E_swigconstant(_fltk)
FL_CURSOR_E = _fltk.FL_CURSOR_E

_fltk.FL_CURSOR_SE_swigconstant(_fltk)
FL_CURSOR_SE = _fltk.FL_CURSOR_SE

_fltk.FL_CURSOR_S_swigconstant(_fltk)
FL_CURSOR_S = _fltk.FL_CURSOR_S

_fltk.FL_CURSOR_SW_swigconstant(_fltk)
FL_CURSOR_SW = _fltk.FL_CURSOR_SW

_fltk.FL_CURSOR_W_swigconstant(_fltk)
FL_CURSOR_W = _fltk.FL_CURSOR_W

_fltk.FL_CURSOR_NW_swigconstant(_fltk)
FL_CURSOR_NW = _fltk.FL_CURSOR_NW

_fltk.FL_CURSOR_NONE_swigconstant(_fltk)
FL_CURSOR_NONE = _fltk.FL_CURSOR_NONE

_fltk.FL_READ_swigconstant(_fltk)
FL_READ = _fltk.FL_READ

_fltk.FL_WRITE_swigconstant(_fltk)
FL_WRITE = _fltk.FL_WRITE

_fltk.FL_EXCEPT_swigconstant(_fltk)
FL_EXCEPT = _fltk.FL_EXCEPT

_fltk.FL_RGB_swigconstant(_fltk)
FL_RGB = _fltk.FL_RGB

_fltk.FL_INDEX_swigconstant(_fltk)
FL_INDEX = _fltk.FL_INDEX

_fltk.FL_SINGLE_swigconstant(_fltk)
FL_SINGLE = _fltk.FL_SINGLE

_fltk.FL_DOUBLE_swigconstant(_fltk)
FL_DOUBLE = _fltk.FL_DOUBLE

_fltk.FL_ACCUM_swigconstant(_fltk)
FL_ACCUM = _fltk.FL_ACCUM

_fltk.FL_ALPHA_swigconstant(_fltk)
FL_ALPHA = _fltk.FL_ALPHA

_fltk.FL_DEPTH_swigconstant(_fltk)
FL_DEPTH = _fltk.FL_DEPTH

_fltk.FL_STENCIL_swigconstant(_fltk)
FL_STENCIL = _fltk.FL_STENCIL

_fltk.FL_RGB8_swigconstant(_fltk)
FL_RGB8 = _fltk.FL_RGB8

_fltk.FL_MULTISAMPLE_swigconstant(_fltk)
FL_MULTISAMPLE = _fltk.FL_MULTISAMPLE

_fltk.FL_STEREO_swigconstant(_fltk)
FL_STEREO = _fltk.FL_STEREO

_fltk.FL_FAKE_SINGLE_swigconstant(_fltk)
FL_FAKE_SINGLE = _fltk.FL_FAKE_SINGLE

_fltk.FL_IMAGE_WITH_ALPHA_swigconstant(_fltk)
FL_IMAGE_WITH_ALPHA = _fltk.FL_IMAGE_WITH_ALPHA

_fltk.FL_DAMAGE_CHILD_swigconstant(_fltk)
FL_DAMAGE_CHILD = _fltk.FL_DAMAGE_CHILD

_fltk.FL_DAMAGE_EXPOSE_swigconstant(_fltk)
FL_DAMAGE_EXPOSE = _fltk.FL_DAMAGE_EXPOSE

_fltk.FL_DAMAGE_SCROLL_swigconstant(_fltk)
FL_DAMAGE_SCROLL = _fltk.FL_DAMAGE_SCROLL

_fltk.FL_DAMAGE_OVERLAY_swigconstant(_fltk)
FL_DAMAGE_OVERLAY = _fltk.FL_DAMAGE_OVERLAY

_fltk.FL_DAMAGE_USER1_swigconstant(_fltk)
FL_DAMAGE_USER1 = _fltk.FL_DAMAGE_USER1

_fltk.FL_DAMAGE_USER2_swigconstant(_fltk)
FL_DAMAGE_USER2 = _fltk.FL_DAMAGE_USER2

_fltk.FL_DAMAGE_ALL_swigconstant(_fltk)
FL_DAMAGE_ALL = _fltk.FL_DAMAGE_ALL

# events
FL_KEYBOARD=FL_KEYDOWN

# additional boxtypes instead of defines
FL_ROUND_UP_BOX=fl_define_FL_ROUND_UP_BOX()
FL_ROUND_DOWN_BOX=fl_define_FL_ROUND_UP_BOX()+1
FL_SHADOW_BOX=fl_define_FL_SHADOW_BOX()
FL_SHADOW_FRAME=fl_define_FL_SHADOW_BOX()+2
FL_ROUNDED_BOX=fl_define_FL_ROUNDED_BOX()
FL_ROUNDED_FRAME=fl_define_FL_ROUNDED_BOX()+2
FL_RFLAT_BOX=fl_define_FL_RFLAT_BOX()
FL_RSHADOW_BOX=fl_define_FL_RSHADOW_BOX()
FL_DIAMOND_UP_BOX=fl_define_FL_DIAMOND_BOX()
FL_DIAMOND_DOWN_BOX=fl_define_FL_DIAMOND_BOX()+1
FL_OVAL_BOX=fl_define_FL_OVAL_BOX()
FL_OSHADOW_BOX=fl_define_FL_OVAL_BOX()+1
FL_OVAL_FRAME=fl_define_FL_OVAL_BOX()+2
FL_OFLAT_BOX=fl_define_FL_OVAL_BOX()+3
FL_PLASTIC_UP_BOX=fl_define_FL_PLASTIC_UP_BOX()
FL_PLASTIC_DOWN_BOX=fl_define_FL_PLASTIC_UP_BOX()+1
FL_PLASTIC_UP_FRAME=fl_define_FL_PLASTIC_UP_BOX()+2
FL_PLASTIC_DOWN_FRAME=fl_define_FL_PLASTIC_UP_BOX()+3
FL_PLASTIC_THIN_UP_BOX=fl_define_FL_PLASTIC_UP_BOX()+4
FL_PLASTIC_THIN_DOWN_BOX=fl_define_FL_PLASTIC_UP_BOX()+5
FL_PLASTIC_ROUND_UP_BOX=fl_define_FL_PLASTIC_UP_BOX()+6
FL_PLASTIC_ROUND_DOWN_BOX=fl_define_FL_PLASTIC_UP_BOX()+7

FL_GTK_UP_BOX=fl_define_FL_GTK_UP_BOX()
FL_GTK_DOWN_BOX=fl_define_FL_GTK_UP_BOX()+1
FL_GTK_UP_FRAME=fl_define_FL_GTK_UP_BOX()+2
FL_GTK_DOWN_FRAME=fl_define_FL_GTK_UP_BOX()+3
FL_GTK_THIN_UP_BOX=fl_define_FL_GTK_UP_BOX()+4
FL_GTK_THIN_DOWN_BOX=fl_define_FL_GTK_UP_BOX()+5
FL_GTK_THIN_UP_FRAME=fl_define_FL_GTK_UP_BOX()+6
FL_GTK_THIN_DOWN_FRAME=fl_define_FL_GTK_UP_BOX()+7
FL_GTK_ROUND_UP_BOX=fl_define_FL_GTK_UP_BOX()+8
FL_GTK_ROUND_DOWN_BOX=fl_define_FL_GTK_UP_BOX()+9


# color defines
FL_FOREGROUND_COLOR  = 0
FL_BACKGROUND2_COLOR = 7
FL_INACTIVE_COLOR    = 8
FL_SELECTION_COLOR   = 15

FL_GRAY0   = 32
FL_DARK3   = 39
FL_DARK2   = 45
FL_DARK1   = 47
FL_BACKGROUND_COLOR  = 49
FL_LIGHT1  = 50
FL_LIGHT2  = 52
FL_LIGHT3  = 54

FL_BLACK   = 56
FL_RED     = 88
FL_GREEN   = 63
FL_YELLOW  = 95
FL_BLUE    = 216
FL_MAGENTA = 248
FL_CYAN    = 223
FL_DARK_RED = 72

FL_DARK_GREEN    = 60
FL_DARK_YELLOW   = 76
FL_DARK_BLUE     = 136
FL_DARK_MAGENTA  = 152
FL_DARK_CYAN     = 140

FL_WHITE         = 255

FL_FREE_COLOR=16           
FL_NUM_FREE_COLOR=16       
FL_GRAY_RAMP=32           
FL_NUM_GRAY=24                     
FL_GRAY=49
FL_COLOR_CUBE=56           
FL_NUM_RED=5                      
FL_NUM_GREEN=8                      
FL_NUM_BLUE=5

# label defines
FL_SYMBOL_LABEL=FL_NORMAL_LABEL
FL_SHADOW_LABEL=fl_define_FL_SHADOW_LABEL()
FL_ENGRAVED_LABEL=fl_define_FL_ENGRAVED_LABEL()
FL_EMBOSSED_LABEL=fl_define_FL_EMBOSSED_LABEL()

FL_ALIGN_CENTER=0
FL_ALIGN_TOP=1
FL_ALIGN_BOTTOM=2
FL_ALIGN_LEFT=4
FL_ALIGN_RIGHT=8
FL_ALIGN_INSIDE=16
FL_ALIGN_TEXT_OVER_IMAGE=32
FL_ALIGN_IMAGE_OVER_TEXT=0
FL_ALIGN_CLIP=64
FL_ALIGN_WRAP=128
FL_ALIGN_IMAGE_NEXT_TO_TEXT=0x0100
FL_ALIGN_TEXT_NEXT_TO_IMAGE=0x0120
FL_ALIGN_IMAGE_BACKDROP=0x0200
FL_ALIGN_TOP_LEFT= FL_ALIGN_TOP | FL_ALIGN_LEFT
FL_ALIGN_TOP_RIGHT= FL_ALIGN_TOP | FL_ALIGN_RIGHT
FL_ALIGN_BOTTOM_LEFT= FL_ALIGN_BOTTOM | FL_ALIGN_LEFT
FL_ALIGN_BOTTOM_RIGHT= FL_ALIGN_BOTTOM | FL_ALIGN_RIGHT
FL_ALIGN_LEFT_TOP= FL_ALIGN_TOP_LEFT
FL_ALIGN_RIGHT_TOP= FL_ALIGN_TOP_RIGHT
FL_ALIGN_LEFT_BOTTOM= FL_ALIGN_BOTTOM_LEFT
FL_ALIGN_RIGHT_BOTTOM= FL_ALIGN_BOTTOM_RIGHT
FL_ALIGN_NOWRAP=0

# font defines
FL_HELVETICA              = 0	## Helvetica (or Arial) normal (0)
FL_HELVETICA_BOLD         = 1	## Helvetica (or Arial) bold
FL_HELVETICA_ITALIC       = 2	## Helvetica (or Arial) oblique
FL_HELVETICA_BOLD_ITALIC  = 3	## Helvetica (or Arial) bold-oblique
FL_COURIER                = 4	## Courier normal
FL_COURIER_BOLD           = 5	## Courier bold 
FL_COURIER_ITALIC         = 6	## Courier italic
FL_COURIER_BOLD_ITALIC    = 7	## Courier bold-italic
FL_TIMES                  = 8	## Times roman
FL_TIMES_BOLD             = 9	## Times roman bold
FL_TIMES_ITALIC           = 10	## Times roman italic
FL_TIMES_BOLD_ITALIC      = 11	## Times roman bold-italic
FL_SYMBOL                 = 12	## Standard symbol font
FL_SCREEN                 = 13	## Default monospaced screen font
FL_SCREEN_BOLD            = 14	## Default monospaced bold screen font
FL_ZAPF_DINGBATS          = 15	## Zapf-dingbats font

FL_FREE_FONT              = 16	## first one to allocate
FL_BOLD                   = 1	## add this to helvetica, courier, or times
FL_ITALIC                 = 2	## add this to helvetica, courier, or times
FL_BOLD_ITALIC            = 3	## add this to helvetica, courier, or times




_fltk.FL_RGB_SCALING_NEAREST_swigconstant(_fltk)
FL_RGB_SCALING_NEAREST = _fltk.FL_RGB_SCALING_NEAREST

_fltk.FL_RGB_SCALING_BILINEAR_swigconstant(_fltk)
FL_RGB_SCALING_BILINEAR = _fltk.FL_RGB_SCALING_BILINEAR
class Fl_Image(object):
    """

    Fl_Image is the base class used for caching and drawing all kinds of images 
    in FLTK. This class keeps track of common image data such as the pixels, 
    colormap, width, height, and depth. Virtual methods are used to provide 
    type-specific image handling.

    Since the Fl_Image class does not support image drawing by itself, calling 
    the draw() method results in a box with an X in it being drawn instead.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def w(self, *args):
        """w(Fl_Image self) -> int"""
        return _fltk.Fl_Image_w(self, *args)


    def h(self, *args):
        """h(Fl_Image self) -> int"""
        return _fltk.Fl_Image_h(self, *args)


    def d(self, *args):
        """d(Fl_Image self) -> int"""
        return _fltk.Fl_Image_d(self, *args)


    def ld(self, *args):
        """ld(Fl_Image self) -> int"""
        return _fltk.Fl_Image_ld(self, *args)


    def count(self, *args):
        """count(Fl_Image self) -> int"""
        return _fltk.Fl_Image_count(self, *args)


    def data(self, *args):
        """data(Fl_Image self) -> char const *const *"""
        return _fltk.Fl_Image_data(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Image self, int W, int H, int D) -> Fl_Image"""
        if self.__class__ == Fl_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Image
    __del__ = lambda self: None

    def copy(self, *args):
        """
        copy(Fl_Image self, int W, int H) -> Fl_Image
        copy(Fl_Image self) -> Fl_Image
        """
        return _fltk.Fl_Image_copy(self, *args)


    def color_average(self, *args):
        """color_average(Fl_Image self, Fl_Color c, float i)"""
        return _fltk.Fl_Image_color_average(self, *args)


    def inactive(self, *args):
        """inactive(Fl_Image self)"""
        return _fltk.Fl_Image_inactive(self, *args)


    def desaturate(self, *args):
        """desaturate(Fl_Image self)"""
        return _fltk.Fl_Image_desaturate(self, *args)


    def label(self, *args):
        """
        label(Fl_Image self, Fl_Widget w)
        label(Fl_Image self, Fl_Menu_Item m)
        """
        return _fltk.Fl_Image_label(self, *args)


    def draw(self, *args):
        """
        draw(Fl_Image self, int X, int Y, int W, int H, int cx=0, int cy=0)
        draw(Fl_Image self, int X, int Y)
        """
        return _fltk.Fl_Image_draw(self, *args)


    def uncache(self, *args):
        """uncache(Fl_Image self)"""
        return _fltk.Fl_Image_uncache(self, *args)


    def RGB_scaling(*args):
        """
        RGB_scaling(Fl_RGB_Scaling arg1)
        RGB_scaling() -> Fl_RGB_Scaling
        """
        return _fltk.Fl_Image_RGB_scaling(*args)

    RGB_scaling = staticmethod(RGB_scaling)
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Image(self)
        return weakref_proxy(self)
Fl_Image_swigregister = _fltk.Fl_Image_swigregister
Fl_Image_swigregister(Fl_Image)

def Fl_Image_RGB_scaling(*args):
    """
    RGB_scaling(Fl_RGB_Scaling arg1)
    Fl_Image_RGB_scaling() -> Fl_RGB_Scaling
    """
    return _fltk.Fl_Image_RGB_scaling(*args)

class Fl_RGB_Image(Fl_Image):
    """Proxy of C++ Fl_RGB_Image class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Fl_RGB_Image self, uchar const * bits, int W, int H, int D=3, int LD=0) -> Fl_RGB_Image
        __init__(Fl_RGB_Image self, Fl_Pixmap pxm, Fl_Color bg) -> Fl_RGB_Image
        """
        if self.__class__ == Fl_RGB_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_RGB_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_RGB_Image
    __del__ = lambda self: None

    def copy(self, *args):
        """
        copy(Fl_RGB_Image self, int W, int H) -> Fl_Image
        copy(Fl_RGB_Image self) -> Fl_Image
        """
        return _fltk.Fl_RGB_Image_copy(self, *args)


    def color_average(self, *args):
        """color_average(Fl_RGB_Image self, Fl_Color c, float i)"""
        return _fltk.Fl_RGB_Image_color_average(self, *args)


    def desaturate(self, *args):
        """desaturate(Fl_RGB_Image self)"""
        return _fltk.Fl_RGB_Image_desaturate(self, *args)


    def draw(self, *args):
        """
        draw(Fl_RGB_Image self, int X, int Y, int W, int H, int cx=0, int cy=0)
        draw(Fl_RGB_Image self, int X, int Y)
        """
        return _fltk.Fl_RGB_Image_draw(self, *args)


    def label(self, *args):
        """
        label(Fl_RGB_Image self, Fl_Widget w)
        label(Fl_RGB_Image self, Fl_Menu_Item m)
        """
        return _fltk.Fl_RGB_Image_label(self, *args)


    def uncache(self, *args):
        """uncache(Fl_RGB_Image self)"""
        return _fltk.Fl_RGB_Image_uncache(self, *args)


    def max_size(*args):
        """
        max_size(size_t size)
        max_size() -> size_t
        """
        return _fltk.Fl_RGB_Image_max_size(*args)

    max_size = staticmethod(max_size)
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_RGB_Image(self)
        return weakref_proxy(self)
Fl_RGB_Image_swigregister = _fltk.Fl_RGB_Image_swigregister
Fl_RGB_Image_swigregister(Fl_RGB_Image)

def Fl_RGB_Image_max_size(*args):
    """
    max_size(size_t size)
    Fl_RGB_Image_max_size() -> size_t
    """
    return _fltk.Fl_RGB_Image_max_size(*args)

class Fl_Label(object):
    """Proxy of C++ Fl_Label class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Label self, int arg2, int arg3, int arg4, int arg5, Fl_Align arg6)"""
        return _fltk.Fl_Label_draw(self, *args)


    def measure(self, *args):
        """measure(Fl_Label self, int & w, int & h)"""
        return _fltk.Fl_Label_measure(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Label self) -> Fl_Label"""
        this = _fltk.new_Fl_Label(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Label
    __del__ = lambda self: None
Fl_Label_swigregister = _fltk.Fl_Label_swigregister
Fl_Label_swigregister(Fl_Label)

class Fl_Widget(object):
    """

    Fl_Widget is the base class for all widgets in FLTK. You can't create one of 
    these because the constructor is not public. However you can subclass it.

    All 'property' accessing methods, such as color(), parent(), or argument() 
    are implemented as trivial inline functions and thus are as fast and small 
    as accessing fields in a structure. Unless otherwise noted, the property 
    setting methods such as color(n) or label(s) are also trivial inline 
    functions, even if they change the widget's appearance. It is up to the user 
    code to call redraw() after these. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Widget self, int x, int y, int w, int h, char const * label=0) -> Fl_Widget"""
        if self.__class__ == Fl_Widget:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Widget(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Widget
    __del__ = lambda self: None

    def draw(self, *args):
        """draw(Fl_Widget self)"""
        return _fltk.Fl_Widget_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Widget self, int event) -> int"""
        return _fltk.Fl_Widget_handle(self, *args)


    def parent(self, *args):
        """
        parent(Fl_Widget self) -> Fl_Group
        parent(Fl_Widget self, Fl_Group p)
        """
        return _fltk.Fl_Widget_parent(self, *args)


    def type(self, *args):
        """
        type(Fl_Widget self) -> uchar
        type(Fl_Widget self, uchar t)
        """
        return _fltk.Fl_Widget_type(self, *args)


    def x(self, *args):
        """x(Fl_Widget self) -> int"""
        return _fltk.Fl_Widget_x(self, *args)


    def y(self, *args):
        """y(Fl_Widget self) -> int"""
        return _fltk.Fl_Widget_y(self, *args)


    def w(self, *args):
        """w(Fl_Widget self) -> int"""
        return _fltk.Fl_Widget_w(self, *args)


    def h(self, *args):
        """h(Fl_Widget self) -> int"""
        return _fltk.Fl_Widget_h(self, *args)


    def resize(self, *args):
        """resize(Fl_Widget self, int x, int y, int w, int h)"""
        return _fltk.Fl_Widget_resize(self, *args)


    def damage_resize(self, *args):
        """damage_resize(Fl_Widget self, int arg2, int arg3, int arg4, int arg5) -> int"""
        return _fltk.Fl_Widget_damage_resize(self, *args)


    def position(self, *args):
        """position(Fl_Widget self, int X, int Y)"""
        return _fltk.Fl_Widget_position(self, *args)


    def size(self, *args):
        """size(Fl_Widget self, int W, int H)"""
        return _fltk.Fl_Widget_size(self, *args)


    def align(self, *args):
        """
        align(Fl_Widget self) -> Fl_Align
        align(Fl_Widget self, Fl_Align alignment)
        """
        return _fltk.Fl_Widget_align(self, *args)


    def box(self, *args):
        """
        box(Fl_Widget self) -> Fl_Boxtype
        box(Fl_Widget self, Fl_Boxtype new_box)
        """
        return _fltk.Fl_Widget_box(self, *args)


    def selection_color(self, *args):
        """
        selection_color(Fl_Widget self) -> Fl_Color
        selection_color(Fl_Widget self, Fl_Color a)
        """
        return _fltk.Fl_Widget_selection_color(self, *args)


    def color(self, *args):
        """
        color(Fl_Widget self) -> Fl_Color
        color(Fl_Widget self, Fl_Color bg)
        color(Fl_Widget self, Fl_Color bg, Fl_Color sel)
        """
        return _fltk.Fl_Widget_color(self, *args)


    def copy_label(self, *args):
        """copy_label(Fl_Widget self, char const * new_label)"""
        return _fltk.Fl_Widget_copy_label(self, *args)


    def label(self, *args):
        """
        label(Fl_Widget self) -> char const
        label(Fl_Widget self, char const * text)
        label(Fl_Widget self, Fl_Labeltype a, char const * b)
        """
        val = _fltk.Fl_Widget_label(self, *args)

        if len(args) > 0:
            self.my_label = args[len(args)-1]


        return val


    def labeltype(self, *args):
        """
        labeltype(Fl_Widget self) -> Fl_Labeltype
        labeltype(Fl_Widget self, Fl_Labeltype a)
        """
        return _fltk.Fl_Widget_labeltype(self, *args)


    def labelcolor(self, *args):
        """
        labelcolor(Fl_Widget self) -> Fl_Color
        labelcolor(Fl_Widget self, Fl_Color c)
        """
        return _fltk.Fl_Widget_labelcolor(self, *args)


    def labelfont(self, *args):
        """
        labelfont(Fl_Widget self) -> Fl_Font
        labelfont(Fl_Widget self, Fl_Font f)
        """
        return _fltk.Fl_Widget_labelfont(self, *args)


    def labelsize(self, *args):
        """
        labelsize(Fl_Widget self) -> Fl_Fontsize
        labelsize(Fl_Widget self, Fl_Fontsize pix)
        """
        return _fltk.Fl_Widget_labelsize(self, *args)


    def image(self, *args):
        """
        image(Fl_Widget self) -> Fl_Image
        image(Fl_Widget self) -> Fl_Image
        image(Fl_Widget self, Fl_Image img)
        """
        val = _fltk.Fl_Widget_image(self, *args)

        if len(args) > 0:
        #delegate ownership to C++
            self.my_image = args[0]


        return val


    def deimage(self, *args):
        """
        deimage(Fl_Widget self) -> Fl_Image
        deimage(Fl_Widget self) -> Fl_Image
        deimage(Fl_Widget self, Fl_Image img)
        """
        val = _fltk.Fl_Widget_deimage(self, *args)

        if len(args) > 0:
        #delegate ownership to C++
            self.my_deimage = args[0]


        return val


    def tooltip(self, *args):
        """
        tooltip(Fl_Widget self) -> char const
        tooltip(Fl_Widget self, char const * text)
        """
        return _fltk.Fl_Widget_tooltip(self, *args)


    def copy_tooltip(self, *args):
        """copy_tooltip(Fl_Widget self, char const * text)"""
        return _fltk.Fl_Widget_copy_tooltip(self, *args)


    def argument(self, *args):
        """
        argument(Fl_Widget self) -> long
        argument(Fl_Widget self, long v)
        """
        return _fltk.Fl_Widget_argument(self, *args)


    def when(self, *args):
        """
        when(Fl_Widget self) -> Fl_When
        when(Fl_Widget self, uchar i)
        """
        return _fltk.Fl_Widget_when(self, *args)


    def visible(self, *args):
        """visible(Fl_Widget self) -> unsigned int"""
        return _fltk.Fl_Widget_visible(self, *args)


    def visible_r(self, *args):
        """visible_r(Fl_Widget self) -> int"""
        return _fltk.Fl_Widget_visible_r(self, *args)


    def show(self, *args):
        """show(Fl_Widget self)"""
        return _fltk.Fl_Widget_show(self, *args)


    def hide(self, *args):
        """hide(Fl_Widget self)"""
        return _fltk.Fl_Widget_hide(self, *args)


    def set_visible(self, *args):
        """set_visible(Fl_Widget self)"""
        return _fltk.Fl_Widget_set_visible(self, *args)


    def clear_visible(self, *args):
        """clear_visible(Fl_Widget self)"""
        return _fltk.Fl_Widget_clear_visible(self, *args)


    def active(self, *args):
        """active(Fl_Widget self) -> unsigned int"""
        return _fltk.Fl_Widget_active(self, *args)


    def active_r(self, *args):
        """active_r(Fl_Widget self) -> int"""
        return _fltk.Fl_Widget_active_r(self, *args)


    def activate(self, *args):
        """activate(Fl_Widget self)"""
        return _fltk.Fl_Widget_activate(self, *args)


    def deactivate(self, *args):
        """deactivate(Fl_Widget self)"""
        return _fltk.Fl_Widget_deactivate(self, *args)


    def output(self, *args):
        """output(Fl_Widget self) -> unsigned int"""
        return _fltk.Fl_Widget_output(self, *args)


    def set_output(self, *args):
        """set_output(Fl_Widget self)"""
        return _fltk.Fl_Widget_set_output(self, *args)


    def clear_output(self, *args):
        """clear_output(Fl_Widget self)"""
        return _fltk.Fl_Widget_clear_output(self, *args)


    def takesevents(self, *args):
        """takesevents(Fl_Widget self) -> unsigned int"""
        return _fltk.Fl_Widget_takesevents(self, *args)


    def changed(self, *args):
        """changed(Fl_Widget self) -> unsigned int"""
        return _fltk.Fl_Widget_changed(self, *args)


    def set_changed(self, *args):
        """set_changed(Fl_Widget self)"""
        return _fltk.Fl_Widget_set_changed(self, *args)


    def clear_changed(self, *args):
        """clear_changed(Fl_Widget self)"""
        return _fltk.Fl_Widget_clear_changed(self, *args)


    def clear_active(self, *args):
        """clear_active(Fl_Widget self)"""
        return _fltk.Fl_Widget_clear_active(self, *args)


    def set_active(self, *args):
        """set_active(Fl_Widget self)"""
        return _fltk.Fl_Widget_set_active(self, *args)


    def take_focus(self, *args):
        """take_focus(Fl_Widget self) -> int"""
        return _fltk.Fl_Widget_take_focus(self, *args)


    def set_visible_focus(self, *args):
        """set_visible_focus(Fl_Widget self)"""
        return _fltk.Fl_Widget_set_visible_focus(self, *args)


    def clear_visible_focus(self, *args):
        """clear_visible_focus(Fl_Widget self)"""
        return _fltk.Fl_Widget_clear_visible_focus(self, *args)


    def visible_focus(self, *args):
        """
        visible_focus(Fl_Widget self, int v)
        visible_focus(Fl_Widget self) -> unsigned int
        """
        return _fltk.Fl_Widget_visible_focus(self, *args)


    def default_callback(*args):
        """default_callback(Fl_Widget cb, void * d)"""
        return _fltk.Fl_Widget_default_callback(*args)

    default_callback = staticmethod(default_callback)

    def do_callback(self, *args):
        """
        do_callback(Fl_Widget self)
        do_callback(Fl_Widget self, Fl_Widget o, long arg)
        do_callback(Fl_Widget self, Fl_Widget o, void * arg=None)
        """
        return _fltk.Fl_Widget_do_callback(self, *args)


    def label_shortcut(*args):
        """label_shortcut(char const * t) -> unsigned int"""
        return _fltk.Fl_Widget_label_shortcut(*args)

    label_shortcut = staticmethod(label_shortcut)

    def test_shortcut(*args):
        """
        test_shortcut() -> int
        test_shortcut(char const * arg1, bool const require_alt=False) -> int
        """
        return _fltk.Fl_Widget_test_shortcut(*args)

    test_shortcut = staticmethod(test_shortcut)

    def _set_fullscreen(self, *args):
        """_set_fullscreen(Fl_Widget self)"""
        return _fltk.Fl_Widget__set_fullscreen(self, *args)


    def _clear_fullscreen(self, *args):
        """_clear_fullscreen(Fl_Widget self)"""
        return _fltk.Fl_Widget__clear_fullscreen(self, *args)


    def contains(self, *args):
        """contains(Fl_Widget self, Fl_Widget w) -> int"""
        return _fltk.Fl_Widget_contains(self, *args)


    def inside(self, *args):
        """inside(Fl_Widget self, Fl_Widget wgt) -> int"""
        return _fltk.Fl_Widget_inside(self, *args)


    def redraw(self, *args):
        """redraw(Fl_Widget self)"""
        return _fltk.Fl_Widget_redraw(self, *args)


    def redraw_label(self, *args):
        """redraw_label(Fl_Widget self)"""
        return _fltk.Fl_Widget_redraw_label(self, *args)


    def clear_damage(self, *args):
        """clear_damage(Fl_Widget self, uchar c=0)"""
        return _fltk.Fl_Widget_clear_damage(self, *args)


    def damage(self, *args):
        """
        damage(Fl_Widget self) -> uchar
        damage(Fl_Widget self, uchar c)
        damage(Fl_Widget self, uchar c, int x, int y, int w, int h)
        """
        return _fltk.Fl_Widget_damage(self, *args)


    def measure_label(self, *args):
        """measure_label(Fl_Widget self, int & ww, int & hh)"""
        return _fltk.Fl_Widget_measure_label(self, *args)


    def window(self, *args):
        """window(Fl_Widget self) -> Fl_Window"""
        return _fltk.Fl_Widget_window(self, *args)


    def top_window(self, *args):
        """top_window(Fl_Widget self) -> Fl_Window"""
        return _fltk.Fl_Widget_top_window(self, *args)


    def top_window_offset(self, *args):
        """top_window_offset(Fl_Widget self, int & xoff, int & yoff) -> Fl_Window"""
        return _fltk.Fl_Widget_top_window_offset(self, *args)


    def as_group(self, *args):
        """as_group(Fl_Widget self) -> Fl_Group"""
        return _fltk.Fl_Widget_as_group(self, *args)


    def as_window(self, *args):
        """as_window(Fl_Widget self) -> Fl_Window"""
        return _fltk.Fl_Widget_as_window(self, *args)


    def as_gl_window(self, *args):
        """as_gl_window(Fl_Widget self) -> Fl_Gl_Window"""
        return _fltk.Fl_Widget_as_gl_window(self, *args)


    def use_accents_menu(self, *args):
        """use_accents_menu(Fl_Widget self) -> int"""
        return _fltk.Fl_Widget_use_accents_menu(self, *args)


    def color2(self, *args):
        """
        color2(Fl_Widget self) -> Fl_Color
        color2(Fl_Widget self, unsigned int a)
        """
        return _fltk.Fl_Widget_color2(self, *args)


    def draw_label(self, *args):
        """
        draw_label(Fl_Widget self, int arg2, int arg3, int arg4, int arg5, Fl_Align arg6)
        draw_label(Fl_Widget self)
        """
        return _fltk.Fl_Widget_draw_label(self, *args)


    def draw_backdrop(self, *args):
        """draw_backdrop(Fl_Widget self)"""
        return _fltk.Fl_Widget_draw_backdrop(self, *args)


    def callback(self, *args):
        """
        callback(Fl_Widget self) -> Fl_Callback_p
        callback(Fl_Widget self, Fl_Callback * cb, void * p)
        callback(Fl_Widget self, Fl_Callback * cb)
        callback(Fl_Widget self, Fl_Callback0 * cb)
        callback(Fl_Widget self, Fl_Callback1 * cb, long p=0)
        callback(Fl_Widget self, PyObject * PyFunc, PyObject * PyWidget, PyObject * PyData=None)
        """
        return _fltk.Fl_Widget_callback(self, *args)


    def user_data(self, *args):
        """
        user_data(Fl_Widget self)
        user_data(Fl_Widget self, void * v)
        user_data(Fl_Widget self, PyObject * PyData)
        user_data(Fl_Widget self) -> PyObject *
        """
        return _fltk.Fl_Widget_user_data(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Widget(self)
        return weakref_proxy(self)
Fl_Widget_swigregister = _fltk.Fl_Widget_swigregister
Fl_Widget_swigregister(Fl_Widget)

def Fl_Widget_default_callback(*args):
    """Fl_Widget_default_callback(Fl_Widget cb, void * d)"""
    return _fltk.Fl_Widget_default_callback(*args)

def Fl_Widget_label_shortcut(*args):
    """Fl_Widget_label_shortcut(char const * t) -> unsigned int"""
    return _fltk.Fl_Widget_label_shortcut(*args)

def Fl_Widget_test_shortcut(*args):
    """
    test_shortcut() -> int
    Fl_Widget_test_shortcut(char const * arg2, bool const require_alt=False) -> int
    """
    return _fltk.Fl_Widget_test_shortcut(*args)


_fltk.FL_RESERVED_TYPE_swigconstant(_fltk)
FL_RESERVED_TYPE = _fltk.FL_RESERVED_TYPE
class Fl_Group(Fl_Widget):
    """

    The Fl_Group class is the FLTK container widget. It maintains an array of 
    child widgets. These children can themselves be any widget including Fl_Group. 
    The most important subclass of Fl_Group  is Fl_Window, however groups can 
    also be used to control radio buttons or to enforce resize behavior.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Group self)"""
        return _fltk.Fl_Group_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Group self, int arg0) -> int"""
        return _fltk.Fl_Group_handle(self, *args)


    def begin(self, *args):
        """begin(Fl_Group self)"""
        return _fltk.Fl_Group_begin(self, *args)


    def end(self, *args):
        """end(Fl_Group self)"""
        return _fltk.Fl_Group_end(self, *args)


    def current(*args):
        """
        current() -> Fl_Group
        current(Fl_Group g)
        """
        return _fltk.Fl_Group_current(*args)

    current = staticmethod(current)

    def children(self, *args):
        """children(Fl_Group self) -> int"""
        return _fltk.Fl_Group_children(self, *args)


    def child(self, *args):
        """child(Fl_Group self, int n) -> Fl_Widget"""
        return _fltk.Fl_Group_child(self, *args)


    def find(self, *args):
        """find(Fl_Group self, Fl_Widget o) -> int"""
        return _fltk.Fl_Group_find(self, *args)


    def resize(self, *args):
        """resize(Fl_Group self, int arg0, int arg1, int arg2, int arg3)"""
        return _fltk.Fl_Group_resize(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Group self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Group"""
        if self.__class__ == Fl_Group:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Group(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Group
    __del__ = lambda self: None

    def add(self, *args):
        """add(Fl_Group self, Fl_Widget o)"""
        val = _fltk.Fl_Group_add(self, *args)

        #self = args[0]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()
        else:                       
        #give ownership back to Python
            self.this.own() 


        return val


    def insert(self, *args):
        """insert(Fl_Group self, Fl_Widget arg2, int i)"""
        return _fltk.Fl_Group_insert(self, *args)


    def insert_before(self, *args):
        """insert_before(Fl_Group self, Fl_Widget o, Fl_Widget before)"""
        return _fltk.Fl_Group_insert_before(self, *args)


    def remove(self, *args):
        """
        remove(Fl_Group self, int index)
        remove(Fl_Group self, Fl_Widget o)
        """
        val = _fltk.Fl_Group_remove(self, *args)

        #self = args[0]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()
        else:                       
        #give ownership back to Python
            self.this.own() 


        return val


    def clear(self, *args):
        """clear(Fl_Group self)"""
        return _fltk.Fl_Group_clear(self, *args)


    def resizable(self, *args):
        """
        resizable(Fl_Group self, Fl_Widget o)
        resizable(Fl_Group self) -> Fl_Widget
        """
        return _fltk.Fl_Group_resizable(self, *args)


    def add_resizable(self, *args):
        """add_resizable(Fl_Group self, Fl_Widget o)"""
        return _fltk.Fl_Group_add_resizable(self, *args)


    def init_sizes(self, *args):
        """init_sizes(Fl_Group self)"""
        return _fltk.Fl_Group_init_sizes(self, *args)


    def clip_children(self, *args):
        """
        clip_children(Fl_Group self, int c)
        clip_children(Fl_Group self) -> unsigned int
        """
        return _fltk.Fl_Group_clip_children(self, *args)


    def as_group(self, *args):
        """as_group(Fl_Group self) -> Fl_Group"""
        return _fltk.Fl_Group_as_group(self, *args)


    def focus(self, *args):
        """focus(Fl_Group self, Fl_Widget W)"""
        return _fltk.Fl_Group_focus(self, *args)


    def _ddfdesign_kludge(self, *args):
        """_ddfdesign_kludge(Fl_Group self) -> Fl_Widget *&"""
        return _fltk.Fl_Group__ddfdesign_kludge(self, *args)


    def forms_end(self, *args):
        """forms_end(Fl_Group self)"""
        return _fltk.Fl_Group_forms_end(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Group(self)
        return weakref_proxy(self)
Fl_Group_swigregister = _fltk.Fl_Group_swigregister
Fl_Group_swigregister(Fl_Group)

def Fl_Group_current(*args):
    """
    current() -> Fl_Group
    Fl_Group_current(Fl_Group g)
    """
    return _fltk.Fl_Group_current(*args)

class Fl_End(object):
    """Proxy of C++ Fl_End class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_End self) -> Fl_End"""
        this = _fltk.new_Fl_End(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_End
    __del__ = lambda self: None
Fl_End_swigregister = _fltk.Fl_End_swigregister
Fl_End_swigregister(Fl_End)


_fltk.FL_NORMAL_BROWSER_swigconstant(_fltk)
FL_NORMAL_BROWSER = _fltk.FL_NORMAL_BROWSER

_fltk.FL_SELECT_BROWSER_swigconstant(_fltk)
FL_SELECT_BROWSER = _fltk.FL_SELECT_BROWSER

_fltk.FL_HOLD_BROWSER_swigconstant(_fltk)
FL_HOLD_BROWSER = _fltk.FL_HOLD_BROWSER

_fltk.FL_MULTI_BROWSER_swigconstant(_fltk)
FL_MULTI_BROWSER = _fltk.FL_MULTI_BROWSER

_fltk.FL_SORT_ASCENDING_swigconstant(_fltk)
FL_SORT_ASCENDING = _fltk.FL_SORT_ASCENDING

_fltk.FL_SORT_DESCENDING_swigconstant(_fltk)
FL_SORT_DESCENDING = _fltk.FL_SORT_DESCENDING
class Fl_Browser_(Fl_Group):
    """

    This is the base class for browsers. To be useful it must be subclassed 
    and several virtual functions defined. The Forms-compatible browser and 
    the file chooser's browser are subclassed off of this.

    This has been designed so that the subclass has complete control over 
    the storage of the data, although because next() and prev() functions 
    are used to index, it works best as a linked list or as a large block 
    of characters in which the line breaks must be searched for.

    A great deal of work has been done so that the 'height' of a data object 
    does not need to be determined until it is drawn. This is useful if 
    actually figuring out the size of an object requires accessing image 
    data or doing stat() on a file or doing some other slow operation. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def item_first(self, *args):
        """item_first(Fl_Browser_ self) -> void *"""
        return _fltk.Fl_Browser__item_first(self, *args)


    def item_next(self, *args):
        """item_next(Fl_Browser_ self, void * item) -> void *"""
        return _fltk.Fl_Browser__item_next(self, *args)


    def item_prev(self, *args):
        """item_prev(Fl_Browser_ self, void * item) -> void *"""
        return _fltk.Fl_Browser__item_prev(self, *args)


    def item_last(self, *args):
        """item_last(Fl_Browser_ self) -> void *"""
        return _fltk.Fl_Browser__item_last(self, *args)


    def item_height(self, *args):
        """item_height(Fl_Browser_ self, void * item) -> int"""
        return _fltk.Fl_Browser__item_height(self, *args)


    def item_width(self, *args):
        """item_width(Fl_Browser_ self, void * item) -> int"""
        return _fltk.Fl_Browser__item_width(self, *args)


    def item_quick_height(self, *args):
        """item_quick_height(Fl_Browser_ self, void * item) -> int"""
        return _fltk.Fl_Browser__item_quick_height(self, *args)


    def item_draw(self, *args):
        """item_draw(Fl_Browser_ self, void * item, int X, int Y, int W, int H)"""
        return _fltk.Fl_Browser__item_draw(self, *args)


    def item_text(self, *args):
        """item_text(Fl_Browser_ self, void * item) -> char const *"""
        return _fltk.Fl_Browser__item_text(self, *args)


    def item_swap(self, *args):
        """item_swap(Fl_Browser_ self, void * a, void * b)"""
        return _fltk.Fl_Browser__item_swap(self, *args)


    def item_at(self, *args):
        """item_at(Fl_Browser_ self, int index) -> void *"""
        return _fltk.Fl_Browser__item_at(self, *args)


    def full_width(self, *args):
        """full_width(Fl_Browser_ self) -> int"""
        return _fltk.Fl_Browser__full_width(self, *args)


    def full_height(self, *args):
        """full_height(Fl_Browser_ self) -> int"""
        return _fltk.Fl_Browser__full_height(self, *args)


    def incr_height(self, *args):
        """incr_height(Fl_Browser_ self) -> int"""
        return _fltk.Fl_Browser__incr_height(self, *args)


    def item_select(self, *args):
        """item_select(Fl_Browser_ self, void * item, int val=1)"""
        return _fltk.Fl_Browser__item_select(self, *args)


    def item_selected(self, *args):
        """item_selected(Fl_Browser_ self, void * item) -> int"""
        return _fltk.Fl_Browser__item_selected(self, *args)


    def draw(self, *args):
        """draw(Fl_Browser_ self)"""
        return _fltk.Fl_Browser__draw(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Browser_ self, int X, int Y, int W, int H, char const * L=None) -> Fl_Browser_"""
        if self.__class__ == Fl_Browser_:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Browser_(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def handle(self, *args):
        """handle(Fl_Browser_ self, int event) -> int"""
        return _fltk.Fl_Browser__handle(self, *args)


    def resize(self, *args):
        """resize(Fl_Browser_ self, int X, int Y, int W, int H)"""
        return _fltk.Fl_Browser__resize(self, *args)


    def select(self, *args):
        """select(Fl_Browser_ self, void * item, int val=1, int docallbacks=0) -> int"""
        return _fltk.Fl_Browser__select(self, *args)


    def select_only(self, *args):
        """select_only(Fl_Browser_ self, void * item, int docallbacks=0) -> int"""
        return _fltk.Fl_Browser__select_only(self, *args)


    def deselect(self, *args):
        """deselect(Fl_Browser_ self, int docallbacks=0) -> int"""
        return _fltk.Fl_Browser__deselect(self, *args)


    def position(self, *args):
        """
        position(Fl_Browser_ self) -> int
        position(Fl_Browser_ self, int pos)
        """
        return _fltk.Fl_Browser__position(self, *args)


    def hposition(self, *args):
        """
        hposition(Fl_Browser_ self) -> int
        hposition(Fl_Browser_ self, int arg2)
        """
        return _fltk.Fl_Browser__hposition(self, *args)


    def display(self, *args):
        """display(Fl_Browser_ self, void * item)"""
        return _fltk.Fl_Browser__display(self, *args)

    HORIZONTAL = _fltk.Fl_Browser__HORIZONTAL
    VERTICAL = _fltk.Fl_Browser__VERTICAL
    BOTH = _fltk.Fl_Browser__BOTH
    ALWAYS_ON = _fltk.Fl_Browser__ALWAYS_ON
    HORIZONTAL_ALWAYS = _fltk.Fl_Browser__HORIZONTAL_ALWAYS
    VERTICAL_ALWAYS = _fltk.Fl_Browser__VERTICAL_ALWAYS
    BOTH_ALWAYS = _fltk.Fl_Browser__BOTH_ALWAYS

    def has_scrollbar(self, *args):
        """
        has_scrollbar(Fl_Browser_ self) -> uchar
        has_scrollbar(Fl_Browser_ self, uchar mode)
        """
        return _fltk.Fl_Browser__has_scrollbar(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Browser_ self) -> Fl_Font
        textfont(Fl_Browser_ self, Fl_Font font)
        """
        return _fltk.Fl_Browser__textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Browser_ self) -> Fl_Fontsize
        textsize(Fl_Browser_ self, Fl_Fontsize newSize)
        """
        return _fltk.Fl_Browser__textsize(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Browser_ self) -> Fl_Color
        textcolor(Fl_Browser_ self, Fl_Color col)
        """
        return _fltk.Fl_Browser__textcolor(self, *args)


    def scrollbar_size(self, *args):
        """
        scrollbar_size(Fl_Browser_ self) -> int
        scrollbar_size(Fl_Browser_ self, int newSize)
        """
        return _fltk.Fl_Browser__scrollbar_size(self, *args)


    def scrollbar_width(self, *args):
        """
        scrollbar_width(Fl_Browser_ self) -> int
        scrollbar_width(Fl_Browser_ self, int width)
        """
        return _fltk.Fl_Browser__scrollbar_width(self, *args)


    def scrollbar_right(self, *args):
        """scrollbar_right(Fl_Browser_ self)"""
        return _fltk.Fl_Browser__scrollbar_right(self, *args)


    def scrollbar_left(self, *args):
        """scrollbar_left(Fl_Browser_ self)"""
        return _fltk.Fl_Browser__scrollbar_left(self, *args)


    def sort(self, *args):
        """sort(Fl_Browser_ self, int flags=0)"""
        return _fltk.Fl_Browser__sort(self, *args)


    def getScrollbar(self, *args):
        """getScrollbar(Fl_Browser_ self) -> Fl_Scrollbar"""
        return _fltk.Fl_Browser__getScrollbar(self, *args)


    def getHScrollbar(self, *args):
        """getHScrollbar(Fl_Browser_ self) -> Fl_Scrollbar"""
        return _fltk.Fl_Browser__getHScrollbar(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Browser_
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Browser_(self)
        return weakref_proxy(self)
Fl_Browser__swigregister = _fltk.Fl_Browser__swigregister
Fl_Browser__swigregister(Fl_Browser_)

class Fl_Browser(Fl_Browser_):
    """

    The Fl_Browser widget displays a scrolling list of text lines, and manages 
    all the storage for the text. This is not a text editor or spreadsheet! But 
    it is useful for showing a vertical list of named objects to the user.

    Each line in the browser is identified by number. The numbers start at one 
    (this is so that zero can be reserved for 'no line' in the selective browsers).
    Unless otherwise noted, the methods do not check to see if the passed line 
    number is in range and legal. It must always be greater than zero 
    and <= size().

    Each line contains a null-terminated string of text and a data pointer. 
    The text string is displayed, the  pointer can be used by the callbacks 
    to reference the object the text describes.

    The base class does nothing when the user clicks on it. The subclasses 
    Fl_Select_Browser, Fl_Hold_Browser, and Fl_Multi_Browser react to user 
    clicks to select lines in the browser and do callbacks.

    The base class called Fl_Browser_ provides the scrolling and selection 
    mechanisms of this and all the subclasses, but the dimensions and appearance 
    of each item are determined by the subclass. You can use Fl_Browser_ to 
    display information other than text, or text that is dynamically produced 
    from your own data structures. If you find that loading the browser is a 
    lot of work or is inefficient, you may want to make a subclass of Fl_Browser_. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def item_first(self, *args):
        """item_first(Fl_Browser self) -> void *"""
        return _fltk.Fl_Browser_item_first(self, *args)


    def item_next(self, *args):
        """item_next(Fl_Browser self, void * item) -> void *"""
        return _fltk.Fl_Browser_item_next(self, *args)


    def item_prev(self, *args):
        """item_prev(Fl_Browser self, void * item) -> void *"""
        return _fltk.Fl_Browser_item_prev(self, *args)


    def item_last(self, *args):
        """item_last(Fl_Browser self) -> void *"""
        return _fltk.Fl_Browser_item_last(self, *args)


    def item_selected(self, *args):
        """item_selected(Fl_Browser self, void * item) -> int"""
        return _fltk.Fl_Browser_item_selected(self, *args)


    def item_select(self, *args):
        """item_select(Fl_Browser self, void * item, int val)"""
        return _fltk.Fl_Browser_item_select(self, *args)


    def item_height(self, *args):
        """item_height(Fl_Browser self, void * item) -> int"""
        return _fltk.Fl_Browser_item_height(self, *args)


    def item_width(self, *args):
        """item_width(Fl_Browser self, void * item) -> int"""
        return _fltk.Fl_Browser_item_width(self, *args)


    def item_draw(self, *args):
        """item_draw(Fl_Browser self, void * item, int X, int Y, int W, int H)"""
        return _fltk.Fl_Browser_item_draw(self, *args)


    def full_height(self, *args):
        """full_height(Fl_Browser self) -> int"""
        return _fltk.Fl_Browser_full_height(self, *args)


    def incr_height(self, *args):
        """incr_height(Fl_Browser self) -> int"""
        return _fltk.Fl_Browser_incr_height(self, *args)


    def item_text(self, *args):
        """item_text(Fl_Browser self, void * item) -> char const *"""
        return _fltk.Fl_Browser_item_text(self, *args)


    def item_swap(self, *args):
        """item_swap(Fl_Browser self, void * a, void * b)"""
        return _fltk.Fl_Browser_item_swap(self, *args)


    def item_at(self, *args):
        """item_at(Fl_Browser self, int line) -> void *"""
        return _fltk.Fl_Browser_item_at(self, *args)


    def remove(self, *args):
        """remove(Fl_Browser self, int line)"""
        val = _fltk.Fl_Browser_remove(self, *args)

        #self = args[0]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()
        else:                       
        #give ownership back to Python
            self.this.own() 


        return val


    def move(self, *args):
        """move(Fl_Browser self, int to, int arg3)"""
        return _fltk.Fl_Browser_move(self, *args)


    def load(self, *args):
        """load(Fl_Browser self, char const * filename) -> int"""
        return _fltk.Fl_Browser_load(self, *args)


    def swap(self, *args):
        """swap(Fl_Browser self, int a, int b)"""
        return _fltk.Fl_Browser_swap(self, *args)


    def clear(self, *args):
        """clear(Fl_Browser self)"""
        return _fltk.Fl_Browser_clear(self, *args)


    def size(self, *args):
        """
        size(Fl_Browser self) -> int
        size(Fl_Browser self, int W, int H)
        """
        return _fltk.Fl_Browser_size(self, *args)

    TOP = _fltk.Fl_Browser_TOP
    BOTTOM = _fltk.Fl_Browser_BOTTOM
    MIDDLE = _fltk.Fl_Browser_MIDDLE

    def lineposition(self, *args):
        """lineposition(Fl_Browser self, int line, Fl_Browser::Fl_Line_Position pos)"""
        return _fltk.Fl_Browser_lineposition(self, *args)


    def topline(self, *args):
        """
        topline(Fl_Browser self) -> int
        topline(Fl_Browser self, int line)
        """
        return _fltk.Fl_Browser_topline(self, *args)


    def bottomline(self, *args):
        """bottomline(Fl_Browser self, int line)"""
        return _fltk.Fl_Browser_bottomline(self, *args)


    def middleline(self, *args):
        """middleline(Fl_Browser self, int line)"""
        return _fltk.Fl_Browser_middleline(self, *args)


    def select(self, *args):
        """select(Fl_Browser self, int line, int val=1) -> int"""
        return _fltk.Fl_Browser_select(self, *args)


    def selected(self, *args):
        """selected(Fl_Browser self, int line) -> int"""
        return _fltk.Fl_Browser_selected(self, *args)


    def show(self, *args):
        """
        show(Fl_Browser self, int line)
        show(Fl_Browser self)
        """
        return _fltk.Fl_Browser_show(self, *args)


    def hide(self, *args):
        """
        hide(Fl_Browser self, int line)
        hide(Fl_Browser self)
        """
        return _fltk.Fl_Browser_hide(self, *args)


    def visible(self, *args):
        """visible(Fl_Browser self, int line) -> int"""
        return _fltk.Fl_Browser_visible(self, *args)


    def value(self, *args):
        """
        value(Fl_Browser self) -> int
        value(Fl_Browser self, int line)
        """
        return _fltk.Fl_Browser_value(self, *args)


    def text(self, *args):
        """
        text(Fl_Browser self, int line) -> char const
        text(Fl_Browser self, int line, char const * newtext)
        """
        return _fltk.Fl_Browser_text(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Browser self, int X, int Y, int W, int H, char const * L=None) -> Fl_Browser"""
        if self.__class__ == Fl_Browser:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Browser(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Browser
    __del__ = lambda self: None

    def format_char(self, *args):
        """
        format_char(Fl_Browser self) -> char
        format_char(Fl_Browser self, char c)
        """
        return _fltk.Fl_Browser_format_char(self, *args)


    def column_char(self, *args):
        """
        column_char(Fl_Browser self) -> char
        column_char(Fl_Browser self, char c)
        """
        return _fltk.Fl_Browser_column_char(self, *args)


    def displayed(self, *args):
        """displayed(Fl_Browser self, int line) -> int"""
        return _fltk.Fl_Browser_displayed(self, *args)


    def make_visible(self, *args):
        """make_visible(Fl_Browser self, int line)"""
        return _fltk.Fl_Browser_make_visible(self, *args)


    def icon(self, *args):
        """
        icon(Fl_Browser self, int line, Fl_Image icon)
        icon(Fl_Browser self, int line) -> Fl_Image
        """
        return _fltk.Fl_Browser_icon(self, *args)


    def remove_icon(self, *args):
        """remove_icon(Fl_Browser self, int line)"""
        return _fltk.Fl_Browser_remove_icon(self, *args)


    def replace(self, *args):
        """replace(Fl_Browser self, int a, char const * b)"""
        return _fltk.Fl_Browser_replace(self, *args)


    def display(self, *args):
        """display(Fl_Browser self, int line, int val=1)"""
        return _fltk.Fl_Browser_display(self, *args)


    def add(self, *args):
        """add(Fl_Browser self, char const * text, PyObject * data=None)"""
        val = _fltk.Fl_Browser_add(self, *args)

        #self = args[0]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()
        else:                       
        #give ownership back to Python
            self.this.own() 


        return val


    def insert(self, *args):
        """insert(Fl_Browser self, int index, char const * text, PyObject * data=None)"""
        return _fltk.Fl_Browser_insert(self, *args)


    def get_data(self, *args):
        """get_data(Fl_Browser self, int index) -> PyObject *"""
        return _fltk.Fl_Browser_get_data(self, *args)


    def data(self, *args):
        """data(Fl_Browser self, int index, PyObject * data=None) -> PyObject *"""
        return _fltk.Fl_Browser_data(self, *args)


    def column_widths(self, *args):
        """
        column_widths(Fl_Browser self) -> int const
        column_widths(Fl_Browser self, PyObject * widths)
        """
        return _fltk.Fl_Browser_column_widths(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Browser(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Browser self)"""
        return _fltk.Fl_Browser_draw(self, *args)


    def item_quick_height(self, *args):
        """item_quick_height(Fl_Browser self, void * item) -> int"""
        return _fltk.Fl_Browser_item_quick_height(self, *args)


    def full_width(self, *args):
        """full_width(Fl_Browser self) -> int"""
        return _fltk.Fl_Browser_full_width(self, *args)

Fl_Browser_swigregister = _fltk.Fl_Browser_swigregister
Fl_Browser_swigregister(Fl_Browser)

class Fl_File_Browser(Fl_Browser):
    """

    The Fl_File_Browser widget displays a list of filenames, optionally with 
    file-specific icons.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    FILES = _fltk.Fl_File_Browser_FILES
    DIRECTORIES = _fltk.Fl_File_Browser_DIRECTORIES

    def __init__(self, *args):
        """__init__(Fl_File_Browser self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_File_Browser"""
        if self.__class__ == Fl_File_Browser:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_File_Browser(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def iconsize(self, *args):
        """
        iconsize(Fl_File_Browser self) -> uchar
        iconsize(Fl_File_Browser self, uchar s)
        """
        return _fltk.Fl_File_Browser_iconsize(self, *args)


    def filter(self, *args):
        """
        filter(Fl_File_Browser self, char const * pattern)
        filter(Fl_File_Browser self) -> char const *
        """
        return _fltk.Fl_File_Browser_filter(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_File_Browser self) -> Fl_Fontsize
        textsize(Fl_File_Browser self, Fl_Fontsize s)
        """
        return _fltk.Fl_File_Browser_textsize(self, *args)


    def filetype(self, *args):
        """
        filetype(Fl_File_Browser self) -> int
        filetype(Fl_File_Browser self, int t)
        """
        return _fltk.Fl_File_Browser_filetype(self, *args)


    def load(self, *args):
        """load(Fl_File_Browser self, PyObject * dObj, PyObject * sObj) -> int"""
        return _fltk.Fl_File_Browser_load(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_File_Browser
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_File_Browser(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_File_Browser self)"""
        return _fltk.Fl_File_Browser_draw(self, *args)


    def item_first(self, *args):
        """item_first(Fl_File_Browser self) -> void *"""
        return _fltk.Fl_File_Browser_item_first(self, *args)


    def item_next(self, *args):
        """item_next(Fl_File_Browser self, void * item) -> void *"""
        return _fltk.Fl_File_Browser_item_next(self, *args)


    def item_prev(self, *args):
        """item_prev(Fl_File_Browser self, void * item) -> void *"""
        return _fltk.Fl_File_Browser_item_prev(self, *args)


    def item_last(self, *args):
        """item_last(Fl_File_Browser self) -> void *"""
        return _fltk.Fl_File_Browser_item_last(self, *args)


    def item_height(self, *args):
        """item_height(Fl_File_Browser self, void * item) -> int"""
        return _fltk.Fl_File_Browser_item_height(self, *args)


    def item_width(self, *args):
        """item_width(Fl_File_Browser self, void * item) -> int"""
        return _fltk.Fl_File_Browser_item_width(self, *args)


    def item_quick_height(self, *args):
        """item_quick_height(Fl_File_Browser self, void * item) -> int"""
        return _fltk.Fl_File_Browser_item_quick_height(self, *args)


    def item_draw(self, *args):
        """item_draw(Fl_File_Browser self, void * item, int X, int Y, int W, int H)"""
        return _fltk.Fl_File_Browser_item_draw(self, *args)


    def item_text(self, *args):
        """item_text(Fl_File_Browser self, void * item) -> char const *"""
        return _fltk.Fl_File_Browser_item_text(self, *args)


    def item_swap(self, *args):
        """item_swap(Fl_File_Browser self, void * a, void * b)"""
        return _fltk.Fl_File_Browser_item_swap(self, *args)


    def item_at(self, *args):
        """item_at(Fl_File_Browser self, int line) -> void *"""
        return _fltk.Fl_File_Browser_item_at(self, *args)


    def full_width(self, *args):
        """full_width(Fl_File_Browser self) -> int"""
        return _fltk.Fl_File_Browser_full_width(self, *args)


    def full_height(self, *args):
        """full_height(Fl_File_Browser self) -> int"""
        return _fltk.Fl_File_Browser_full_height(self, *args)


    def incr_height(self, *args):
        """incr_height(Fl_File_Browser self) -> int"""
        return _fltk.Fl_File_Browser_incr_height(self, *args)


    def item_select(self, *args):
        """item_select(Fl_File_Browser self, void * item, int val)"""
        return _fltk.Fl_File_Browser_item_select(self, *args)


    def item_selected(self, *args):
        """item_selected(Fl_File_Browser self, void * item) -> int"""
        return _fltk.Fl_File_Browser_item_selected(self, *args)

Fl_File_Browser_swigregister = _fltk.Fl_File_Browser_swigregister
Fl_File_Browser_swigregister(Fl_File_Browser)


_fltk.FL_ALPHASORT_swigconstant(_fltk)
FL_ALPHASORT = _fltk.FL_ALPHASORT

_fltk.FL_CASEALPHASORT_swigconstant(_fltk)
FL_CASEALPHASORT = _fltk.FL_CASEALPHASORT

_fltk.FL_CASENUMERICSORT_swigconstant(_fltk)
FL_CASENUMERICSORT = _fltk.FL_CASENUMERICSORT

_fltk.FL_NUMERICSORT_swigconstant(_fltk)
FL_NUMERICSORT = _fltk.FL_NUMERICSORT
class Fl_File_Icon(object):
    """

    The Fl_File_Icon class manages icon images that can be used as labels in 
    other widgets and as icons in the FileBrowser widget.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ANY = _fltk.Fl_File_Icon_ANY
    PLAIN = _fltk.Fl_File_Icon_PLAIN
    FIFO = _fltk.Fl_File_Icon_FIFO
    DEVICE = _fltk.Fl_File_Icon_DEVICE
    LINK = _fltk.Fl_File_Icon_LINK
    DIRECTORY = _fltk.Fl_File_Icon_DIRECTORY
    END = _fltk.Fl_File_Icon_END
    COLOR = _fltk.Fl_File_Icon_COLOR
    LINE = _fltk.Fl_File_Icon_LINE
    CLOSEDLINE = _fltk.Fl_File_Icon_CLOSEDLINE
    POLYGON = _fltk.Fl_File_Icon_POLYGON
    OUTLINEPOLYGON = _fltk.Fl_File_Icon_OUTLINEPOLYGON
    VERTEX = _fltk.Fl_File_Icon_VERTEX

    def __init__(self, *args):
        """__init__(Fl_File_Icon self, char const * p, int t, int nd=0, short * d=None) -> Fl_File_Icon"""
        this = _fltk.new_Fl_File_Icon(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_File_Icon
    __del__ = lambda self: None

    def add(self, *args):
        """add(Fl_File_Icon self, short d) -> short *"""
        return _fltk.Fl_File_Icon_add(self, *args)


    def add_color(self, *args):
        """add_color(Fl_File_Icon self, Fl_Color c) -> short *"""
        return _fltk.Fl_File_Icon_add_color(self, *args)


    def add_vertex(self, *args):
        """
        add_vertex(Fl_File_Icon self, int x, int y) -> short
        add_vertex(Fl_File_Icon self, float x, float y) -> short *
        """
        return _fltk.Fl_File_Icon_add_vertex(self, *args)


    def clear(self, *args):
        """clear(Fl_File_Icon self)"""
        return _fltk.Fl_File_Icon_clear(self, *args)


    def draw(self, *args):
        """draw(Fl_File_Icon self, int x, int y, int w, int h, Fl_Color ic, int active=1)"""
        return _fltk.Fl_File_Icon_draw(self, *args)


    def label(self, *args):
        """label(Fl_File_Icon self, Fl_Widget w)"""
        return _fltk.Fl_File_Icon_label(self, *args)


    def labeltype(*args):
        """labeltype(Fl_Label o, int x, int y, int w, int h, Fl_Align a)"""
        return _fltk.Fl_File_Icon_labeltype(*args)

    labeltype = staticmethod(labeltype)

    def load(self, *args):
        """load(Fl_File_Icon self, char const * f)"""
        return _fltk.Fl_File_Icon_load(self, *args)


    def load_fti(self, *args):
        """load_fti(Fl_File_Icon self, char const * fti) -> int"""
        return _fltk.Fl_File_Icon_load_fti(self, *args)


    def load_image(self, *args):
        """load_image(Fl_File_Icon self, char const * i) -> int"""
        return _fltk.Fl_File_Icon_load_image(self, *args)


    def next(self, *args):
        """next(Fl_File_Icon self) -> Fl_File_Icon"""
        return _fltk.Fl_File_Icon_next(self, *args)


    def pattern(self, *args):
        """pattern(Fl_File_Icon self) -> char const *"""
        return _fltk.Fl_File_Icon_pattern(self, *args)


    def size(self, *args):
        """size(Fl_File_Icon self) -> int"""
        return _fltk.Fl_File_Icon_size(self, *args)


    def type(self, *args):
        """type(Fl_File_Icon self) -> int"""
        return _fltk.Fl_File_Icon_type(self, *args)


    def value(self, *args):
        """value(Fl_File_Icon self) -> short *"""
        return _fltk.Fl_File_Icon_value(self, *args)


    def find(*args):
        """find(char const * filename, int filetype) -> Fl_File_Icon"""
        return _fltk.Fl_File_Icon_find(*args)

    find = staticmethod(find)

    def first(*args):
        """first() -> Fl_File_Icon"""
        return _fltk.Fl_File_Icon_first(*args)

    first = staticmethod(first)

    def load_system_icons(*args):
        """load_system_icons()"""
        return _fltk.Fl_File_Icon_load_system_icons(*args)

    load_system_icons = staticmethod(load_system_icons)
Fl_File_Icon_swigregister = _fltk.Fl_File_Icon_swigregister
Fl_File_Icon_swigregister(Fl_File_Icon)

def Fl_File_Icon_labeltype(*args):
    """Fl_File_Icon_labeltype(Fl_Label o, int x, int y, int w, int h, Fl_Align a)"""
    return _fltk.Fl_File_Icon_labeltype(*args)

def Fl_File_Icon_find(*args):
    """Fl_File_Icon_find(char const * filename, int filetype) -> Fl_File_Icon"""
    return _fltk.Fl_File_Icon_find(*args)

def Fl_File_Icon_first(*args):
    """Fl_File_Icon_first() -> Fl_File_Icon"""
    return _fltk.Fl_File_Icon_first(*args)

def Fl_File_Icon_load_system_icons(*args):
    """Fl_File_Icon_load_system_icons()"""
    return _fltk.Fl_File_Icon_load_system_icons(*args)

class Fl_File_Chooser(object):
    """

    The Fl_File_Chooser widget displays a standard file selection dialog that 
    supports various selection modes.

    The Fl_File_Chooser class also exports several static values that may be used 
    to localize or customize the appearance of all file chooser dialogs:
    Member 	Default value
    add_favorites_label 	'Add to Favorites'
    all_files_label 	'All Files (*)'
    custom_filter_label 	'Custom Filter'
    existing_file_label 	'Please choose an existing file!'
    favorites_label 	'Favorites'
    filename_label 		'Filename:'
    filesystems_label 	'My Computer' (WIN32)
    			'File Systems' (all others)
    manage_favorites_label 	'Manage Favorites'
    new_directory_label 	'New Directory?'
    new_directory_tooltip 	'Create a new directory.'
    preview_label 		'Preview'
    save_label 		'Save'
    show_label 		'Show:'
    sort 			fl_numericsort

    The sort member specifies the sort function that is used when loading the 
    contents of a directory. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    SINGLE = _fltk.Fl_File_Chooser_SINGLE
    MULTI = _fltk.Fl_File_Chooser_MULTI
    CREATE = _fltk.Fl_File_Chooser_CREATE
    DIRECTORY = _fltk.Fl_File_Chooser_DIRECTORY

    def __init__(self, *args):
        """__init__(Fl_File_Chooser self, char const * d, char const * p, int t, char const * title) -> Fl_File_Chooser"""
        this = _fltk.new_Fl_File_Chooser(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_File_Chooser
    __del__ = lambda self: None

    def color(self, *args):
        """
        color(Fl_File_Chooser self, Fl_Color c)
        color(Fl_File_Chooser self) -> Fl_Color
        """
        return _fltk.Fl_File_Chooser_color(self, *args)


    def count(self, *args):
        """count(Fl_File_Chooser self) -> int"""
        return _fltk.Fl_File_Chooser_count(self, *args)


    def directory(self, *args):
        """
        directory(Fl_File_Chooser self, char const * d)
        directory(Fl_File_Chooser self) -> char *
        """
        return _fltk.Fl_File_Chooser_directory(self, *args)


    def filter(self, *args):
        """
        filter(Fl_File_Chooser self, char const * p)
        filter(Fl_File_Chooser self) -> char const *
        """
        return _fltk.Fl_File_Chooser_filter(self, *args)


    def filter_value(self, *args):
        """
        filter_value(Fl_File_Chooser self) -> int
        filter_value(Fl_File_Chooser self, int f)
        """
        return _fltk.Fl_File_Chooser_filter_value(self, *args)


    def hide(self, *args):
        """hide(Fl_File_Chooser self)"""
        return _fltk.Fl_File_Chooser_hide(self, *args)


    def iconsize(self, *args):
        """
        iconsize(Fl_File_Chooser self, uchar s)
        iconsize(Fl_File_Chooser self) -> uchar
        """
        return _fltk.Fl_File_Chooser_iconsize(self, *args)


    def label(self, *args):
        """
        label(Fl_File_Chooser self, char const * l)
        label(Fl_File_Chooser self) -> char const *
        """
        return _fltk.Fl_File_Chooser_label(self, *args)


    def ok_label(self, *args):
        """
        ok_label(Fl_File_Chooser self, char const * l)
        ok_label(Fl_File_Chooser self) -> char const *
        """
        return _fltk.Fl_File_Chooser_ok_label(self, *args)


    def preview(self, *args):
        """
        preview(Fl_File_Chooser self, int e)
        preview(Fl_File_Chooser self) -> int
        """
        return _fltk.Fl_File_Chooser_preview(self, *args)


    def rescan(self, *args):
        """rescan(Fl_File_Chooser self)"""
        return _fltk.Fl_File_Chooser_rescan(self, *args)


    def show(self, *args):
        """show(Fl_File_Chooser self)"""
        return _fltk.Fl_File_Chooser_show(self, *args)


    def shown(self, *args):
        """shown(Fl_File_Chooser self) -> int"""
        return _fltk.Fl_File_Chooser_shown(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_File_Chooser self, Fl_Color c)
        textcolor(Fl_File_Chooser self) -> Fl_Color
        """
        return _fltk.Fl_File_Chooser_textcolor(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_File_Chooser self, Fl_Font f)
        textfont(Fl_File_Chooser self) -> Fl_Font
        """
        return _fltk.Fl_File_Chooser_textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_File_Chooser self, Fl_Fontsize s)
        textsize(Fl_File_Chooser self) -> Fl_Fontsize
        """
        return _fltk.Fl_File_Chooser_textsize(self, *args)


    def type(self, *args):
        """
        type(Fl_File_Chooser self, int t)
        type(Fl_File_Chooser self) -> int
        """
        return _fltk.Fl_File_Chooser_type(self, *args)


    def user_data(self, *args):
        """
        user_data(Fl_File_Chooser self)
        user_data(Fl_File_Chooser self, void * d)
        """
        return _fltk.Fl_File_Chooser_user_data(self, *args)


    def value(self, *args):
        """
        value(Fl_File_Chooser self, int f=1) -> char const
        value(Fl_File_Chooser self, char const * filename)
        """
        return _fltk.Fl_File_Chooser_value(self, *args)


    def visible(self, *args):
        """visible(Fl_File_Chooser self) -> int"""
        return _fltk.Fl_File_Chooser_visible(self, *args)


    def add_extra(self, *args):
        """add_extra(Fl_File_Chooser self, Fl_Widget gr) -> Fl_Widget"""
        return _fltk.Fl_File_Chooser_add_extra(self, *args)


    def callback(self, *args):
        """
        callback(Fl_File_Chooser self, void (*)(Fl_File_Chooser *,void *) cb, void * d=None)
        callback(Fl_File_Chooser self, PyObject * PyFunc, PyObject * PyWidget, PyObject * PyData=None)
        """
        return _fltk.Fl_File_Chooser_callback(self, *args)

Fl_File_Chooser_swigregister = _fltk.Fl_File_Chooser_swigregister
Fl_File_Chooser_swigregister(Fl_File_Chooser)


def fl_dir_chooser(*args):
    """fl_dir_chooser(char const * message, char const * fname, int relative=0) -> char *"""
    return _fltk.fl_dir_chooser(*args)

def fl_file_chooser(*args):
    """fl_file_chooser(char const * message, char const * pat, char const * fname, int relative=0) -> char *"""
    return _fltk.fl_file_chooser(*args)

def fl_file_chooser_callback(*args):
    """fl_file_chooser_callback(void (*)(char const *) cb)"""
    return _fltk.fl_file_chooser_callback(*args)

def fl_file_chooser_ok_label(*args):
    """fl_file_chooser_ok_label(char const * l)"""
    return _fltk.fl_file_chooser_ok_label(*args)
class Fl(object):
    """
    The Fl class is the FLTK global (static) class containing state 
    information and global methods for the current application.
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def call_screen_init(*args):
        """call_screen_init()"""
        return _fltk.Fl_call_screen_init(*args)

    call_screen_init = staticmethod(call_screen_init)
    OPTION_ARROW_FOCUS = _fltk.Fl_OPTION_ARROW_FOCUS
    OPTION_VISIBLE_FOCUS = _fltk.Fl_OPTION_VISIBLE_FOCUS
    OPTION_DND_TEXT = _fltk.Fl_OPTION_DND_TEXT
    OPTION_SHOW_TOOLTIPS = _fltk.Fl_OPTION_SHOW_TOOLTIPS
    OPTION_FNFC_USES_GTK = _fltk.Fl_OPTION_FNFC_USES_GTK
    OPTION_LAST = _fltk.Fl_OPTION_LAST

    def option(*args):
        """
        option(Fl::Fl_Option opt) -> bool
        option(Fl::Fl_Option opt, bool val)
        """
        return _fltk.Fl_option(*args)

    option = staticmethod(option)

    def add_awake_handler_(*args):
        """add_awake_handler_(Fl_Awake_Handler arg1, void * arg2) -> int"""
        return _fltk.Fl_add_awake_handler_(*args)

    add_awake_handler_ = staticmethod(add_awake_handler_)

    def version(*args):
        """version() -> double"""
        return _fltk.Fl_version(*args)

    version = staticmethod(version)

    def arg(*args):
        """arg(int argc, char ** argv, int & i) -> int"""
        return _fltk.Fl_arg(*args)

    arg = staticmethod(arg)

    def args(*args):
        """
        args(int argc, char ** argv, int & i, Fl_Args_Handler cb=None) -> int
        args(int argc, char ** argv)
        """
        return _fltk.Fl_args(*args)

    args = staticmethod(args)

    def display(*args):
        """display(char const * arg1)"""
        return _fltk.Fl_display(*args)

    display = staticmethod(display)

    def visual(*args):
        """visual(int arg1) -> int"""
        return _fltk.Fl_visual(*args)

    visual = staticmethod(visual)

    def own_colormap(*args):
        """own_colormap()"""
        return _fltk.Fl_own_colormap(*args)

    own_colormap = staticmethod(own_colormap)

    def get_system_colors(*args):
        """get_system_colors()"""
        return _fltk.Fl_get_system_colors(*args)

    get_system_colors = staticmethod(get_system_colors)

    def foreground(*args):
        """foreground(uchar arg1, uchar arg2, uchar arg3)"""
        return _fltk.Fl_foreground(*args)

    foreground = staticmethod(foreground)

    def background(*args):
        """background(uchar arg1, uchar arg2, uchar arg3)"""
        return _fltk.Fl_background(*args)

    background = staticmethod(background)

    def background2(*args):
        """background2(uchar arg1, uchar arg2, uchar arg3)"""
        return _fltk.Fl_background2(*args)

    background2 = staticmethod(background2)

    def scheme(*args):
        """
        scheme(char const * name) -> int
        scheme() -> char const *
        """
        return _fltk.Fl_scheme(*args)

    scheme = staticmethod(scheme)

    def is_scheme(*args):
        """is_scheme(char const * name) -> int"""
        return _fltk.Fl_is_scheme(*args)

    is_scheme = staticmethod(is_scheme)

    def reload_scheme(*args):
        """reload_scheme() -> int"""
        return _fltk.Fl_reload_scheme(*args)

    reload_scheme = staticmethod(reload_scheme)

    def scrollbar_size(*args):
        """
        scrollbar_size() -> int
        scrollbar_size(int W)
        """
        return _fltk.Fl_scrollbar_size(*args)

    scrollbar_size = staticmethod(scrollbar_size)

    def wait(*args):
        """
        wait() -> int
        wait(double time) -> double
        """
        return _fltk.Fl_wait(*args)

    wait = staticmethod(wait)

    def check(*args):
        """check() -> int"""
        return _fltk.Fl_check(*args)

    check = staticmethod(check)

    def ready(*args):
        """ready() -> int"""
        return _fltk.Fl_ready(*args)

    ready = staticmethod(ready)

    def run(*args):
        """run() -> int"""
        return _fltk.Fl_run(*args)

    run = staticmethod(run)

    def readqueue(*args):
        """readqueue() -> Fl_Widget"""
        return _fltk.Fl_readqueue(*args)

    readqueue = staticmethod(readqueue)

    def has_timeout(*args):
        """has_timeout(Fl_Timeout_Handler arg1, void * arg2=None) -> int"""
        return _fltk.Fl_has_timeout(*args)

    has_timeout = staticmethod(has_timeout)

    def add_idle(*args):
        """add_idle(Fl_Idle_Handler cb, void * data=None)"""
        return _fltk.Fl_add_idle(*args)

    add_idle = staticmethod(add_idle)

    def has_idle(*args):
        """has_idle(Fl_Idle_Handler cb, void * data=None) -> int"""
        return _fltk.Fl_has_idle(*args)

    has_idle = staticmethod(has_idle)

    def remove_idle(*args):
        """remove_idle(Fl_Idle_Handler cb, void * data=None)"""
        return _fltk.Fl_remove_idle(*args)

    remove_idle = staticmethod(remove_idle)

    def damage(*args):
        """
        damage(int d)
        damage() -> int
        """
        return _fltk.Fl_damage(*args)

    damage = staticmethod(damage)

    def redraw(*args):
        """redraw()"""
        return _fltk.Fl_redraw(*args)

    redraw = staticmethod(redraw)

    def flush(*args):
        """flush()"""
        return _fltk.Fl_flush(*args)

    flush = staticmethod(flush)

    def first_window(*args):
        """
        first_window() -> Fl_Window
        first_window(Fl_Window arg1)
        """
        return _fltk.Fl_first_window(*args)

    first_window = staticmethod(first_window)

    def next_window(*args):
        """next_window(Fl_Window arg1) -> Fl_Window"""
        return _fltk.Fl_next_window(*args)

    next_window = staticmethod(next_window)

    def modal(*args):
        """modal() -> Fl_Window"""
        return _fltk.Fl_modal(*args)

    modal = staticmethod(modal)

    def grab(*args):
        """
        grab() -> Fl_Window
        grab(Fl_Window arg1)
        """
        return _fltk.Fl_grab(*args)

    grab = staticmethod(grab)

    def event(*args):
        """event() -> int"""
        return _fltk.Fl_event(*args)

    event = staticmethod(event)

    def event_x(*args):
        """event_x() -> int"""
        return _fltk.Fl_event_x(*args)

    event_x = staticmethod(event_x)

    def event_y(*args):
        """event_y() -> int"""
        return _fltk.Fl_event_y(*args)

    event_y = staticmethod(event_y)

    def event_x_root(*args):
        """event_x_root() -> int"""
        return _fltk.Fl_event_x_root(*args)

    event_x_root = staticmethod(event_x_root)

    def event_y_root(*args):
        """event_y_root() -> int"""
        return _fltk.Fl_event_y_root(*args)

    event_y_root = staticmethod(event_y_root)

    def event_dx(*args):
        """event_dx() -> int"""
        return _fltk.Fl_event_dx(*args)

    event_dx = staticmethod(event_dx)

    def event_dy(*args):
        """event_dy() -> int"""
        return _fltk.Fl_event_dy(*args)

    event_dy = staticmethod(event_dy)

    def get_mouse(*args):
        """get_mouse(int & arg1, int & arg2)"""
        return _fltk.Fl_get_mouse(*args)

    get_mouse = staticmethod(get_mouse)

    def event_clicks(*args):
        """
        event_clicks() -> int
        event_clicks(int i)
        """
        return _fltk.Fl_event_clicks(*args)

    event_clicks = staticmethod(event_clicks)

    def event_is_click(*args):
        """
        event_is_click() -> int
        event_is_click(int i)
        """
        return _fltk.Fl_event_is_click(*args)

    event_is_click = staticmethod(event_is_click)

    def event_button(*args):
        """event_button() -> int"""
        return _fltk.Fl_event_button(*args)

    event_button = staticmethod(event_button)

    def event_state(*args):
        """
        event_state() -> int
        event_state(int i) -> int
        """
        return _fltk.Fl_event_state(*args)

    event_state = staticmethod(event_state)

    def event_original_key(*args):
        """event_original_key() -> int"""
        return _fltk.Fl_event_original_key(*args)

    event_original_key = staticmethod(event_original_key)

    def event_key(*args):
        """
        event_key() -> int
        event_key(int key) -> int
        """
        return _fltk.Fl_event_key(*args)

    event_key = staticmethod(event_key)

    def get_key(*args):
        """get_key(int key) -> int"""
        return _fltk.Fl_get_key(*args)

    get_key = staticmethod(get_key)

    def event_text(*args):
        """event_text() -> char const *"""
        return _fltk.Fl_event_text(*args)

    event_text = staticmethod(event_text)

    def event_length(*args):
        """event_length() -> int"""
        return _fltk.Fl_event_length(*args)

    event_length = staticmethod(event_length)

    def event_clipboard(*args):
        """event_clipboard() -> void *"""
        return _fltk.Fl_event_clipboard(*args)

    event_clipboard = staticmethod(event_clipboard)

    def event_clipboard_type(*args):
        """event_clipboard_type() -> char const *"""
        return _fltk.Fl_event_clipboard_type(*args)

    event_clipboard_type = staticmethod(event_clipboard_type)

    def compose(*args):
        """compose(int & arg1) -> int"""
        return _fltk.Fl_compose(*args)

    compose = staticmethod(compose)

    def compose_reset(*args):
        """compose_reset()"""
        return _fltk.Fl_compose_reset(*args)

    compose_reset = staticmethod(compose_reset)

    def event_inside(*args):
        """
        event_inside(int arg1, int arg2, int arg3, int arg4) -> int
        event_inside(Fl_Widget arg1) -> int
        """
        return _fltk.Fl_event_inside(*args)

    event_inside = staticmethod(event_inside)

    def test_shortcut(*args):
        """test_shortcut(Fl_Shortcut arg1) -> int"""
        return _fltk.Fl_test_shortcut(*args)

    test_shortcut = staticmethod(test_shortcut)

    def enable_im(*args):
        """enable_im()"""
        return _fltk.Fl_enable_im(*args)

    enable_im = staticmethod(enable_im)

    def disable_im(*args):
        """disable_im()"""
        return _fltk.Fl_disable_im(*args)

    disable_im = staticmethod(disable_im)

    def handle(*args):
        """handle(int arg1, Fl_Window arg2) -> int"""
        return _fltk.Fl_handle(*args)

    handle = staticmethod(handle)

    def handle_(*args):
        """handle_(int arg1, Fl_Window arg2) -> int"""
        return _fltk.Fl_handle_(*args)

    handle_ = staticmethod(handle_)

    def belowmouse(*args):
        """
        belowmouse() -> Fl_Widget
        belowmouse(Fl_Widget arg1)
        """
        return _fltk.Fl_belowmouse(*args)

    belowmouse = staticmethod(belowmouse)

    def pushed(*args):
        """
        pushed() -> Fl_Widget
        pushed(Fl_Widget arg1)
        """
        return _fltk.Fl_pushed(*args)

    pushed = staticmethod(pushed)

    def focus(*args):
        """
        focus() -> Fl_Widget
        focus(Fl_Widget arg1)
        """
        return _fltk.Fl_focus(*args)

    focus = staticmethod(focus)

    def add_system_handler(*args):
        """add_system_handler(Fl_System_Handler h, void * data)"""
        return _fltk.Fl_add_system_handler(*args)

    add_system_handler = staticmethod(add_system_handler)

    def remove_system_handler(*args):
        """remove_system_handler(Fl_System_Handler h)"""
        return _fltk.Fl_remove_system_handler(*args)

    remove_system_handler = staticmethod(remove_system_handler)

    def event_dispatch(*args):
        """
        event_dispatch(Fl_Event_Dispatch d)
        event_dispatch() -> Fl_Event_Dispatch
        """
        return _fltk.Fl_event_dispatch(*args)

    event_dispatch = staticmethod(event_dispatch)

    def copy(*args):
        """
        copy(char const * stuff, int len, int destination, char const * type)
        copy(char const * stuff, int len, int destination=0)
        """
        return _fltk.Fl_copy(*args)

    copy = staticmethod(copy)

    def add_clipboard_notify(*args):
        """add_clipboard_notify(Fl_Clipboard_Notify_Handler h, void * data=None)"""
        return _fltk.Fl_add_clipboard_notify(*args)

    add_clipboard_notify = staticmethod(add_clipboard_notify)

    def remove_clipboard_notify(*args):
        """remove_clipboard_notify(Fl_Clipboard_Notify_Handler h)"""
        return _fltk.Fl_remove_clipboard_notify(*args)

    remove_clipboard_notify = staticmethod(remove_clipboard_notify)

    def clipboard_contains(*args):
        """clipboard_contains(char const * type) -> int"""
        return _fltk.Fl_clipboard_contains(*args)

    clipboard_contains = staticmethod(clipboard_contains)

    def dnd(*args):
        """dnd() -> int"""
        return _fltk.Fl_dnd(*args)

    dnd = staticmethod(dnd)

    def selection_owner(*args):
        """
        selection_owner() -> Fl_Widget
        selection_owner(Fl_Widget arg1)
        """
        return _fltk.Fl_selection_owner(*args)

    selection_owner = staticmethod(selection_owner)

    def selection(*args):
        """selection(Fl_Widget owner, char const * arg2, int len)"""
        return _fltk.Fl_selection(*args)

    selection = staticmethod(selection)

    def paste(*args):
        """
        paste(Fl_Widget receiver, int source, char const * type)
        paste(Fl_Widget receiver, int source)
        paste(Fl_Widget receiver)
        """
        return _fltk.Fl_paste(*args)

    paste = staticmethod(paste)

    def x(*args):
        """x() -> int"""
        return _fltk.Fl_x(*args)

    x = staticmethod(x)

    def y(*args):
        """y() -> int"""
        return _fltk.Fl_y(*args)

    y = staticmethod(y)

    def w(*args):
        """w() -> int"""
        return _fltk.Fl_w(*args)

    w = staticmethod(w)

    def h(*args):
        """h() -> int"""
        return _fltk.Fl_h(*args)

    h = staticmethod(h)

    def screen_count(*args):
        """screen_count() -> int"""
        return _fltk.Fl_screen_count(*args)

    screen_count = staticmethod(screen_count)

    def screen_xywh(*args):
        """
        screen_xywh(int & X, int & Y, int & W, int & H)
        screen_xywh(int & X, int & Y, int & W, int & H, int mx, int my)
        screen_xywh(int & X, int & Y, int & W, int & H, int n)
        screen_xywh(int & X, int & Y, int & W, int & H, int mx, int my, int mw, int mh)
        """
        return _fltk.Fl_screen_xywh(*args)

    screen_xywh = staticmethod(screen_xywh)

    def screen_num(*args):
        """
        screen_num(int x, int y) -> int
        screen_num(int x, int y, int w, int h) -> int
        """
        return _fltk.Fl_screen_num(*args)

    screen_num = staticmethod(screen_num)

    def screen_dpi(*args):
        """screen_dpi(float & h, float & v, int n=0)"""
        return _fltk.Fl_screen_dpi(*args)

    screen_dpi = staticmethod(screen_dpi)

    def screen_work_area(*args):
        """
        screen_work_area(int & X, int & Y, int & W, int & H, int mx, int my)
        screen_work_area(int & X, int & Y, int & W, int & H, int n)
        screen_work_area(int & X, int & Y, int & W, int & H)
        """
        return _fltk.Fl_screen_work_area(*args)

    screen_work_area = staticmethod(screen_work_area)

    def set_color(*args):
        """
        set_color(Fl_Color arg1, uchar arg2, uchar arg3, uchar arg4)
        set_color(Fl_Color i, unsigned int c)
        """
        return _fltk.Fl_set_color(*args)

    set_color = staticmethod(set_color)

    def get_color(*args):
        """get_color(Fl_Color i)"""
        return _fltk.Fl_get_color(*args)

    get_color = staticmethod(get_color)

    def free_color(*args):
        """free_color(Fl_Color i, int overlay=0)"""
        return _fltk.Fl_free_color(*args)

    free_color = staticmethod(free_color)

    def get_font(*args):
        """get_font(Fl_Font arg1) -> char const *"""
        return _fltk.Fl_get_font(*args)

    get_font = staticmethod(get_font)

    def get_font_name(*args):
        """get_font_name(Fl_Font arg1) -> char const *"""
        return _fltk.Fl_get_font_name(*args)

    get_font_name = staticmethod(get_font_name)

    def set_font(*args):
        """
        set_font(Fl_Font arg1, char const * arg2)
        set_font(Fl_Font arg1, Fl_Font arg2)
        """
        return _fltk.Fl_set_font(*args)

    set_font = staticmethod(set_font)

    def set_fonts(*args):
        """set_fonts(char const * arg1=None) -> Fl_Font"""
        return _fltk.Fl_set_fonts(*args)

    set_fonts = staticmethod(set_fonts)

    def set_labeltype(*args):
        """set_labeltype(Fl_Labeltype arg1, Fl_Label_Draw_F * arg2, Fl_Label_Measure_F * arg3)"""
        return _fltk.Fl_set_labeltype(*args)

    set_labeltype = staticmethod(set_labeltype)

    def get_boxtype(*args):
        """get_boxtype(Fl_Boxtype arg1) -> Fl_Box_Draw_F *"""
        return _fltk.Fl_get_boxtype(*args)

    get_boxtype = staticmethod(get_boxtype)

    def set_boxtype(*args):
        """
        set_boxtype(Fl_Boxtype arg1, Fl_Box_Draw_F * arg2, uchar arg3, uchar arg4, uchar arg5, uchar arg6)
        set_boxtype(Fl_Boxtype arg1, Fl_Boxtype arg2)
        """
        return _fltk.Fl_set_boxtype(*args)

    set_boxtype = staticmethod(set_boxtype)

    def box_dx(*args):
        """box_dx(Fl_Boxtype arg1) -> int"""
        return _fltk.Fl_box_dx(*args)

    box_dx = staticmethod(box_dx)

    def box_dy(*args):
        """box_dy(Fl_Boxtype arg1) -> int"""
        return _fltk.Fl_box_dy(*args)

    box_dy = staticmethod(box_dy)

    def box_dw(*args):
        """box_dw(Fl_Boxtype arg1) -> int"""
        return _fltk.Fl_box_dw(*args)

    box_dw = staticmethod(box_dw)

    def box_dh(*args):
        """box_dh(Fl_Boxtype arg1) -> int"""
        return _fltk.Fl_box_dh(*args)

    box_dh = staticmethod(box_dh)

    def draw_box_active(*args):
        """draw_box_active() -> int"""
        return _fltk.Fl_draw_box_active(*args)

    draw_box_active = staticmethod(draw_box_active)

    def set_abort(*args):
        """set_abort(Fl_Abort_Handler f)"""
        return _fltk.Fl_set_abort(*args)

    set_abort = staticmethod(set_abort)

    def default_atclose(*args):
        """default_atclose(Fl_Window arg1, void * arg2)"""
        return _fltk.Fl_default_atclose(*args)

    default_atclose = staticmethod(default_atclose)

    def set_atclose(*args):
        """set_atclose(Fl_Atclose_Handler f)"""
        return _fltk.Fl_set_atclose(*args)

    set_atclose = staticmethod(set_atclose)

    def event_shift(*args):
        """event_shift() -> int"""
        return _fltk.Fl_event_shift(*args)

    event_shift = staticmethod(event_shift)

    def event_ctrl(*args):
        """event_ctrl() -> int"""
        return _fltk.Fl_event_ctrl(*args)

    event_ctrl = staticmethod(event_ctrl)

    def event_command(*args):
        """event_command() -> int"""
        return _fltk.Fl_event_command(*args)

    event_command = staticmethod(event_command)

    def event_alt(*args):
        """event_alt() -> int"""
        return _fltk.Fl_event_alt(*args)

    event_alt = staticmethod(event_alt)

    def event_buttons(*args):
        """event_buttons() -> int"""
        return _fltk.Fl_event_buttons(*args)

    event_buttons = staticmethod(event_buttons)

    def event_button1(*args):
        """event_button1() -> int"""
        return _fltk.Fl_event_button1(*args)

    event_button1 = staticmethod(event_button1)

    def event_button2(*args):
        """event_button2() -> int"""
        return _fltk.Fl_event_button2(*args)

    event_button2 = staticmethod(event_button2)

    def event_button3(*args):
        """event_button3() -> int"""
        return _fltk.Fl_event_button3(*args)

    event_button3 = staticmethod(event_button3)

    def set_idle(*args):
        """set_idle(Fl_Old_Idle_Handler cb)"""
        return _fltk.Fl_set_idle(*args)

    set_idle = staticmethod(set_idle)

    def release(*args):
        """release()"""
        return _fltk.Fl_release(*args)

    release = staticmethod(release)

    def visible_focus(*args):
        """
        visible_focus(int v)
        visible_focus() -> int
        """
        return _fltk.Fl_visible_focus(*args)

    visible_focus = staticmethod(visible_focus)

    def dnd_text_ops(*args):
        """
        dnd_text_ops(int v)
        dnd_text_ops() -> int
        """
        return _fltk.Fl_dnd_text_ops(*args)

    dnd_text_ops = staticmethod(dnd_text_ops)

    def delete_widget(*args):
        """delete_widget(Fl_Widget w)"""
        return _fltk.Fl_delete_widget(*args)

    delete_widget = staticmethod(delete_widget)

    def do_widget_deletion(*args):
        """do_widget_deletion()"""
        return _fltk.Fl_do_widget_deletion(*args)

    do_widget_deletion = staticmethod(do_widget_deletion)

    def watch_widget_pointer(*args):
        """watch_widget_pointer(Fl_Widget *& w)"""
        return _fltk.Fl_watch_widget_pointer(*args)

    watch_widget_pointer = staticmethod(watch_widget_pointer)

    def release_widget_pointer(*args):
        """release_widget_pointer(Fl_Widget *& w)"""
        return _fltk.Fl_release_widget_pointer(*args)

    release_widget_pointer = staticmethod(release_widget_pointer)

    def clear_widget_pointer(*args):
        """clear_widget_pointer(Fl_Widget w)"""
        return _fltk.Fl_clear_widget_pointer(*args)

    clear_widget_pointer = staticmethod(clear_widget_pointer)

    def lock(*args):
        """lock()"""
        return _fltk.Fl_lock(*args)

    lock = staticmethod(lock)

    def unlock(*args):
        """unlock()"""
        return _fltk.Fl_unlock(*args)

    unlock = staticmethod(unlock)

    def awake(*args):
        """
        awake(Fl_Awake_Handler cb, void * message=None) -> int
        awake(void * message=None)
        """
        return _fltk.Fl_awake(*args)

    awake = staticmethod(awake)

    def thread_message(*args):
        """thread_message()"""
        return _fltk.Fl_thread_message(*args)

    thread_message = staticmethod(thread_message)
    __swig_destroy__ = _fltk.delete_Fl
    __del__ = lambda self: None
Fl_swigregister = _fltk.Fl_swigregister
Fl_swigregister(Fl)

def Fl_call_screen_init(*args):
    """Fl_call_screen_init()"""
    return _fltk.Fl_call_screen_init(*args)

def Fl_option(*args):
    """
    option(Fl::Fl_Option opt) -> bool
    Fl_option(Fl::Fl_Option opt, bool val)
    """
    return _fltk.Fl_option(*args)

def Fl_add_awake_handler_(*args):
    """Fl_add_awake_handler_(Fl_Awake_Handler arg2, void * arg3) -> int"""
    return _fltk.Fl_add_awake_handler_(*args)

def Fl_version(*args):
    """Fl_version() -> double"""
    return _fltk.Fl_version(*args)

def Fl_arg(*args):
    """Fl_arg(int argc, char ** argv, int & i) -> int"""
    return _fltk.Fl_arg(*args)

def Fl_args(*args):
    """
    args(int argc, char ** argv, int & i, Fl_Args_Handler cb=None) -> int
    Fl_args(int argc, char ** argv)
    """
    return _fltk.Fl_args(*args)

def Fl_display(*args):
    """Fl_display(char const * arg2)"""
    return _fltk.Fl_display(*args)

def Fl_visual(*args):
    """Fl_visual(int arg2) -> int"""
    return _fltk.Fl_visual(*args)

def Fl_own_colormap(*args):
    """Fl_own_colormap()"""
    return _fltk.Fl_own_colormap(*args)

def Fl_get_system_colors(*args):
    """Fl_get_system_colors()"""
    return _fltk.Fl_get_system_colors(*args)

def Fl_foreground(*args):
    """Fl_foreground(uchar arg2, uchar arg3, uchar arg4)"""
    return _fltk.Fl_foreground(*args)

def Fl_background(*args):
    """Fl_background(uchar arg2, uchar arg3, uchar arg4)"""
    return _fltk.Fl_background(*args)

def Fl_background2(*args):
    """Fl_background2(uchar arg2, uchar arg3, uchar arg4)"""
    return _fltk.Fl_background2(*args)

def Fl_scheme(*args):
    """
    scheme(char const * name) -> int
    Fl_scheme() -> char const *
    """
    return _fltk.Fl_scheme(*args)

def Fl_is_scheme(*args):
    """Fl_is_scheme(char const * name) -> int"""
    return _fltk.Fl_is_scheme(*args)

def Fl_reload_scheme(*args):
    """Fl_reload_scheme() -> int"""
    return _fltk.Fl_reload_scheme(*args)

def Fl_scrollbar_size(*args):
    """
    scrollbar_size() -> int
    Fl_scrollbar_size(int W)
    """
    return _fltk.Fl_scrollbar_size(*args)

def Fl_wait(*args):
    """
    wait() -> int
    Fl_wait(double time) -> double
    """
    return _fltk.Fl_wait(*args)

def Fl_check(*args):
    """Fl_check() -> int"""
    return _fltk.Fl_check(*args)

def Fl_ready(*args):
    """Fl_ready() -> int"""
    return _fltk.Fl_ready(*args)

def Fl_run(*args):
    """Fl_run() -> int"""
    return _fltk.Fl_run(*args)

def Fl_readqueue(*args):
    """Fl_readqueue() -> Fl_Widget"""
    return _fltk.Fl_readqueue(*args)

def Fl_has_timeout(*args):
    """Fl_has_timeout(Fl_Timeout_Handler arg2, void * arg3=None) -> int"""
    return _fltk.Fl_has_timeout(*args)

def Fl_add_idle(*args):
    """Fl_add_idle(Fl_Idle_Handler cb, void * data=None)"""
    return _fltk.Fl_add_idle(*args)

def Fl_has_idle(*args):
    """Fl_has_idle(Fl_Idle_Handler cb, void * data=None) -> int"""
    return _fltk.Fl_has_idle(*args)

def Fl_remove_idle(*args):
    """Fl_remove_idle(Fl_Idle_Handler cb, void * data=None)"""
    return _fltk.Fl_remove_idle(*args)

def Fl_damage(*args):
    """
    damage(int d)
    Fl_damage() -> int
    """
    return _fltk.Fl_damage(*args)

def Fl_redraw(*args):
    """Fl_redraw()"""
    return _fltk.Fl_redraw(*args)

def Fl_flush(*args):
    """Fl_flush()"""
    return _fltk.Fl_flush(*args)

def Fl_first_window(*args):
    """
    first_window() -> Fl_Window
    Fl_first_window(Fl_Window arg2)
    """
    return _fltk.Fl_first_window(*args)

def Fl_next_window(*args):
    """Fl_next_window(Fl_Window arg2) -> Fl_Window"""
    return _fltk.Fl_next_window(*args)

def Fl_modal(*args):
    """Fl_modal() -> Fl_Window"""
    return _fltk.Fl_modal(*args)

def Fl_grab(*args):
    """
    grab() -> Fl_Window
    Fl_grab(Fl_Window arg2)
    """
    return _fltk.Fl_grab(*args)

def Fl_event(*args):
    """Fl_event() -> int"""
    return _fltk.Fl_event(*args)

def Fl_event_x(*args):
    """Fl_event_x() -> int"""
    return _fltk.Fl_event_x(*args)

def Fl_event_y(*args):
    """Fl_event_y() -> int"""
    return _fltk.Fl_event_y(*args)

def Fl_event_x_root(*args):
    """Fl_event_x_root() -> int"""
    return _fltk.Fl_event_x_root(*args)

def Fl_event_y_root(*args):
    """Fl_event_y_root() -> int"""
    return _fltk.Fl_event_y_root(*args)

def Fl_event_dx(*args):
    """Fl_event_dx() -> int"""
    return _fltk.Fl_event_dx(*args)

def Fl_event_dy(*args):
    """Fl_event_dy() -> int"""
    return _fltk.Fl_event_dy(*args)

def Fl_get_mouse(*args):
    """Fl_get_mouse(int & arg2, int & arg3)"""
    return _fltk.Fl_get_mouse(*args)

def Fl_event_clicks(*args):
    """
    event_clicks() -> int
    Fl_event_clicks(int i)
    """
    return _fltk.Fl_event_clicks(*args)

def Fl_event_is_click(*args):
    """
    event_is_click() -> int
    Fl_event_is_click(int i)
    """
    return _fltk.Fl_event_is_click(*args)

def Fl_event_button(*args):
    """Fl_event_button() -> int"""
    return _fltk.Fl_event_button(*args)

def Fl_event_state(*args):
    """
    event_state() -> int
    Fl_event_state(int i) -> int
    """
    return _fltk.Fl_event_state(*args)

def Fl_event_original_key(*args):
    """Fl_event_original_key() -> int"""
    return _fltk.Fl_event_original_key(*args)

def Fl_event_key(*args):
    """
    event_key() -> int
    Fl_event_key(int key) -> int
    """
    return _fltk.Fl_event_key(*args)

def Fl_get_key(*args):
    """Fl_get_key(int key) -> int"""
    return _fltk.Fl_get_key(*args)

def Fl_event_text(*args):
    """Fl_event_text() -> char const *"""
    return _fltk.Fl_event_text(*args)

def Fl_event_length(*args):
    """Fl_event_length() -> int"""
    return _fltk.Fl_event_length(*args)

def Fl_event_clipboard(*args):
    """Fl_event_clipboard() -> void *"""
    return _fltk.Fl_event_clipboard(*args)

def Fl_event_clipboard_type(*args):
    """Fl_event_clipboard_type() -> char const *"""
    return _fltk.Fl_event_clipboard_type(*args)

def Fl_compose(*args):
    """Fl_compose(int & arg2) -> int"""
    return _fltk.Fl_compose(*args)

def Fl_compose_reset(*args):
    """Fl_compose_reset()"""
    return _fltk.Fl_compose_reset(*args)

def Fl_event_inside(*args):
    """
    event_inside(int arg1, int arg2, int arg3, int arg4) -> int
    Fl_event_inside(Fl_Widget arg2) -> int
    """
    return _fltk.Fl_event_inside(*args)

def Fl_test_shortcut(*args):
    """Fl_test_shortcut(Fl_Shortcut arg2) -> int"""
    return _fltk.Fl_test_shortcut(*args)

def Fl_enable_im(*args):
    """Fl_enable_im()"""
    return _fltk.Fl_enable_im(*args)

def Fl_disable_im(*args):
    """Fl_disable_im()"""
    return _fltk.Fl_disable_im(*args)

def Fl_handle(*args):
    """Fl_handle(int arg2, Fl_Window arg3) -> int"""
    return _fltk.Fl_handle(*args)

def Fl_handle_(*args):
    """Fl_handle_(int arg2, Fl_Window arg3) -> int"""
    return _fltk.Fl_handle_(*args)

def Fl_belowmouse(*args):
    """
    belowmouse() -> Fl_Widget
    Fl_belowmouse(Fl_Widget arg2)
    """
    return _fltk.Fl_belowmouse(*args)

def Fl_pushed(*args):
    """
    pushed() -> Fl_Widget
    Fl_pushed(Fl_Widget arg2)
    """
    return _fltk.Fl_pushed(*args)

def Fl_focus(*args):
    """
    focus() -> Fl_Widget
    Fl_focus(Fl_Widget arg2)
    """
    return _fltk.Fl_focus(*args)

def Fl_add_system_handler(*args):
    """Fl_add_system_handler(Fl_System_Handler h, void * data)"""
    return _fltk.Fl_add_system_handler(*args)

def Fl_remove_system_handler(*args):
    """Fl_remove_system_handler(Fl_System_Handler h)"""
    return _fltk.Fl_remove_system_handler(*args)

def Fl_event_dispatch(*args):
    """
    event_dispatch(Fl_Event_Dispatch d)
    Fl_event_dispatch() -> Fl_Event_Dispatch
    """
    return _fltk.Fl_event_dispatch(*args)

def Fl_copy(*args):
    """
    copy(char const * stuff, int len, int destination, char const * type)
    Fl_copy(char const * stuff, int len, int destination=0)
    """
    return _fltk.Fl_copy(*args)

def Fl_add_clipboard_notify(*args):
    """Fl_add_clipboard_notify(Fl_Clipboard_Notify_Handler h, void * data=None)"""
    return _fltk.Fl_add_clipboard_notify(*args)

def Fl_remove_clipboard_notify(*args):
    """Fl_remove_clipboard_notify(Fl_Clipboard_Notify_Handler h)"""
    return _fltk.Fl_remove_clipboard_notify(*args)

def Fl_clipboard_contains(*args):
    """Fl_clipboard_contains(char const * type) -> int"""
    return _fltk.Fl_clipboard_contains(*args)

def Fl_dnd(*args):
    """Fl_dnd() -> int"""
    return _fltk.Fl_dnd(*args)

def Fl_selection_owner(*args):
    """
    selection_owner() -> Fl_Widget
    Fl_selection_owner(Fl_Widget arg2)
    """
    return _fltk.Fl_selection_owner(*args)

def Fl_selection(*args):
    """Fl_selection(Fl_Widget owner, char const * arg3, int len)"""
    return _fltk.Fl_selection(*args)

def Fl_paste(*args):
    """
    paste(Fl_Widget receiver, int source, char const * type)
    paste(Fl_Widget receiver, int source)
    Fl_paste(Fl_Widget receiver)
    """
    return _fltk.Fl_paste(*args)

def Fl_x(*args):
    """Fl_x() -> int"""
    return _fltk.Fl_x(*args)

def Fl_y(*args):
    """Fl_y() -> int"""
    return _fltk.Fl_y(*args)

def Fl_w(*args):
    """Fl_w() -> int"""
    return _fltk.Fl_w(*args)

def Fl_h(*args):
    """Fl_h() -> int"""
    return _fltk.Fl_h(*args)

def Fl_screen_count(*args):
    """Fl_screen_count() -> int"""
    return _fltk.Fl_screen_count(*args)

def Fl_screen_xywh(*args):
    """
    screen_xywh(int & X, int & Y, int & W, int & H)
    screen_xywh(int & X, int & Y, int & W, int & H, int mx, int my)
    screen_xywh(int & X, int & Y, int & W, int & H, int n)
    Fl_screen_xywh(int & X, int & Y, int & W, int & H, int mx, int my, int mw, int mh)
    """
    return _fltk.Fl_screen_xywh(*args)

def Fl_screen_num(*args):
    """
    screen_num(int x, int y) -> int
    Fl_screen_num(int x, int y, int w, int h) -> int
    """
    return _fltk.Fl_screen_num(*args)

def Fl_screen_dpi(*args):
    """Fl_screen_dpi(float & h, float & v, int n=0)"""
    return _fltk.Fl_screen_dpi(*args)

def Fl_screen_work_area(*args):
    """
    screen_work_area(int & X, int & Y, int & W, int & H, int mx, int my)
    screen_work_area(int & X, int & Y, int & W, int & H, int n)
    Fl_screen_work_area(int & X, int & Y, int & W, int & H)
    """
    return _fltk.Fl_screen_work_area(*args)

def Fl_set_color(*args):
    """
    set_color(Fl_Color arg1, uchar arg2, uchar arg3, uchar arg4)
    Fl_set_color(Fl_Color i, unsigned int c)
    """
    return _fltk.Fl_set_color(*args)

def Fl_get_color(*args):
    """Fl_get_color(Fl_Color i)"""
    return _fltk.Fl_get_color(*args)

def Fl_free_color(*args):
    """Fl_free_color(Fl_Color i, int overlay=0)"""
    return _fltk.Fl_free_color(*args)

def Fl_get_font(*args):
    """Fl_get_font(Fl_Font arg2) -> char const *"""
    return _fltk.Fl_get_font(*args)

def Fl_get_font_name(*args):
    """Fl_get_font_name(Fl_Font arg2) -> char const *"""
    return _fltk.Fl_get_font_name(*args)

def Fl_set_font(*args):
    """
    set_font(Fl_Font arg1, char const * arg2)
    Fl_set_font(Fl_Font arg2, Fl_Font arg3)
    """
    return _fltk.Fl_set_font(*args)

def Fl_set_fonts(*args):
    """Fl_set_fonts(char const * arg2=None) -> Fl_Font"""
    return _fltk.Fl_set_fonts(*args)

def Fl_set_labeltype(*args):
    """Fl_set_labeltype(Fl_Labeltype arg2, Fl_Label_Draw_F * arg3, Fl_Label_Measure_F * arg4)"""
    return _fltk.Fl_set_labeltype(*args)

def Fl_get_boxtype(*args):
    """Fl_get_boxtype(Fl_Boxtype arg2) -> Fl_Box_Draw_F *"""
    return _fltk.Fl_get_boxtype(*args)

def Fl_set_boxtype(*args):
    """
    set_boxtype(Fl_Boxtype arg1, Fl_Box_Draw_F * arg2, uchar arg3, uchar arg4, uchar arg5, uchar arg6)
    Fl_set_boxtype(Fl_Boxtype arg2, Fl_Boxtype arg3)
    """
    return _fltk.Fl_set_boxtype(*args)

def Fl_box_dx(*args):
    """Fl_box_dx(Fl_Boxtype arg2) -> int"""
    return _fltk.Fl_box_dx(*args)

def Fl_box_dy(*args):
    """Fl_box_dy(Fl_Boxtype arg2) -> int"""
    return _fltk.Fl_box_dy(*args)

def Fl_box_dw(*args):
    """Fl_box_dw(Fl_Boxtype arg2) -> int"""
    return _fltk.Fl_box_dw(*args)

def Fl_box_dh(*args):
    """Fl_box_dh(Fl_Boxtype arg2) -> int"""
    return _fltk.Fl_box_dh(*args)

def Fl_draw_box_active(*args):
    """Fl_draw_box_active() -> int"""
    return _fltk.Fl_draw_box_active(*args)

def Fl_set_abort(*args):
    """Fl_set_abort(Fl_Abort_Handler f)"""
    return _fltk.Fl_set_abort(*args)

def Fl_default_atclose(*args):
    """Fl_default_atclose(Fl_Window arg2, void * arg3)"""
    return _fltk.Fl_default_atclose(*args)

def Fl_set_atclose(*args):
    """Fl_set_atclose(Fl_Atclose_Handler f)"""
    return _fltk.Fl_set_atclose(*args)

def Fl_event_shift(*args):
    """Fl_event_shift() -> int"""
    return _fltk.Fl_event_shift(*args)

def Fl_event_ctrl(*args):
    """Fl_event_ctrl() -> int"""
    return _fltk.Fl_event_ctrl(*args)

def Fl_event_command(*args):
    """Fl_event_command() -> int"""
    return _fltk.Fl_event_command(*args)

def Fl_event_alt(*args):
    """Fl_event_alt() -> int"""
    return _fltk.Fl_event_alt(*args)

def Fl_event_buttons(*args):
    """Fl_event_buttons() -> int"""
    return _fltk.Fl_event_buttons(*args)

def Fl_event_button1(*args):
    """Fl_event_button1() -> int"""
    return _fltk.Fl_event_button1(*args)

def Fl_event_button2(*args):
    """Fl_event_button2() -> int"""
    return _fltk.Fl_event_button2(*args)

def Fl_event_button3(*args):
    """Fl_event_button3() -> int"""
    return _fltk.Fl_event_button3(*args)

def Fl_set_idle(*args):
    """Fl_set_idle(Fl_Old_Idle_Handler cb)"""
    return _fltk.Fl_set_idle(*args)

def Fl_release(*args):
    """Fl_release()"""
    return _fltk.Fl_release(*args)

def Fl_visible_focus(*args):
    """
    visible_focus(int v)
    Fl_visible_focus() -> int
    """
    return _fltk.Fl_visible_focus(*args)

def Fl_dnd_text_ops(*args):
    """
    dnd_text_ops(int v)
    Fl_dnd_text_ops() -> int
    """
    return _fltk.Fl_dnd_text_ops(*args)

def Fl_delete_widget(*args):
    """Fl_delete_widget(Fl_Widget w)"""
    return _fltk.Fl_delete_widget(*args)

def Fl_do_widget_deletion(*args):
    """Fl_do_widget_deletion()"""
    return _fltk.Fl_do_widget_deletion(*args)

def Fl_watch_widget_pointer(*args):
    """Fl_watch_widget_pointer(Fl_Widget *& w)"""
    return _fltk.Fl_watch_widget_pointer(*args)

def Fl_release_widget_pointer(*args):
    """Fl_release_widget_pointer(Fl_Widget *& w)"""
    return _fltk.Fl_release_widget_pointer(*args)

def Fl_clear_widget_pointer(*args):
    """Fl_clear_widget_pointer(Fl_Widget w)"""
    return _fltk.Fl_clear_widget_pointer(*args)

def Fl_lock(*args):
    """Fl_lock()"""
    return _fltk.Fl_lock(*args)

def Fl_unlock(*args):
    """Fl_unlock()"""
    return _fltk.Fl_unlock(*args)

def Fl_awake(*args):
    """
    awake(Fl_Awake_Handler cb, void * message=None) -> int
    Fl_awake(void * message=None)
    """
    return _fltk.Fl_awake(*args)

def Fl_thread_message(*args):
    """Fl_thread_message()"""
    return _fltk.Fl_thread_message(*args)

class Fl_Widget_Tracker(object):
    """Proxy of C++ Fl_Widget_Tracker class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Widget_Tracker self, Fl_Widget wi) -> Fl_Widget_Tracker"""
        this = _fltk.new_Fl_Widget_Tracker(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Widget_Tracker
    __del__ = lambda self: None

    def widget(self, *args):
        """widget(Fl_Widget_Tracker self) -> Fl_Widget"""
        return _fltk.Fl_Widget_Tracker_widget(self, *args)


    def deleted(self, *args):
        """deleted(Fl_Widget_Tracker self) -> int"""
        return _fltk.Fl_Widget_Tracker_deleted(self, *args)


    def exists(self, *args):
        """exists(Fl_Widget_Tracker self) -> int"""
        return _fltk.Fl_Widget_Tracker_exists(self, *args)

Fl_Widget_Tracker_swigregister = _fltk.Fl_Widget_Tracker_swigregister
Fl_Widget_Tracker_swigregister(Fl_Widget_Tracker)


def pyFLTK_controlIdleCallbacks(*args):
    """pyFLTK_controlIdleCallbacks(int enable)"""
    return _fltk.pyFLTK_controlIdleCallbacks(*args)

def Fl_mt_run(window):
    import time
    while window.visible():
        time.sleep(0.1)
        Fl.check()

Fl.mt_run = staticmethod(Fl_mt_run)


_fltk.FL_PATH_MAX_swigconstant(_fltk)
FL_PATH_MAX = _fltk.FL_PATH_MAX

def fl_filename_name(*args):
    """fl_filename_name(char const * filename) -> char const *"""
    return _fltk.fl_filename_name(*args)

def fl_filename_ext(*args):
    """fl_filename_ext(char const * buf) -> char const *"""
    return _fltk.fl_filename_ext(*args)

def fl_filename_match(*args):
    """fl_filename_match(char const * name, char const * pattern) -> int"""
    return _fltk.fl_filename_match(*args)

def fl_filename_isdir(*args):
    """fl_filename_isdir(char const * name) -> int"""
    return _fltk.fl_filename_isdir(*args)

def fl_filename_setext(*args):
    """
    fl_filename_setext(char * to, int tolen, char const * ext) -> char
    fl_filename_setext(char * to, char const * ext) -> char *
    """
    return _fltk.fl_filename_setext(*args)

def fl_filename_expand(*args):
    """
    fl_filename_expand(char * to, int tolen, char const * arg3) -> int
    fl_filename_expand(char * to, char const * arg2) -> int
    """
    return _fltk.fl_filename_expand(*args)

def fl_filename_absolute(*args):
    """
    fl_filename_absolute(char * to, int tolen, char const * arg3) -> int
    fl_filename_absolute(char * to, char const * arg2) -> int
    """
    return _fltk.fl_filename_absolute(*args)

def fl_filename_relative(*args):
    """
    fl_filename_relative(char * to, int tolen, char const * arg3) -> int
    fl_filename_relative(char * to, int tolen, char const * arg3, char const * cwd) -> int
    fl_filename_relative(char * to, char const * arg2) -> int
    """
    return _fltk.fl_filename_relative(*args)

def fl_filename_free_list(*args):
    """fl_filename_free_list(dirent *** l, int n)"""
    return _fltk.fl_filename_free_list(*args)

def fl_open_uri(*args):
    """fl_open_uri(char const * uri, char * msg, int msglen=0) -> int"""
    return _fltk.fl_open_uri(*args)

def fl_decode_uri(*args):
    """fl_decode_uri(char * uri)"""
    return _fltk.fl_decode_uri(*args)
class Fl_Valuator(Fl_Widget):
    """

    The Fl_Valuator class controls a single floating-point value and provides 
    a consistent interface to set the value, range, and step, and insures that 
    callbacks are done the same for every object.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def bounds(self, *args):
        """bounds(Fl_Valuator self, double a, double b)"""
        return _fltk.Fl_Valuator_bounds(self, *args)


    def minimum(self, *args):
        """
        minimum(Fl_Valuator self) -> double
        minimum(Fl_Valuator self, double a)
        """
        return _fltk.Fl_Valuator_minimum(self, *args)


    def maximum(self, *args):
        """
        maximum(Fl_Valuator self) -> double
        maximum(Fl_Valuator self, double a)
        """
        return _fltk.Fl_Valuator_maximum(self, *args)


    def range(self, *args):
        """range(Fl_Valuator self, double a, double b)"""
        return _fltk.Fl_Valuator_range(self, *args)


    def step(self, *args):
        """
        step(Fl_Valuator self, int a)
        step(Fl_Valuator self, double a, int b)
        step(Fl_Valuator self, double s)
        step(Fl_Valuator self) -> double
        """
        return _fltk.Fl_Valuator_step(self, *args)


    def precision(self, *args):
        """precision(Fl_Valuator self, int arg2)"""
        return _fltk.Fl_Valuator_precision(self, *args)


    def value(self, *args):
        """
        value(Fl_Valuator self) -> double
        value(Fl_Valuator self, double arg2) -> int
        """
        return _fltk.Fl_Valuator_value(self, *args)


    def format(self, *args):
        """format(Fl_Valuator self, char * format_string) -> int"""
        return _fltk.Fl_Valuator_format(self, *args)


    def round(self, *args):
        """round(Fl_Valuator self, double arg2) -> double"""
        return _fltk.Fl_Valuator_round(self, *args)


    def clamp(self, *args):
        """clamp(Fl_Valuator self, double arg2) -> double"""
        return _fltk.Fl_Valuator_clamp(self, *args)


    def increment(self, *args):
        """increment(Fl_Valuator self, double arg2, int arg3) -> double"""
        return _fltk.Fl_Valuator_increment(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Valuator
    __del__ = lambda self: None
Fl_Valuator_swigregister = _fltk.Fl_Valuator_swigregister
Fl_Valuator_swigregister(Fl_Valuator)
pyFLTK_registerDoIdle = _fltk.pyFLTK_registerDoIdle
Fl_add_timeout = _fltk.Fl_add_timeout
Fl_repeat_timeout = _fltk.Fl_repeat_timeout
Fl_remove_timeout = _fltk.Fl_remove_timeout
Fl_add_fd = _fltk.Fl_add_fd
Fl_remove_fd = _fltk.Fl_remove_fd
Fl_add_handler = _fltk.Fl_add_handler
Fl_remove_handler = _fltk.Fl_remove_handler
Fl_add_check = _fltk.Fl_add_check
Fl_remove_check = _fltk.Fl_remove_check
Fl_get_font_sizes_tmp = _fltk.Fl_get_font_sizes_tmp


FL_VERTICAL=0
FL_HORIZONTAL=1

class Fl_Adjuster(Fl_Valuator):
    """

    The Fl_Adjuster widget has proven to be very useful for values that need a 
    was stolen from Prisms, and large dynamic range.
    When you press a button and drag to the right the value increases. When you 
    drag to the left it decreases. The largest button adjusts by 100 * step(), 
    the next by 10 * step() and that smallest button by step(). Clicking on the 
    buttons increments by 10 times the amount dragging by a pixel does. 
    Shift + click decrements by 10 times the amount. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Adjuster self)"""
        return _fltk.Fl_Adjuster_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Adjuster self, int arg0) -> int"""
        return _fltk.Fl_Adjuster_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Adjuster self, int X, int Y, int W, int H, char const * l=None) -> Fl_Adjuster"""
        if self.__class__ == Fl_Adjuster:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Adjuster(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def soft(self, *args):
        """
        soft(Fl_Adjuster self, int s)
        soft(Fl_Adjuster self) -> int
        """
        return _fltk.Fl_Adjuster_soft(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Adjuster
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Adjuster(self)
        return weakref_proxy(self)
Fl_Adjuster_swigregister = _fltk.Fl_Adjuster_swigregister
Fl_Adjuster_swigregister(Fl_Adjuster)


_fltk.FL_BEEP_DEFAULT_swigconstant(_fltk)
FL_BEEP_DEFAULT = _fltk.FL_BEEP_DEFAULT

_fltk.FL_BEEP_MESSAGE_swigconstant(_fltk)
FL_BEEP_MESSAGE = _fltk.FL_BEEP_MESSAGE

_fltk.FL_BEEP_ERROR_swigconstant(_fltk)
FL_BEEP_ERROR = _fltk.FL_BEEP_ERROR

_fltk.FL_BEEP_QUESTION_swigconstant(_fltk)
FL_BEEP_QUESTION = _fltk.FL_BEEP_QUESTION

_fltk.FL_BEEP_PASSWORD_swigconstant(_fltk)
FL_BEEP_PASSWORD = _fltk.FL_BEEP_PASSWORD

_fltk.FL_BEEP_NOTIFICATION_swigconstant(_fltk)
FL_BEEP_NOTIFICATION = _fltk.FL_BEEP_NOTIFICATION

def fl_beep(*args):
    """fl_beep(int type=FL_BEEP_DEFAULT)"""
    return _fltk.fl_beep(*args)

def fl_message(*args):
    """fl_message(char const * arg1)"""
    return _fltk.fl_message(*args)

def fl_alert(*args):
    """fl_alert(char const * arg1)"""
    return _fltk.fl_alert(*args)

def fl_ask(*args):
    """fl_ask(char const * arg1) -> int"""
    return _fltk.fl_ask(*args)

def fl_choice(*args):
    """fl_choice(char const * q, char const * b0, char const * b1, char const * b2) -> int"""
    return _fltk.fl_choice(*args)

def fl_message_icon(*args):
    """fl_message_icon() -> Fl_Widget"""
    return _fltk.fl_message_icon(*args)

def fl_message_font(*args):
    """fl_message_font(Fl_Font f, Fl_Fontsize s)"""
    return _fltk.fl_message_font(*args)

def fl_message_hotspot(*args):
    """
    fl_message_hotspot(int enable)
    fl_message_hotspot() -> int
    """
    return _fltk.fl_message_hotspot(*args)

def fl_message_title(*args):
    """fl_message_title(char const * title)"""
    return _fltk.fl_message_title(*args)

def fl_message_title_default(*args):
    """fl_message_title_default(char const * title)"""
    return _fltk.fl_message_title_default(*args)

def fl_input(*args):
    """fl_input(char const * label, char const * deflt=None) -> char const *"""
    return _fltk.fl_input(*args)

def fl_password(*args):
    """fl_password(char const * label, char const * deflt=None) -> char const *"""
    return _fltk.fl_password(*args)

def fl_no_get(*args):
    """fl_no_get() -> char const *"""
    return _fltk.fl_no_get(*args)

def fl_yes_get(*args):
    """fl_yes_get() -> char const *"""
    return _fltk.fl_yes_get(*args)

def fl_ok_get(*args):
    """fl_ok_get() -> char const *"""
    return _fltk.fl_ok_get(*args)

def fl_cancel_get(*args):
    """fl_cancel_get() -> char const *"""
    return _fltk.fl_cancel_get(*args)

def fl_close_get(*args):
    """fl_close_get() -> char const *"""
    return _fltk.fl_close_get(*args)

def fl_no_set(*args):
    """fl_no_set(char const * value)"""
    return _fltk.fl_no_set(*args)

def fl_yes_set(*args):
    """fl_yes_set(char const * value)"""
    return _fltk.fl_yes_set(*args)

def fl_ok_set(*args):
    """fl_ok_set(char const * value)"""
    return _fltk.fl_ok_set(*args)

def fl_cancel_set(*args):
    """fl_cancel_set(char const * value)"""
    return _fltk.fl_cancel_set(*args)

def fl_close_set(*args):
    """fl_close_set(char const * value)"""
    return _fltk.fl_close_set(*args)

def fl_mt_message(*args):
    """fl_mt_message(char const * text)"""
    return _fltk.fl_mt_message(*args)

def fl_mt_alert(*args):
    """fl_mt_alert(char const * text)"""
    return _fltk.fl_mt_alert(*args)

def fl_mt_ask(*args):
    """fl_mt_ask(char const * text) -> int"""
    return _fltk.fl_mt_ask(*args)

def fl_mt_choice(*args):
    """fl_mt_choice(char const * q, char const * b0, char const * b1, char const * b2) -> int"""
    return _fltk.fl_mt_choice(*args)

def fl_mt_input(*args):
    """fl_mt_input(char const * label, char const * deflt=None) -> char const *"""
    return _fltk.fl_mt_input(*args)

def fl_mt_password(*args):
    """fl_mt_password(char const * label, char const * deflt=None) -> char const *"""
    return _fltk.fl_mt_password(*args)
class Fl_Bitmap(Fl_Image):
    """

    The Fl_Bitmap class supports caching and drawing of mono-color 
    (bitmap) images. Images are drawn using the current color.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Bitmap self, uchar const * bits, int W, int H) -> Fl_Bitmap"""
        if self.__class__ == Fl_Bitmap:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Bitmap(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Bitmap
    __del__ = lambda self: None

    def copy(self, *args):
        """
        copy(Fl_Bitmap self, int W, int H) -> Fl_Image
        copy(Fl_Bitmap self) -> Fl_Image
        """
        return _fltk.Fl_Bitmap_copy(self, *args)


    def draw(self, *args):
        """
        draw(Fl_Bitmap self, int X, int Y, int W, int H, int cx=0, int cy=0)
        draw(Fl_Bitmap self, int X, int Y)
        """
        return _fltk.Fl_Bitmap_draw(self, *args)


    def label(self, *args):
        """
        label(Fl_Bitmap self, Fl_Widget w)
        label(Fl_Bitmap self, Fl_Menu_Item m)
        """
        return _fltk.Fl_Bitmap_label(self, *args)


    def uncache(self, *args):
        """uncache(Fl_Bitmap self)"""
        return _fltk.Fl_Bitmap_uncache(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Bitmap(self)
        return weakref_proxy(self)
Fl_Bitmap_swigregister = _fltk.Fl_Bitmap_swigregister
Fl_Bitmap_swigregister(Fl_Bitmap)

class Fl_BMP_Image(Fl_RGB_Image):
    """

    The Fl_BMP_Image class supports loading, caching, and drawing of 
    Windows Bitmap (BMP) image files.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_BMP_Image self, char const * filename) -> Fl_BMP_Image"""
        if self.__class__ == Fl_BMP_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_BMP_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_BMP_Image
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_BMP_Image(self)
        return weakref_proxy(self)
Fl_BMP_Image_swigregister = _fltk.Fl_BMP_Image_swigregister
Fl_BMP_Image_swigregister(Fl_BMP_Image)

class Fl_Box(Fl_Widget):
    """

    This widget simply draws its box, and possibly it's label. 
    Putting it before some other widgets and making it big enough 
    to surround them will let you draw a frame around them.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Box self)"""
        return _fltk.Fl_Box_draw(self, *args)


    def __init__(self, *args):
        """
        __init__(Fl_Box self, int X, int Y, int W, int H, char const * l=None) -> Fl_Box
        __init__(Fl_Box self, Fl_Boxtype b, int X, int Y, int W, int H, char const * l) -> Fl_Box
        """
        if self.__class__ == Fl_Box:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Box(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def handle(self, *args):
        """handle(Fl_Box self, int arg0) -> int"""
        return _fltk.Fl_Box_handle(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Box
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Box(self)
        return weakref_proxy(self)
Fl_Box_swigregister = _fltk.Fl_Box_swigregister
Fl_Box_swigregister(Fl_Box)


_fltk.FL_NORMAL_BUTTON_swigconstant(_fltk)
FL_NORMAL_BUTTON = _fltk.FL_NORMAL_BUTTON

_fltk.FL_TOGGLE_BUTTON_swigconstant(_fltk)
FL_TOGGLE_BUTTON = _fltk.FL_TOGGLE_BUTTON

_fltk.FL_RADIO_BUTTON_swigconstant(_fltk)
FL_RADIO_BUTTON = _fltk.FL_RADIO_BUTTON

_fltk.FL_HIDDEN_BUTTON_swigconstant(_fltk)
FL_HIDDEN_BUTTON = _fltk.FL_HIDDEN_BUTTON

def fl_old_shortcut(*args):
    """fl_old_shortcut(char const * arg1) -> Fl_Shortcut"""
    return _fltk.fl_old_shortcut(*args)
class Fl_Button(Fl_Widget):
    """

    Buttons generate callbacks when they are clicked by the user. You control 
    exactly when and how by changing the values for type()  and when().

    Buttons can also generate callbacks in response to FL_SHORTCUT events. The 
    button can either have an explicit shortcut() value or a letter shortcut 
    can be indicated in the label() with an '&' character before it. For the 
    label shortcut it does not matter if Alt is held down, but if you have an 
    input field in the same window, the user will have to hold down the Alt key 
    so that the input field does not eat the event first as an FL_KEYBOARD event. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Button self)"""
        return _fltk.Fl_Button_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Button self, int arg0) -> int"""
        return _fltk.Fl_Button_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Button self, int X, int Y, int W, int H, char const * L=None) -> Fl_Button"""
        if self.__class__ == Fl_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def value(self, *args):
        """
        value(Fl_Button self, int v) -> int
        value(Fl_Button self) -> char
        """
        return _fltk.Fl_Button_value(self, *args)


    def set(self, *args):
        """set(Fl_Button self) -> int"""
        return _fltk.Fl_Button_set(self, *args)


    def clear(self, *args):
        """clear(Fl_Button self) -> int"""
        return _fltk.Fl_Button_clear(self, *args)


    def setonly(self, *args):
        """setonly(Fl_Button self)"""
        return _fltk.Fl_Button_setonly(self, *args)


    def down_box(self, *args):
        """
        down_box(Fl_Button self) -> Fl_Boxtype
        down_box(Fl_Button self, Fl_Boxtype b)
        """
        return _fltk.Fl_Button_down_box(self, *args)


    def shortcut(self, *args):
        """
        shortcut(Fl_Button self) -> int
        shortcut(Fl_Button self, int s)
        shortcut(Fl_Button self, char const * s)
        """
        return _fltk.Fl_Button_shortcut(self, *args)


    def down_color(self, *args):
        """
        down_color(Fl_Button self) -> Fl_Color
        down_color(Fl_Button self, unsigned int c)
        """
        return _fltk.Fl_Button_down_color(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Button(self)
        return weakref_proxy(self)
Fl_Button_swigregister = _fltk.Fl_Button_swigregister
Fl_Button_swigregister(Fl_Button)


_fltk.FL_BAR_CHART_swigconstant(_fltk)
FL_BAR_CHART = _fltk.FL_BAR_CHART

_fltk.FL_HORBAR_CHART_swigconstant(_fltk)
FL_HORBAR_CHART = _fltk.FL_HORBAR_CHART

_fltk.FL_LINE_CHART_swigconstant(_fltk)
FL_LINE_CHART = _fltk.FL_LINE_CHART

_fltk.FL_FILL_CHART_swigconstant(_fltk)
FL_FILL_CHART = _fltk.FL_FILL_CHART

_fltk.FL_SPIKE_CHART_swigconstant(_fltk)
FL_SPIKE_CHART = _fltk.FL_SPIKE_CHART

_fltk.FL_PIE_CHART_swigconstant(_fltk)
FL_PIE_CHART = _fltk.FL_PIE_CHART

_fltk.FL_SPECIALPIE_CHART_swigconstant(_fltk)
FL_SPECIALPIE_CHART = _fltk.FL_SPECIALPIE_CHART

_fltk.FL_FILLED_CHART_swigconstant(_fltk)
FL_FILLED_CHART = _fltk.FL_FILLED_CHART

_fltk.FL_CHART_MAX_swigconstant(_fltk)
FL_CHART_MAX = _fltk.FL_CHART_MAX

_fltk.FL_CHART_LABEL_MAX_swigconstant(_fltk)
FL_CHART_LABEL_MAX = _fltk.FL_CHART_LABEL_MAX
class FL_CHART_ENTRY(object):
    """Proxy of C++ FL_CHART_ENTRY class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(FL_CHART_ENTRY self) -> FL_CHART_ENTRY"""
        this = _fltk.new_FL_CHART_ENTRY(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_FL_CHART_ENTRY
    __del__ = lambda self: None
FL_CHART_ENTRY_swigregister = _fltk.FL_CHART_ENTRY_swigregister
FL_CHART_ENTRY_swigregister(FL_CHART_ENTRY)

class Fl_Chart(Fl_Widget):
    """

    This widget displays simple charts and is provided for Forms compatibility.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Chart self)"""
        return _fltk.Fl_Chart_draw(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Chart self, int X, int Y, int W, int H, char const * L=None) -> Fl_Chart"""
        if self.__class__ == Fl_Chart:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Chart(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Chart
    __del__ = lambda self: None

    def clear(self, *args):
        """clear(Fl_Chart self)"""
        return _fltk.Fl_Chart_clear(self, *args)


    def add(self, *args):
        """add(Fl_Chart self, double val, char const * str=None, unsigned int col=0)"""
        return _fltk.Fl_Chart_add(self, *args)


    def insert(self, *args):
        """insert(Fl_Chart self, int ind, double val, char const * str=None, unsigned int col=0)"""
        return _fltk.Fl_Chart_insert(self, *args)


    def replace(self, *args):
        """replace(Fl_Chart self, int ind, double val, char const * str=None, unsigned int col=0)"""
        return _fltk.Fl_Chart_replace(self, *args)


    def bounds(self, *args):
        """
        bounds(Fl_Chart self, double * a, double * b)
        bounds(Fl_Chart self, double a, double b)
        """
        return _fltk.Fl_Chart_bounds(self, *args)


    def size(self, *args):
        """
        size(Fl_Chart self) -> int
        size(Fl_Chart self, int W, int H)
        """
        return _fltk.Fl_Chart_size(self, *args)


    def maxsize(self, *args):
        """
        maxsize(Fl_Chart self) -> int
        maxsize(Fl_Chart self, int m)
        """
        return _fltk.Fl_Chart_maxsize(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Chart self) -> Fl_Font
        textfont(Fl_Chart self, Fl_Font s)
        """
        return _fltk.Fl_Chart_textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Chart self) -> Fl_Fontsize
        textsize(Fl_Chart self, Fl_Fontsize s)
        """
        return _fltk.Fl_Chart_textsize(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Chart self) -> Fl_Color
        textcolor(Fl_Chart self, Fl_Color n)
        """
        return _fltk.Fl_Chart_textcolor(self, *args)


    def autosize(self, *args):
        """
        autosize(Fl_Chart self) -> uchar
        autosize(Fl_Chart self, uchar n)
        """
        return _fltk.Fl_Chart_autosize(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Chart(self)
        return weakref_proxy(self)
Fl_Chart_swigregister = _fltk.Fl_Chart_swigregister
Fl_Chart_swigregister(Fl_Chart)

class Fl_Check_Browser(Fl_Browser_):
    """

    The Fl_Check_Browser widget displays a scrolling list of text lines that may be selected and/or checked by the user.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Check_Browser self, int x, int y, int w, int h, char const * l=None) -> Fl_Check_Browser"""
        if self.__class__ == Fl_Check_Browser:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Check_Browser(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Check_Browser
    __del__ = lambda self: None

    def remove(self, *args):
        """remove(Fl_Check_Browser self, int item) -> int"""
        val = _fltk.Fl_Check_Browser_remove(self, *args)

        #self = args[0]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()
        else:                       
        #give ownership back to Python
            self.this.own() 


        return val


    def add(self, *args):
        """
        add(Fl_Check_Browser self, char const * s) -> int
        add(Fl_Check_Browser self, char const * s, int b) -> int
        """
        val = _fltk.Fl_Check_Browser_add(self, *args)

        #self = args[0]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()
        else:                       
        #give ownership back to Python
            self.this.own() 


        return val


    def clear(self, *args):
        """clear(Fl_Check_Browser self)"""
        return _fltk.Fl_Check_Browser_clear(self, *args)


    def nitems(self, *args):
        """nitems(Fl_Check_Browser self) -> int"""
        return _fltk.Fl_Check_Browser_nitems(self, *args)


    def nchecked(self, *args):
        """nchecked(Fl_Check_Browser self) -> int"""
        return _fltk.Fl_Check_Browser_nchecked(self, *args)


    def checked(self, *args):
        """
        checked(Fl_Check_Browser self, int item) -> int
        checked(Fl_Check_Browser self, int item, int b)
        """
        return _fltk.Fl_Check_Browser_checked(self, *args)


    def set_checked(self, *args):
        """set_checked(Fl_Check_Browser self, int item)"""
        return _fltk.Fl_Check_Browser_set_checked(self, *args)


    def check_all(self, *args):
        """check_all(Fl_Check_Browser self)"""
        return _fltk.Fl_Check_Browser_check_all(self, *args)


    def check_none(self, *args):
        """check_none(Fl_Check_Browser self)"""
        return _fltk.Fl_Check_Browser_check_none(self, *args)


    def value(self, *args):
        """value(Fl_Check_Browser self) -> int"""
        return _fltk.Fl_Check_Browser_value(self, *args)


    def text(self, *args):
        """text(Fl_Check_Browser self, int item) -> char *"""
        return _fltk.Fl_Check_Browser_text(self, *args)


    def handle(self, *args):
        """handle(Fl_Check_Browser self, int arg0) -> int"""
        return _fltk.Fl_Check_Browser_handle(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Check_Browser(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Check_Browser self)"""
        return _fltk.Fl_Check_Browser_draw(self, *args)


    def item_first(self, *args):
        """item_first(Fl_Check_Browser self) -> void *"""
        return _fltk.Fl_Check_Browser_item_first(self, *args)


    def item_next(self, *args):
        """item_next(Fl_Check_Browser self, void * item) -> void *"""
        return _fltk.Fl_Check_Browser_item_next(self, *args)


    def item_prev(self, *args):
        """item_prev(Fl_Check_Browser self, void * item) -> void *"""
        return _fltk.Fl_Check_Browser_item_prev(self, *args)


    def item_last(self, *args):
        """item_last(Fl_Check_Browser self) -> void *"""
        return _fltk.Fl_Check_Browser_item_last(self, *args)


    def item_height(self, *args):
        """item_height(Fl_Check_Browser self, void * item) -> int"""
        return _fltk.Fl_Check_Browser_item_height(self, *args)


    def item_width(self, *args):
        """item_width(Fl_Check_Browser self, void * item) -> int"""
        return _fltk.Fl_Check_Browser_item_width(self, *args)


    def item_quick_height(self, *args):
        """item_quick_height(Fl_Check_Browser self, void * item) -> int"""
        return _fltk.Fl_Check_Browser_item_quick_height(self, *args)


    def item_draw(self, *args):
        """item_draw(Fl_Check_Browser self, void * item, int X, int Y, int W, int H)"""
        return _fltk.Fl_Check_Browser_item_draw(self, *args)


    def item_text(self, *args):
        """item_text(Fl_Check_Browser self, void * item) -> char const *"""
        return _fltk.Fl_Check_Browser_item_text(self, *args)


    def item_swap(self, *args):
        """item_swap(Fl_Check_Browser self, void * a, void * b)"""
        return _fltk.Fl_Check_Browser_item_swap(self, *args)


    def item_at(self, *args):
        """item_at(Fl_Check_Browser self, int index) -> void *"""
        return _fltk.Fl_Check_Browser_item_at(self, *args)


    def full_width(self, *args):
        """full_width(Fl_Check_Browser self) -> int"""
        return _fltk.Fl_Check_Browser_full_width(self, *args)


    def full_height(self, *args):
        """full_height(Fl_Check_Browser self) -> int"""
        return _fltk.Fl_Check_Browser_full_height(self, *args)


    def incr_height(self, *args):
        """incr_height(Fl_Check_Browser self) -> int"""
        return _fltk.Fl_Check_Browser_incr_height(self, *args)


    def item_select(self, *args):
        """item_select(Fl_Check_Browser self, void * item, int val=1)"""
        return _fltk.Fl_Check_Browser_item_select(self, *args)


    def item_selected(self, *args):
        """item_selected(Fl_Check_Browser self, void * item) -> int"""
        return _fltk.Fl_Check_Browser_item_selected(self, *args)

Fl_Check_Browser_swigregister = _fltk.Fl_Check_Browser_swigregister
Fl_Check_Browser_swigregister(Fl_Check_Browser)

class Fl_Light_Button(Fl_Button):
    """

    Buttons generate callbacks when they are clicked by the user. You control 
    exactly when and how by changing the values for type() and when().

    The Fl_Light_Button subclass display the 'on' state by turning on a light, 
    rather than drawing pushed in. The shape of the 'light' is initially set 
    to FL_DOWN_BOX. The color of the light when on is controlled with 
    selection_color(), which defaults to FL_YELLOW.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Light_Button self)"""
        return _fltk.Fl_Light_Button_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Light_Button self, int arg0) -> int"""
        return _fltk.Fl_Light_Button_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Light_Button self, int x, int y, int w, int h, char const * l=None) -> Fl_Light_Button"""
        if self.__class__ == Fl_Light_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Light_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Light_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Light_Button(self)
        return weakref_proxy(self)
Fl_Light_Button_swigregister = _fltk.Fl_Light_Button_swigregister
Fl_Light_Button_swigregister(Fl_Light_Button)

class Fl_Check_Button(Fl_Light_Button):
    """

    Buttons generate callbacks when they are clicked by the user. You control 
    exactly when and how by changing the values for type() and when().

    The Fl_Check_Button subclass display the 'on' state by turning on a light, 
    rather than drawing pushed in. The shape of the 'light' is initially set to 
    FL_DIAMOND_DOWN_BOX. The color of the light when on is controlled with 
    selection_color(), which defaults to FL_RED.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Check_Button self, int X, int Y, int W, int H, char const * L=None) -> Fl_Check_Button"""
        if self.__class__ == Fl_Check_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Check_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Check_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Check_Button(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Check_Button self)"""
        return _fltk.Fl_Check_Button_draw(self, *args)

Fl_Check_Button_swigregister = _fltk.Fl_Check_Button_swigregister
Fl_Check_Button_swigregister(Fl_Check_Button)

class Fl_Menu_(Fl_Widget):
    """

    All widgets that have a menu in FLTK are subclassed off of this class. 
    Currently FLTK provides you with Fl_Menu_Button, Fl_Menu_Bar, and Fl_Choice .

    The class contains a pointer to an array of structures of type Fl_Menu_Item. 
    The array may either be supplied directly by the user program, or it may be 
    'private': a dynamically allocated array managed by the Fl_Menu_. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Menu_ self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Menu_"""
        if self.__class__ == Fl_Menu_:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Menu_(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Menu_
    __del__ = lambda self: None

    def item_pathname(self, *args):
        """item_pathname(Fl_Menu_ self, char * name, int namelen, Fl_Menu_Item finditem=None) -> int"""
        return _fltk.Fl_Menu__item_pathname(self, *args)


    def picked(self, *args):
        """picked(Fl_Menu_ self, Fl_Menu_Item arg2) -> Fl_Menu_Item"""
        return _fltk.Fl_Menu__picked(self, *args)


    def find_item(self, *args):
        """
        find_item(Fl_Menu_ self, char const * name) -> Fl_Menu_Item
        find_item(Fl_Menu_ self, Fl_Callback * arg2) -> Fl_Menu_Item
        """
        return _fltk.Fl_Menu__find_item(self, *args)


    def find_index(self, *args):
        """
        find_index(Fl_Menu_ self, char const * name) -> int
        find_index(Fl_Menu_ self, Fl_Menu_Item item) -> int
        find_index(Fl_Menu_ self, Fl_Callback * cb) -> int
        """
        return _fltk.Fl_Menu__find_index(self, *args)


    def test_shortcut(self, *args):
        """test_shortcut(Fl_Menu_ self) -> Fl_Menu_Item"""
        return _fltk.Fl_Menu__test_shortcut(self, *args)


    def insert(self, *args):
        """
        insert(Fl_Menu_ self, int index, char const * arg3, int shortcut, Fl_Callback * arg5, void * arg6=None, int arg7=0) -> int
        insert(Fl_Menu_ self, int index, char const * a, char const * b, Fl_Callback * c, void * d=None, int e=0) -> int
        """
        return _fltk.Fl_Menu__insert(self, *args)


    def size(self, *args):
        """
        size(Fl_Menu_ self) -> int
        size(Fl_Menu_ self, int W, int H)
        """
        return _fltk.Fl_Menu__size(self, *args)


    def clear(self, *args):
        """clear(Fl_Menu_ self)"""
        return _fltk.Fl_Menu__clear(self, *args)


    def clear_submenu(self, *args):
        """clear_submenu(Fl_Menu_ self, int index) -> int"""
        return _fltk.Fl_Menu__clear_submenu(self, *args)


    def replace(self, *args):
        """replace(Fl_Menu_ self, int arg2, char const * arg3)"""
        return _fltk.Fl_Menu__replace(self, *args)


    def remove(self, *args):
        """remove(Fl_Menu_ self, int arg2)"""
        return _fltk.Fl_Menu__remove(self, *args)


    def shortcut(self, *args):
        """shortcut(Fl_Menu_ self, int i, int s)"""
        return _fltk.Fl_Menu__shortcut(self, *args)


    def mode(self, *args):
        """
        mode(Fl_Menu_ self, int i, int fl)
        mode(Fl_Menu_ self, int i) -> int
        """
        return _fltk.Fl_Menu__mode(self, *args)


    def mvalue(self, *args):
        """mvalue(Fl_Menu_ self) -> Fl_Menu_Item"""
        return _fltk.Fl_Menu__mvalue(self, *args)


    def value(self, *args):
        """
        value(Fl_Menu_ self) -> int
        value(Fl_Menu_ self, int i) -> int
        """
        return _fltk.Fl_Menu__value(self, *args)


    def text(self, *args):
        """
        text(Fl_Menu_ self) -> char const
        text(Fl_Menu_ self, int i) -> char const *
        """
        return _fltk.Fl_Menu__text(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Menu_ self) -> Fl_Font
        textfont(Fl_Menu_ self, Fl_Font c)
        """
        return _fltk.Fl_Menu__textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Menu_ self) -> Fl_Fontsize
        textsize(Fl_Menu_ self, Fl_Fontsize c)
        """
        return _fltk.Fl_Menu__textsize(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Menu_ self) -> Fl_Color
        textcolor(Fl_Menu_ self, Fl_Color c)
        """
        return _fltk.Fl_Menu__textcolor(self, *args)


    def down_box(self, *args):
        """
        down_box(Fl_Menu_ self) -> Fl_Boxtype
        down_box(Fl_Menu_ self, Fl_Boxtype b)
        """
        return _fltk.Fl_Menu__down_box(self, *args)


    def down_color(self, *args):
        """
        down_color(Fl_Menu_ self) -> Fl_Color
        down_color(Fl_Menu_ self, unsigned int c)
        """
        return _fltk.Fl_Menu__down_color(self, *args)


    def copy(self, *args):
        """
        copy(Fl_Menu_ self, Fl_Menu_Item m, void * user_data=None)
        copy(Fl_Menu_ self, PyObject * args, PyObject * user_data=None)
        """
        return _fltk.Fl_Menu__copy(self, *args)


    def add(self, *args):
        """
        add(Fl_Menu_ self, char const * arg2, int shortcut, Fl_Callback * arg4, void * arg5=None, int arg6=0) -> int
        add(Fl_Menu_ self, char const * arg2) -> int
        add(Fl_Menu_ self, PyObject * lObj, PyObject * sObj, PyObject * cObj, PyObject * uObj=None, PyObject * fObj=None) -> int
        """
        return _fltk.Fl_Menu__add(self, *args)


    def menu(self, *args):
        """
        menu(Fl_Menu_ self) -> Fl_Menu_Item
        menu(Fl_Menu_ self, PyObject * args)
        menu(Fl_Menu_ self) -> PyObject *
        """
        return _fltk.Fl_Menu__menu(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Menu_(self)
        return weakref_proxy(self)
Fl_Menu__swigregister = _fltk.Fl_Menu__swigregister
Fl_Menu__swigregister(Fl_Menu_)

class Fl_Choice(Fl_Menu_):
    """

    This is a button that when pushed pops up a menu (or hierarchy of menus) 
    defined by an array of Fl_Menu_Item objects. Motif calls this an OptionButton.

    The only difference between this and a Fl_Menu_Button is that the name of 
    the most recent chosen menu item is displayed inside the box, while the 
    label is displayed outside the box. However, since the use of this is most 
    often to control a single variable rather than do individual callbacks, some 
    of the Fl_Menu_Button methods are redescribed here in those terms.

    When the user picks an item off the menu the value() is set to that item and 
    then the item's callback is done with the menu_button as the Fl_Widget 
    argument. If the item does not have a callback the menu_button's callback is 
    done instead.

    All three mouse buttons pop up the menu. The Forms behavior of the first two 
    buttons to increment/decrement the choice is not implemented. This could be 
    added with a subclass, however.

    The menu will also pop up in response to shortcuts indicated by putting a '&' 
    character in the label(). See Fl_Button for a description of this.

    Typing the shortcut() of any of the items will do exactly the same as when 
    you pick the item with the mouse. The '&' character in item names are only 
    looked at when the menu is popped up, however. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Choice self)"""
        return _fltk.Fl_Choice_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Choice self, int arg0) -> int"""
        return _fltk.Fl_Choice_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Choice self, int X, int Y, int W, int H, char const * L=None) -> Fl_Choice"""
        if self.__class__ == Fl_Choice:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Choice(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def value(self, *args):
        """
        value(Fl_Choice self) -> int
        value(Fl_Choice self, int v) -> int
        """
        return _fltk.Fl_Choice_value(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Choice
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Choice(self)
        return weakref_proxy(self)
Fl_Choice_swigregister = _fltk.Fl_Choice_swigregister
Fl_Choice_swigregister(Fl_Choice)


_fltk.FL_SQUARE_CLOCK_swigconstant(_fltk)
FL_SQUARE_CLOCK = _fltk.FL_SQUARE_CLOCK

_fltk.FL_ROUND_CLOCK_swigconstant(_fltk)
FL_ROUND_CLOCK = _fltk.FL_ROUND_CLOCK

_fltk.FL_ANALOG_CLOCK_swigconstant(_fltk)
FL_ANALOG_CLOCK = _fltk.FL_ANALOG_CLOCK

_fltk.FL_DIGITAL_CLOCK_swigconstant(_fltk)
FL_DIGITAL_CLOCK = _fltk.FL_DIGITAL_CLOCK
class Fl_Clock_Output(Fl_Widget):
    """Proxy of C++ Fl_Clock_Output class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Clock_Output self)"""
        return _fltk.Fl_Clock_Output_draw(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Clock_Output self, int X, int Y, int W, int H, char const * L=None) -> Fl_Clock_Output"""
        if self.__class__ == Fl_Clock_Output:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Clock_Output(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def value(self, *args):
        """
        value(Fl_Clock_Output self, ulong v)
        value(Fl_Clock_Output self, int H, int m, int s)
        value(Fl_Clock_Output self) -> ulong
        """
        return _fltk.Fl_Clock_Output_value(self, *args)


    def hour(self, *args):
        """hour(Fl_Clock_Output self) -> int"""
        return _fltk.Fl_Clock_Output_hour(self, *args)


    def minute(self, *args):
        """minute(Fl_Clock_Output self) -> int"""
        return _fltk.Fl_Clock_Output_minute(self, *args)


    def second(self, *args):
        """second(Fl_Clock_Output self) -> int"""
        return _fltk.Fl_Clock_Output_second(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Clock_Output
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Clock_Output(self)
        return weakref_proxy(self)
Fl_Clock_Output_swigregister = _fltk.Fl_Clock_Output_swigregister
Fl_Clock_Output_swigregister(Fl_Clock_Output)

class Fl_Clock(Fl_Clock_Output):
    """

    This widget provides a round analog clock display and is provided for Forms 
    compatibility. It installs a 1-second timeout callback using Fl.add_timeout().

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def handle(self, *args):
        """handle(Fl_Clock self, int arg0) -> int"""
        return _fltk.Fl_Clock_handle(self, *args)


    def __init__(self, *args):
        """
        __init__(Fl_Clock self, int X, int Y, int W, int H, char const * L=None) -> Fl_Clock
        __init__(Fl_Clock self, uchar t, int X, int Y, int W, int H, char const * L) -> Fl_Clock
        """
        if self.__class__ == Fl_Clock:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Clock(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Clock
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Clock(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Clock self)"""
        return _fltk.Fl_Clock_draw(self, *args)

Fl_Clock_swigregister = _fltk.Fl_Clock_swigregister
Fl_Clock_swigregister(Fl_Clock)

class Fl_Value_Input(Fl_Valuator):
    """

    The Fl_Value_Input widget displays a numeric value. The user can click in 
    the text field and edit it - there is in fact a hidden Fl_Input widget with 
    type(FL_FLOAT_INPUT) or type(FL_INT_INPUT) in there - and when they hit 
    return or tab the value updates to what they typed and the callback is done.

    If step() is non-zero, the user can also drag the mouse across the object 
    and thus slide the value. The left button moves one step() per pixel, the 
    middle by 10 * step(), and the right button by 100 * step(). It is therefore 
    impossible to select text by dragging across it, although clicking can still 
    move the insertion cursor.

    If step() is non-zero and integral, then the range of numbers are limited 
    to integers instead of floating point values. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def handle(self, *args):
        """handle(Fl_Value_Input self, int arg0) -> int"""
        return _fltk.Fl_Value_Input_handle(self, *args)


    def draw(self, *args):
        """draw(Fl_Value_Input self)"""
        return _fltk.Fl_Value_Input_draw(self, *args)


    def resize(self, *args):
        """resize(Fl_Value_Input self, int arg0, int arg1, int arg2, int arg3)"""
        return _fltk.Fl_Value_Input_resize(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Value_Input self, int x, int y, int w, int h, char const * l=None) -> Fl_Value_Input"""
        if self.__class__ == Fl_Value_Input:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Value_Input(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Value_Input
    __del__ = lambda self: None

    def soft(self, *args):
        """
        soft(Fl_Value_Input self, char s)
        soft(Fl_Value_Input self) -> char
        """
        return _fltk.Fl_Value_Input_soft(self, *args)


    def shortcut(self, *args):
        """
        shortcut(Fl_Value_Input self) -> int
        shortcut(Fl_Value_Input self, int s)
        """
        return _fltk.Fl_Value_Input_shortcut(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Value_Input self) -> Fl_Font
        textfont(Fl_Value_Input self, Fl_Font s)
        """
        return _fltk.Fl_Value_Input_textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Value_Input self) -> Fl_Fontsize
        textsize(Fl_Value_Input self, Fl_Fontsize s)
        """
        return _fltk.Fl_Value_Input_textsize(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Value_Input self) -> Fl_Color
        textcolor(Fl_Value_Input self, Fl_Color n)
        """
        return _fltk.Fl_Value_Input_textcolor(self, *args)


    def cursor_color(self, *args):
        """
        cursor_color(Fl_Value_Input self) -> Fl_Color
        cursor_color(Fl_Value_Input self, Fl_Color n)
        """
        return _fltk.Fl_Value_Input_cursor_color(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Value_Input(self)
        return weakref_proxy(self)
Fl_Value_Input_swigregister = _fltk.Fl_Value_Input_swigregister
Fl_Value_Input_swigregister(Fl_Value_Input)

class Flcc_HueBox(Fl_Widget):
    """Proxy of C++ Flcc_HueBox class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Flcc_HueBox self)"""
        return _fltk.Flcc_HueBox_draw(self, *args)


    def handle(self, *args):
        """handle(Flcc_HueBox self, int arg0) -> int"""
        return _fltk.Flcc_HueBox_handle(self, *args)


    def __init__(self, *args):
        """__init__(Flcc_HueBox self, int X, int Y, int W, int H) -> Flcc_HueBox"""
        if self.__class__ == Flcc_HueBox:
            _self = None
        else:
            _self = self
        this = _fltk.new_Flcc_HueBox(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Flcc_HueBox
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Flcc_HueBox(self)
        return weakref_proxy(self)
Flcc_HueBox_swigregister = _fltk.Flcc_HueBox_swigregister
Flcc_HueBox_swigregister(Flcc_HueBox)

class Flcc_ValueBox(Fl_Widget):
    """Proxy of C++ Flcc_ValueBox class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Flcc_ValueBox self)"""
        return _fltk.Flcc_ValueBox_draw(self, *args)


    def handle(self, *args):
        """handle(Flcc_ValueBox self, int arg0) -> int"""
        return _fltk.Flcc_ValueBox_handle(self, *args)


    def __init__(self, *args):
        """__init__(Flcc_ValueBox self, int X, int Y, int W, int H) -> Flcc_ValueBox"""
        if self.__class__ == Flcc_ValueBox:
            _self = None
        else:
            _self = self
        this = _fltk.new_Flcc_ValueBox(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Flcc_ValueBox
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Flcc_ValueBox(self)
        return weakref_proxy(self)
Flcc_ValueBox_swigregister = _fltk.Flcc_ValueBox_swigregister
Flcc_ValueBox_swigregister(Flcc_ValueBox)

class Flcc_Value_Input(Fl_Value_Input):
    """Proxy of C++ Flcc_Value_Input class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def format(self, *args):
        """format(Flcc_Value_Input self, char * arg0) -> int"""
        return _fltk.Flcc_Value_Input_format(self, *args)


    def __init__(self, *args):
        """__init__(Flcc_Value_Input self, int X, int Y, int W, int H) -> Flcc_Value_Input"""
        if self.__class__ == Flcc_Value_Input:
            _self = None
        else:
            _self = self
        this = _fltk.new_Flcc_Value_Input(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Flcc_Value_Input
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Flcc_Value_Input(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Flcc_Value_Input self)"""
        return _fltk.Flcc_Value_Input_draw(self, *args)

Flcc_Value_Input_swigregister = _fltk.Flcc_Value_Input_swigregister
Flcc_Value_Input_swigregister(Flcc_Value_Input)

class Fl_Color_Chooser(Fl_Group):
    """

    The Fl_Color_Chooser widget provides a standard RGB color chooser. You can 
    place any number of these into a panel of your own design. This widget 
    contains the hue box, value slider, and rgb input fields from the above 
    diagram (it does not have the color chips or the Cancel or OK buttons). The 
    callback is done every time the user changes the rgb value. It is not done 
    if they move the hue control in a way that produces the same rgb value, such 
    as when saturation or value is zero.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def mode(self, *args):
        """
        mode(Fl_Color_Chooser self) -> int
        mode(Fl_Color_Chooser self, int newMode)
        """
        return _fltk.Fl_Color_Chooser_mode(self, *args)


    def hue(self, *args):
        """hue(Fl_Color_Chooser self) -> double"""
        return _fltk.Fl_Color_Chooser_hue(self, *args)


    def saturation(self, *args):
        """saturation(Fl_Color_Chooser self) -> double"""
        return _fltk.Fl_Color_Chooser_saturation(self, *args)


    def value(self, *args):
        """value(Fl_Color_Chooser self) -> double"""
        return _fltk.Fl_Color_Chooser_value(self, *args)


    def r(self, *args):
        """r(Fl_Color_Chooser self) -> double"""
        return _fltk.Fl_Color_Chooser_r(self, *args)


    def g(self, *args):
        """g(Fl_Color_Chooser self) -> double"""
        return _fltk.Fl_Color_Chooser_g(self, *args)


    def b(self, *args):
        """b(Fl_Color_Chooser self) -> double"""
        return _fltk.Fl_Color_Chooser_b(self, *args)


    def hsv(self, *args):
        """hsv(Fl_Color_Chooser self, double H, double S, double V) -> int"""
        return _fltk.Fl_Color_Chooser_hsv(self, *args)


    def rgb(self, *args):
        """rgb(Fl_Color_Chooser self, double R, double G, double B) -> int"""
        return _fltk.Fl_Color_Chooser_rgb(self, *args)


    def hsv2rgb(*args):
        """hsv2rgb(double H, double S, double V, double & R, double & G, double & B)"""
        return _fltk.Fl_Color_Chooser_hsv2rgb(*args)

    hsv2rgb = staticmethod(hsv2rgb)

    def rgb2hsv(*args):
        """rgb2hsv(double R, double G, double B, double & H, double & S, double & V)"""
        return _fltk.Fl_Color_Chooser_rgb2hsv(*args)

    rgb2hsv = staticmethod(rgb2hsv)

    def __init__(self, *args):
        """__init__(Fl_Color_Chooser self, int X, int Y, int W, int H, char const * L=None) -> Fl_Color_Chooser"""
        if self.__class__ == Fl_Color_Chooser:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Color_Chooser(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Color_Chooser
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Color_Chooser(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Color_Chooser self)"""
        return _fltk.Fl_Color_Chooser_draw(self, *args)

Fl_Color_Chooser_swigregister = _fltk.Fl_Color_Chooser_swigregister
Fl_Color_Chooser_swigregister(Fl_Color_Chooser)

def Fl_Color_Chooser_hsv2rgb(*args):
    """Fl_Color_Chooser_hsv2rgb(double H, double S, double V, double & R, double & G, double & B)"""
    return _fltk.Fl_Color_Chooser_hsv2rgb(*args)

def Fl_Color_Chooser_rgb2hsv(*args):
    """Fl_Color_Chooser_rgb2hsv(double R, double G, double B, double & H, double & S, double & V)"""
    return _fltk.Fl_Color_Chooser_rgb2hsv(*args)


def fl_color_chooser(*args):
    """
    fl_color_chooser(char const * name, double & r, double & g, double & b, int m=-1) -> int
    fl_color_chooser(char const * name, uchar & r, uchar & g, uchar & b, int m=-1) -> int
    """
    return _fltk.fl_color_chooser(*args)

_fltk.FL_NORMAL_COUNTER_swigconstant(_fltk)
FL_NORMAL_COUNTER = _fltk.FL_NORMAL_COUNTER

_fltk.FL_SIMPLE_COUNTER_swigconstant(_fltk)
FL_SIMPLE_COUNTER = _fltk.FL_SIMPLE_COUNTER
class Fl_Counter(Fl_Valuator):
    """

    The Fl_Counter widget is provided for forms compatibility. It controls a 
    single floating point value.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Counter self)"""
        return _fltk.Fl_Counter_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Counter self, int arg0) -> int"""
        return _fltk.Fl_Counter_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Counter self, int X, int Y, int W, int H, char const * L=None) -> Fl_Counter"""
        if self.__class__ == Fl_Counter:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Counter(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Counter
    __del__ = lambda self: None

    def lstep(self, *args):
        """lstep(Fl_Counter self, double a)"""
        return _fltk.Fl_Counter_lstep(self, *args)


    def step(self, *args):
        """
        step(Fl_Counter self, double a, double b)
        step(Fl_Counter self, double a)
        step(Fl_Counter self) -> double
        """
        return _fltk.Fl_Counter_step(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Counter self) -> Fl_Font
        textfont(Fl_Counter self, Fl_Font s)
        """
        return _fltk.Fl_Counter_textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Counter self) -> Fl_Fontsize
        textsize(Fl_Counter self, Fl_Fontsize s)
        """
        return _fltk.Fl_Counter_textsize(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Counter self) -> Fl_Color
        textcolor(Fl_Counter self, Fl_Color s)
        """
        return _fltk.Fl_Counter_textcolor(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Counter(self)
        return weakref_proxy(self)
Fl_Counter_swigregister = _fltk.Fl_Counter_swigregister
Fl_Counter_swigregister(Fl_Counter)


_fltk.FL_NORMAL_DIAL_swigconstant(_fltk)
FL_NORMAL_DIAL = _fltk.FL_NORMAL_DIAL

_fltk.FL_LINE_DIAL_swigconstant(_fltk)
FL_LINE_DIAL = _fltk.FL_LINE_DIAL

_fltk.FL_FILL_DIAL_swigconstant(_fltk)
FL_FILL_DIAL = _fltk.FL_FILL_DIAL
class Fl_Dial(Fl_Valuator):
    """

    The Fl_Dial widget provides a circular dial to control a single floating 
    point value.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Dial self)"""
        return _fltk.Fl_Dial_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Dial self, int arg0) -> int"""
        return _fltk.Fl_Dial_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Dial self, int x, int y, int w, int h, char const * l=None) -> Fl_Dial"""
        if self.__class__ == Fl_Dial:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Dial(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def angle1(self, *args):
        """
        angle1(Fl_Dial self) -> short
        angle1(Fl_Dial self, short a)
        """
        return _fltk.Fl_Dial_angle1(self, *args)


    def angle2(self, *args):
        """
        angle2(Fl_Dial self) -> short
        angle2(Fl_Dial self, short a)
        """
        return _fltk.Fl_Dial_angle2(self, *args)


    def angles(self, *args):
        """angles(Fl_Dial self, short a, short b)"""
        return _fltk.Fl_Dial_angles(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Dial
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Dial(self)
        return weakref_proxy(self)
Fl_Dial_swigregister = _fltk.Fl_Dial_swigregister
Fl_Dial_swigregister(Fl_Dial)


_fltk.FL_WINDOW_swigconstant(_fltk)
FL_WINDOW = _fltk.FL_WINDOW

_fltk.FL_DOUBLE_WINDOW_swigconstant(_fltk)
FL_DOUBLE_WINDOW = _fltk.FL_DOUBLE_WINDOW
class Fl_Window(Fl_Group):
    """

    This widget produces an actual window. This can either be a main window, 
    with a border and title and all the window management controls, or a 
    'subwindow' inside a window. This is controlled by whether or not the 
    window has a parent().

    Once you create a window, you usually add children Fl_Widget 's to it by 
    using window->add(child) for each new widget. See Fl_Group for more 
    information on how to add and remove children.

    There are several subclasses of Fl_Window that provide double-buffering, 
    overlay, menu, and OpenGL support.

    The window's callback is done if the user tries to close a window using 
    the window manager and Fl.modal() is zero or equal to the window. Fl_Window 
    has a default callback that calls Fl_Window.hide(). 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def shape(self, *args):
        """
        shape(Fl_Window self, Fl_Image img)
        shape(Fl_Window self, Fl_Image b)
        """
        return _fltk.Fl_Window_shape(self, *args)


    def draw(self, *args):
        """draw(Fl_Window self)"""
        return _fltk.Fl_Window_draw(self, *args)


    def flush(self, *args):
        """flush(Fl_Window self)"""
        return _fltk.Fl_Window_flush(self, *args)


    def __init__(self, *args):
        """
        __init__(Fl_Window self, int w, int h, char const * title=None) -> Fl_Window
        __init__(Fl_Window self, int x, int y, int w, int h, char const * title=None) -> Fl_Window
        """
        if self.__class__ == Fl_Window:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Window(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Window
    __del__ = lambda self: None

    def handle(self, *args):
        """handle(Fl_Window self, int arg0) -> int"""
        return _fltk.Fl_Window_handle(self, *args)


    def resize(self, *args):
        """resize(Fl_Window self, int X, int Y, int W, int H)"""
        return _fltk.Fl_Window_resize(self, *args)


    def clear_border(self, *args):
        """clear_border(Fl_Window self)"""
        return _fltk.Fl_Window_clear_border(self, *args)


    def border(self, *args):
        """
        border(Fl_Window self, int b)
        border(Fl_Window self) -> unsigned int
        """
        return _fltk.Fl_Window_border(self, *args)


    def set_override(self, *args):
        """set_override(Fl_Window self)"""
        return _fltk.Fl_Window_set_override(self, *args)


    def override(self, *args):
        """override(Fl_Window self) -> unsigned int"""
        return _fltk.Fl_Window_override(self, *args)


    def set_modal(self, *args):
        """set_modal(Fl_Window self)"""
        return _fltk.Fl_Window_set_modal(self, *args)


    def modal(self, *args):
        """modal(Fl_Window self) -> unsigned int"""
        return _fltk.Fl_Window_modal(self, *args)


    def set_non_modal(self, *args):
        """set_non_modal(Fl_Window self)"""
        return _fltk.Fl_Window_set_non_modal(self, *args)


    def non_modal(self, *args):
        """non_modal(Fl_Window self) -> unsigned int"""
        return _fltk.Fl_Window_non_modal(self, *args)


    def clear_modal_states(self, *args):
        """clear_modal_states(Fl_Window self)"""
        return _fltk.Fl_Window_clear_modal_states(self, *args)


    def set_menu_window(self, *args):
        """set_menu_window(Fl_Window self)"""
        return _fltk.Fl_Window_set_menu_window(self, *args)


    def menu_window(self, *args):
        """menu_window(Fl_Window self) -> unsigned int"""
        return _fltk.Fl_Window_menu_window(self, *args)


    def set_tooltip_window(self, *args):
        """set_tooltip_window(Fl_Window self)"""
        return _fltk.Fl_Window_set_tooltip_window(self, *args)


    def tooltip_window(self, *args):
        """tooltip_window(Fl_Window self) -> unsigned int"""
        return _fltk.Fl_Window_tooltip_window(self, *args)


    def hotspot(self, *args):
        """
        hotspot(Fl_Window self, int x, int y, int offscreen=0)
        hotspot(Fl_Window self, Fl_Widget arg2, int offscreen=0)
        """
        return _fltk.Fl_Window_hotspot(self, *args)


    def free_position(self, *args):
        """free_position(Fl_Window self)"""
        return _fltk.Fl_Window_free_position(self, *args)


    def size_range(self, *args):
        """size_range(Fl_Window self, int minw, int minh, int maxw=0, int maxh=0, int dw=0, int dh=0, int aspect=0)"""
        return _fltk.Fl_Window_size_range(self, *args)


    def iconlabel(self, *args):
        """
        iconlabel(Fl_Window self) -> char const
        iconlabel(Fl_Window self, char const * arg2)
        """
        return _fltk.Fl_Window_iconlabel(self, *args)


    def label(self, *args):
        """
        label(Fl_Window self) -> char const
        label(Fl_Window self, char const * arg2)
        label(Fl_Window self, char const * label, char const * iconlabel)
        """
        val = _fltk.Fl_Window_label(self, *args)

        if len(args) > 0:
            self.my_label = args[len(args)-1]


        return val


    def copy_label(self, *args):
        """copy_label(Fl_Window self, char const * a)"""
        return _fltk.Fl_Window_copy_label(self, *args)


    def default_xclass(*args):
        """
        default_xclass(char const * arg1)
        default_xclass() -> char const *
        """
        return _fltk.Fl_Window_default_xclass(*args)

    default_xclass = staticmethod(default_xclass)

    def xclass(self, *args):
        """
        xclass(Fl_Window self) -> char const
        xclass(Fl_Window self, char const * c)
        """
        return _fltk.Fl_Window_xclass(self, *args)


    def default_icon(*args):
        """default_icon(Fl_RGB_Image arg1)"""
        return _fltk.Fl_Window_default_icon(*args)

    default_icon = staticmethod(default_icon)

    def default_icons(*args):
        """default_icons(Fl_RGB_Image const *[] arg1, int arg2)"""
        return _fltk.Fl_Window_default_icons(*args)

    default_icons = staticmethod(default_icons)

    def icons(self, *args):
        """icons(Fl_Window self, Fl_RGB_Image const *[] arg2, int arg3)"""
        return _fltk.Fl_Window_icons(self, *args)


    def icon(self, *args):
        """
        icon(Fl_Window self, Fl_RGB_Image arg2)
        icon(Fl_Window self) -> void const
        icon(Fl_Window self, void const * ic)
        """
        return _fltk.Fl_Window_icon(self, *args)


    def shown(self, *args):
        """shown(Fl_Window self) -> int"""
        return _fltk.Fl_Window_shown(self, *args)


    def hide(self, *args):
        """hide(Fl_Window self)"""
        return _fltk.Fl_Window_hide(self, *args)


    def wait_for_expose(self, *args):
        """wait_for_expose(Fl_Window self)"""
        return _fltk.Fl_Window_wait_for_expose(self, *args)


    def fullscreen(self, *args):
        """fullscreen(Fl_Window self)"""
        return _fltk.Fl_Window_fullscreen(self, *args)


    def fullscreen_off(self, *args):
        """
        fullscreen_off(Fl_Window self)
        fullscreen_off(Fl_Window self, int X, int Y, int W, int H)
        """
        return _fltk.Fl_Window_fullscreen_off(self, *args)


    def fullscreen_active(self, *args):
        """fullscreen_active(Fl_Window self) -> unsigned int"""
        return _fltk.Fl_Window_fullscreen_active(self, *args)


    def fullscreen_screens(self, *args):
        """fullscreen_screens(Fl_Window self, int top, int bottom, int left, int right)"""
        return _fltk.Fl_Window_fullscreen_screens(self, *args)


    def iconize(self, *args):
        """iconize(Fl_Window self)"""
        return _fltk.Fl_Window_iconize(self, *args)


    def x_root(self, *args):
        """x_root(Fl_Window self) -> int"""
        return _fltk.Fl_Window_x_root(self, *args)


    def y_root(self, *args):
        """y_root(Fl_Window self) -> int"""
        return _fltk.Fl_Window_y_root(self, *args)


    def current(*args):
        """current() -> Fl_Window"""
        return _fltk.Fl_Window_current(*args)

    current = staticmethod(current)

    def make_current(self, *args):
        """make_current(Fl_Window self)"""
        return _fltk.Fl_Window_make_current(self, *args)


    def as_window(self, *args):
        """as_window(Fl_Window self) -> Fl_Window"""
        return _fltk.Fl_Window_as_window(self, *args)


    def cursor(self, *args):
        """
        cursor(Fl_Window self, Fl_Cursor arg2)
        cursor(Fl_Window self, Fl_RGB_Image arg2, int arg3, int arg4)
        cursor(Fl_Window self, Fl_Cursor c, Fl_Color arg3, Fl_Color arg4)
        """
        return _fltk.Fl_Window_cursor(self, *args)


    def default_cursor(self, *args):
        """
        default_cursor(Fl_Window self, Fl_Cursor arg2)
        default_cursor(Fl_Window self, Fl_Cursor c, Fl_Color arg3, Fl_Color arg4)
        """
        return _fltk.Fl_Window_default_cursor(self, *args)


    def default_callback(*args):
        """default_callback(Fl_Window arg1, void * v)"""
        return _fltk.Fl_Window_default_callback(*args)

    default_callback = staticmethod(default_callback)

    def decorated_w(self, *args):
        """decorated_w(Fl_Window self) -> int"""
        return _fltk.Fl_Window_decorated_w(self, *args)


    def decorated_h(self, *args):
        """decorated_h(Fl_Window self) -> int"""
        return _fltk.Fl_Window_decorated_h(self, *args)


    def show(self, *args):
        """show(Fl_Window self, PyObject * count=None, PyObject * data=None)"""
        return _fltk.Fl_Window_show(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Window(self)
        return weakref_proxy(self)
Fl_Window_swigregister = _fltk.Fl_Window_swigregister
Fl_Window_swigregister(Fl_Window)

def Fl_Window_default_xclass(*args):
    """
    default_xclass(char const * arg1)
    Fl_Window_default_xclass() -> char const *
    """
    return _fltk.Fl_Window_default_xclass(*args)

def Fl_Window_default_icon(*args):
    """Fl_Window_default_icon(Fl_RGB_Image arg2)"""
    return _fltk.Fl_Window_default_icon(*args)

def Fl_Window_default_icons(*args):
    """Fl_Window_default_icons(Fl_RGB_Image const *[] arg2, int arg3)"""
    return _fltk.Fl_Window_default_icons(*args)

def Fl_Window_current(*args):
    """Fl_Window_current() -> Fl_Window"""
    return _fltk.Fl_Window_current(*args)

def Fl_Window_default_callback(*args):
    """Fl_Window_default_callback(Fl_Window arg2, void * v)"""
    return _fltk.Fl_Window_default_callback(*args)

class Fl_Double_Window(Fl_Window):
    """

    The Fl_Double_Window class provides a double-buffered window. If possible 
    this will use the X double buffering extension (Xdbe). If not, it will draw 
    the window data into an off-screen pixmap, and then copy it to the on-screen 
    window.

    It is highly recommended that you put the following code before the first 
    show() of any window in your program:

          Fl.visual(FL_DOUBLE|FL_INDEX)

    This makes sure you can use Xdbe on servers where double buffering does not 
    exist for every visual.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def flush(self, *args):
        """flush(Fl_Double_Window self)"""
        return _fltk.Fl_Double_Window_flush(self, *args)


    def resize(self, *args):
        """resize(Fl_Double_Window self, int arg0, int arg1, int arg2, int arg3)"""
        return _fltk.Fl_Double_Window_resize(self, *args)


    def hide(self, *args):
        """hide(Fl_Double_Window self)"""
        return _fltk.Fl_Double_Window_hide(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Double_Window
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Fl_Double_Window self, int W, int H, char const * l=None) -> Fl_Double_Window
        __init__(Fl_Double_Window self, int X, int Y, int W, int H, char const * l=None) -> Fl_Double_Window
        """
        if self.__class__ == Fl_Double_Window:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Double_Window(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def show(self, *args):
        """show(Fl_Double_Window self, PyObject * count=None, PyObject * data=None)"""
        return _fltk.Fl_Double_Window_show(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Double_Window(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Double_Window self)"""
        return _fltk.Fl_Double_Window_draw(self, *args)

Fl_Double_Window_swigregister = _fltk.Fl_Double_Window_swigregister
Fl_Double_Window_swigregister(Fl_Double_Window)


def fl_color(*args):
    """
    fl_color(Fl_Color c)
    fl_color(uchar r, uchar g, uchar b)
    fl_color() -> Fl_Color
    """
    return _fltk.fl_color(*args)

def fl_push_clip(*args):
    """fl_push_clip(int x, int y, int w, int h)"""
    return _fltk.fl_push_clip(*args)

def fl_push_no_clip(*args):
    """fl_push_no_clip()"""
    return _fltk.fl_push_no_clip(*args)

def fl_pop_clip(*args):
    """fl_pop_clip()"""
    return _fltk.fl_pop_clip(*args)

def fl_not_clipped(*args):
    """fl_not_clipped(int x, int y, int w, int h) -> int"""
    return _fltk.fl_not_clipped(*args)

def fl_clip_box(*args):
    """fl_clip_box(int x, int y, int w, int h) -> int"""
    return _fltk.fl_clip_box(*args)

def fl_restore_clip(*args):
    """fl_restore_clip()"""
    return _fltk.fl_restore_clip(*args)

def fl_clip_region(*args):
    """
    fl_clip_region(Fl_Region r)
    fl_clip_region() -> Fl_Region
    """
    return _fltk.fl_clip_region(*args)

def fl_point(*args):
    """fl_point(int x, int y)"""
    return _fltk.fl_point(*args)

def fl_line_style(*args):
    """fl_line_style(int style, int width=0, char * dashes=None)"""
    return _fltk.fl_line_style(*args)

_fltk.FL_SOLID_swigconstant(_fltk)
FL_SOLID = _fltk.FL_SOLID

_fltk.FL_DASH_swigconstant(_fltk)
FL_DASH = _fltk.FL_DASH

_fltk.FL_DOT_swigconstant(_fltk)
FL_DOT = _fltk.FL_DOT

_fltk.FL_DASHDOT_swigconstant(_fltk)
FL_DASHDOT = _fltk.FL_DASHDOT

_fltk.FL_DASHDOTDOT_swigconstant(_fltk)
FL_DASHDOTDOT = _fltk.FL_DASHDOTDOT

_fltk.FL_CAP_FLAT_swigconstant(_fltk)
FL_CAP_FLAT = _fltk.FL_CAP_FLAT

_fltk.FL_CAP_ROUND_swigconstant(_fltk)
FL_CAP_ROUND = _fltk.FL_CAP_ROUND

_fltk.FL_CAP_SQUARE_swigconstant(_fltk)
FL_CAP_SQUARE = _fltk.FL_CAP_SQUARE

_fltk.FL_JOIN_MITER_swigconstant(_fltk)
FL_JOIN_MITER = _fltk.FL_JOIN_MITER

_fltk.FL_JOIN_ROUND_swigconstant(_fltk)
FL_JOIN_ROUND = _fltk.FL_JOIN_ROUND

_fltk.FL_JOIN_BEVEL_swigconstant(_fltk)
FL_JOIN_BEVEL = _fltk.FL_JOIN_BEVEL

def fl_rect(*args):
    """
    fl_rect(int x, int y, int w, int h)
    fl_rect(int x, int y, int w, int h, Fl_Color c)
    """
    return _fltk.fl_rect(*args)

def fl_rectf(*args):
    """
    fl_rectf(int x, int y, int w, int h)
    fl_rectf(int x, int y, int w, int h, Fl_Color c)
    fl_rectf(int x, int y, int w, int h, uchar r, uchar g, uchar b)
    """
    return _fltk.fl_rectf(*args)

def fl_line(*args):
    """
    fl_line(int x, int y, int x1, int y1)
    fl_line(int x, int y, int x1, int y1, int x2, int y2)
    """
    return _fltk.fl_line(*args)

def fl_loop(*args):
    """
    fl_loop(int x, int y, int x1, int y1, int x2, int y2)
    fl_loop(int x, int y, int x1, int y1, int x2, int y2, int x3, int y3)
    """
    return _fltk.fl_loop(*args)

def fl_polygon(*args):
    """
    fl_polygon(int x, int y, int x1, int y1, int x2, int y2)
    fl_polygon(int x, int y, int x1, int y1, int x2, int y2, int x3, int y3)
    """
    return _fltk.fl_polygon(*args)

def fl_xyline(*args):
    """
    fl_xyline(int x, int y, int x1)
    fl_xyline(int x, int y, int x1, int y2)
    fl_xyline(int x, int y, int x1, int y2, int x3)
    """
    return _fltk.fl_xyline(*args)

def fl_yxline(*args):
    """
    fl_yxline(int x, int y, int y1)
    fl_yxline(int x, int y, int y1, int x2)
    fl_yxline(int x, int y, int y1, int x2, int y3)
    """
    return _fltk.fl_yxline(*args)

def fl_pie(*args):
    """fl_pie(int x, int y, int w, int h, double a1, double a2)"""
    return _fltk.fl_pie(*args)

def fl_push_matrix(*args):
    """fl_push_matrix()"""
    return _fltk.fl_push_matrix(*args)

def fl_pop_matrix(*args):
    """fl_pop_matrix()"""
    return _fltk.fl_pop_matrix(*args)

def fl_scale(*args):
    """
    fl_scale(double x, double y)
    fl_scale(double x)
    """
    return _fltk.fl_scale(*args)

def fl_translate(*args):
    """fl_translate(double x, double y)"""
    return _fltk.fl_translate(*args)

def fl_rotate(*args):
    """fl_rotate(double d)"""
    return _fltk.fl_rotate(*args)

def fl_mult_matrix(*args):
    """fl_mult_matrix(double a, double b, double c, double d, double x, double y)"""
    return _fltk.fl_mult_matrix(*args)

def fl_begin_points(*args):
    """fl_begin_points()"""
    return _fltk.fl_begin_points(*args)

def fl_begin_line(*args):
    """fl_begin_line()"""
    return _fltk.fl_begin_line(*args)

def fl_begin_loop(*args):
    """fl_begin_loop()"""
    return _fltk.fl_begin_loop(*args)

def fl_begin_polygon(*args):
    """fl_begin_polygon()"""
    return _fltk.fl_begin_polygon(*args)

def fl_vertex(*args):
    """fl_vertex(double x, double y)"""
    return _fltk.fl_vertex(*args)

def fl_curve(*args):
    """fl_curve(double X0, double Y0, double X1, double Y1, double X2, double Y2, double X3, double Y3)"""
    return _fltk.fl_curve(*args)

def fl_arc(*args):
    """
    fl_arc(int x, int y, int w, int h, double a1, double a2)
    fl_arc(double x, double y, double r, double start, double end)
    """
    return _fltk.fl_arc(*args)

def fl_circle(*args):
    """fl_circle(double x, double y, double r)"""
    return _fltk.fl_circle(*args)

def fl_end_points(*args):
    """fl_end_points()"""
    return _fltk.fl_end_points(*args)

def fl_end_line(*args):
    """fl_end_line()"""
    return _fltk.fl_end_line(*args)

def fl_end_loop(*args):
    """fl_end_loop()"""
    return _fltk.fl_end_loop(*args)

def fl_end_polygon(*args):
    """fl_end_polygon()"""
    return _fltk.fl_end_polygon(*args)

def fl_begin_complex_polygon(*args):
    """fl_begin_complex_polygon()"""
    return _fltk.fl_begin_complex_polygon(*args)

def fl_gap(*args):
    """fl_gap()"""
    return _fltk.fl_gap(*args)

def fl_end_complex_polygon(*args):
    """fl_end_complex_polygon()"""
    return _fltk.fl_end_complex_polygon(*args)

def fl_transform_x(*args):
    """fl_transform_x(double x, double y) -> double"""
    return _fltk.fl_transform_x(*args)

def fl_transform_y(*args):
    """fl_transform_y(double x, double y) -> double"""
    return _fltk.fl_transform_y(*args)

def fl_transform_dx(*args):
    """fl_transform_dx(double x, double y) -> double"""
    return _fltk.fl_transform_dx(*args)

def fl_transform_dy(*args):
    """fl_transform_dy(double x, double y) -> double"""
    return _fltk.fl_transform_dy(*args)

def fl_transformed_vertex(*args):
    """fl_transformed_vertex(double xf, double yf)"""
    return _fltk.fl_transformed_vertex(*args)

def fl_font(*args):
    """
    fl_font(Fl_Font face, Fl_Fontsize fsize)
    fl_font() -> Fl_Font
    """
    return _fltk.fl_font(*args)

def fl_size(*args):
    """fl_size() -> Fl_Fontsize"""
    return _fltk.fl_size(*args)

def fl_height(*args):
    """
    fl_height() -> int
    fl_height(int font, int size) -> int
    """
    return _fltk.fl_height(*args)

def fl_descent(*args):
    """fl_descent() -> int"""
    return _fltk.fl_descent(*args)

def fl_width(*args):
    """
    fl_width(char const * txt) -> double
    fl_width(char const * txt, int n) -> double
    fl_width(unsigned int c) -> double
    """
    return _fltk.fl_width(*args)

def fl_text_extents(*args):
    """
    fl_text_extents(char const * arg1)
    fl_text_extents(char const * t, int n)
    """
    return _fltk.fl_text_extents(*args)

def fl_latin1_to_local(*args):
    """fl_latin1_to_local(char const * t, int n=-1) -> char const *"""
    return _fltk.fl_latin1_to_local(*args)

def fl_local_to_latin1(*args):
    """fl_local_to_latin1(char const * t, int n=-1) -> char const *"""
    return _fltk.fl_local_to_latin1(*args)

def fl_mac_roman_to_local(*args):
    """fl_mac_roman_to_local(char const * t, int n=-1) -> char const *"""
    return _fltk.fl_mac_roman_to_local(*args)

def fl_local_to_mac_roman(*args):
    """fl_local_to_mac_roman(char const * t, int n=-1) -> char const *"""
    return _fltk.fl_local_to_mac_roman(*args)

def fl_rtl_draw(*args):
    """fl_rtl_draw(char const * str, int n, int x, int y)"""
    return _fltk.fl_rtl_draw(*args)

def fl_measure(*args):
    """fl_measure(char const * str, int draw_symbols=1)"""
    return _fltk.fl_measure(*args)

def fl_draw(*args):
    """
    fl_draw(char const * str, int x, int y)
    fl_draw(int angle, char const * str, int x, int y)
    fl_draw(char const * str, int n, int x, int y)
    fl_draw(int angle, char const * str, int n, int x, int y)
    fl_draw(char const * str, int x, int y, int w, int h, Fl_Align align, Fl_Image img=None, int draw_symbols=1)
    fl_draw(char const * str, int x, int y, int w, int h, Fl_Align align, void (*)(char const *,int,int,int) callthis, Fl_Image img=None, int draw_symbols=1)
    """
    return _fltk.fl_draw(*args)

def fl_frame(*args):
    """
    fl_frame(Fl_Boxtype b) -> Fl_Boxtype
    fl_frame(char const * s, int x, int y, int w, int h)
    """
    return _fltk.fl_frame(*args)

def fl_frame2(*args):
    """fl_frame2(char const * s, int x, int y, int w, int h)"""
    return _fltk.fl_frame2(*args)

def fl_draw_box(*args):
    """fl_draw_box(Fl_Boxtype arg1, int x, int y, int w, int h, Fl_Color arg6)"""
    return _fltk.fl_draw_box(*args)

def fl_draw_image(*args):
    """fl_draw_image(uchar const * buf, int X, int Y, int W, int H, int D=3, int L=0)"""
    return _fltk.fl_draw_image(*args)

def fl_draw_image_mono(*args):
    """fl_draw_image_mono(uchar const * buf, int X, int Y, int W, int H, int D=1, int L=0)"""
    return _fltk.fl_draw_image_mono(*args)

def fl_can_do_alpha_blending(*args):
    """fl_can_do_alpha_blending() -> char"""
    return _fltk.fl_can_do_alpha_blending(*args)

def fl_draw_pixmap(*args):
    """fl_draw_pixmap(char *const * data, int x, int y, Fl_Color arg4) -> int"""
    return _fltk.fl_draw_pixmap(*args)

def fl_measure_pixmap(*args):
    """fl_measure_pixmap(char *const * data) -> int"""
    return _fltk.fl_measure_pixmap(*args)

def fl_scroll(*args):
    """fl_scroll(int X, int Y, int W, int H, int dx, int dy, void (*)(void *,int,int,int,int) draw_area, void * data)"""
    return _fltk.fl_scroll(*args)

def fl_shortcut_label(*args):
    """
    fl_shortcut_label(unsigned int shortcut) -> char const
    fl_shortcut_label(unsigned int shortcut, char const ** eom) -> char const *
    """
    return _fltk.fl_shortcut_label(*args)

def fl_overlay_rect(*args):
    """fl_overlay_rect(int x, int y, int w, int h)"""
    return _fltk.fl_overlay_rect(*args)

def fl_overlay_clear(*args):
    """fl_overlay_clear()"""
    return _fltk.fl_overlay_clear(*args)

def fl_cursor(*args):
    """
    fl_cursor(Fl_Cursor arg1)
    fl_cursor(Fl_Cursor arg1, Fl_Color fg, Fl_Color bg)
    """
    return _fltk.fl_cursor(*args)

def fl_expand_text(*args):
    """fl_expand_text(char const * arg1, char * buf, int maxbuf, double maxw, double & width, int wrap, int draw_symbols=0) -> char const *"""
    return _fltk.fl_expand_text(*args)

def fl_set_status(*args):
    """fl_set_status(int X, int Y, int W, int H)"""
    return _fltk.fl_set_status(*args)

def fl_set_spot(*args):
    """fl_set_spot(int font, int size, int X, int Y, int W, int H, Fl_Window win=None)"""
    return _fltk.fl_set_spot(*args)

def fl_reset_spot(*args):
    """fl_reset_spot()"""
    return _fltk.fl_reset_spot(*args)

def fl_draw_symbol(*args):
    """fl_draw_symbol(char const * label, int x, int y, int w, int h, Fl_Color arg6) -> int"""
    return _fltk.fl_draw_symbol(*args)

def fl_add_symbol(*args):
    """fl_add_symbol(char const * name, void (*)(Fl_Color) drawit, int scalable) -> int"""
    return _fltk.fl_add_symbol(*args)

_fltk.FL_NORMAL_INPUT_swigconstant(_fltk)
FL_NORMAL_INPUT = _fltk.FL_NORMAL_INPUT

_fltk.FL_FLOAT_INPUT_swigconstant(_fltk)
FL_FLOAT_INPUT = _fltk.FL_FLOAT_INPUT

_fltk.FL_INT_INPUT_swigconstant(_fltk)
FL_INT_INPUT = _fltk.FL_INT_INPUT

_fltk.FL_HIDDEN_INPUT_swigconstant(_fltk)
FL_HIDDEN_INPUT = _fltk.FL_HIDDEN_INPUT

_fltk.FL_MULTILINE_INPUT_swigconstant(_fltk)
FL_MULTILINE_INPUT = _fltk.FL_MULTILINE_INPUT

_fltk.FL_SECRET_INPUT_swigconstant(_fltk)
FL_SECRET_INPUT = _fltk.FL_SECRET_INPUT

_fltk.FL_INPUT_TYPE_swigconstant(_fltk)
FL_INPUT_TYPE = _fltk.FL_INPUT_TYPE

_fltk.FL_INPUT_READONLY_swigconstant(_fltk)
FL_INPUT_READONLY = _fltk.FL_INPUT_READONLY

_fltk.FL_NORMAL_OUTPUT_swigconstant(_fltk)
FL_NORMAL_OUTPUT = _fltk.FL_NORMAL_OUTPUT

_fltk.FL_MULTILINE_OUTPUT_swigconstant(_fltk)
FL_MULTILINE_OUTPUT = _fltk.FL_MULTILINE_OUTPUT

_fltk.FL_INPUT_WRAP_swigconstant(_fltk)
FL_INPUT_WRAP = _fltk.FL_INPUT_WRAP

_fltk.FL_MULTILINE_INPUT_WRAP_swigconstant(_fltk)
FL_MULTILINE_INPUT_WRAP = _fltk.FL_MULTILINE_INPUT_WRAP

_fltk.FL_MULTILINE_OUTPUT_WRAP_swigconstant(_fltk)
FL_MULTILINE_OUTPUT_WRAP = _fltk.FL_MULTILINE_OUTPUT_WRAP
class Fl_Input_(Fl_Widget):
    """

    This is a virtual base class below Fl_Input. It has all the same interfaces, 
    but lacks the handle() and draw() method. You may want to subclass it if you 
    are one of those people who likes to change how the editing keys work.

    This can act like any of the subclasses of Fl_Input, by setting type() to one 
    of the following values:

          FL_NORMAL_INPUT		0
          FL_FLOAT_INPUT		1
          FL_INT_INPUT		2
          FL_MULTILINE_INPUT	4
          FL_SECRET_INPUT		5
          FL_INPUT_TYPE		7
          FL_INPUT_READONLY		8
          FL_NORMAL_OUTPUT		(FL_NORMAL_INPUT | FL_INPUT_READONLY)
          FL_MULTILINE_OUTPUT	(FL_MULTILINE_INPUT | FL_INPUT_READONLY)
          FL_INPUT_WRAP		16
          FL_MULTILINE_INPUT_WRAP	(FL_MULTILINE_INPUT | FL_INPUT_WRAP)
          FL_MULTILINE_OUTPUT_WRAP 	(FL_MULTILINE_INPUT | FL_INPUT_READONLY | FL_INPUT_WRAP)


    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def resize(self, *args):
        """resize(Fl_Input_ self, int arg0, int arg1, int arg2, int arg3)"""
        return _fltk.Fl_Input__resize(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Input_ self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Input_"""
        if self.__class__ == Fl_Input_:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Input_(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Input_
    __del__ = lambda self: None

    def static_value(self, *args):
        """
        static_value(Fl_Input_ self, char const * arg2) -> int
        static_value(Fl_Input_ self, char const * arg2, int arg3) -> int
        """
        return _fltk.Fl_Input__static_value(self, *args)


    def value(self, *args):
        """
        value(Fl_Input_ self, char const * arg2) -> int
        value(Fl_Input_ self, char const * arg2, int arg3) -> int
        value(Fl_Input_ self) -> char const *
        """
        return _fltk.Fl_Input__value(self, *args)


    def index(self, *args):
        """index(Fl_Input_ self, int i) -> Fl_Char"""
        return _fltk.Fl_Input__index(self, *args)


    def size(self, *args):
        """
        size(Fl_Input_ self) -> int
        size(Fl_Input_ self, int W, int H)
        """
        return _fltk.Fl_Input__size(self, *args)


    def maximum_size(self, *args):
        """
        maximum_size(Fl_Input_ self) -> int
        maximum_size(Fl_Input_ self, int m)
        """
        return _fltk.Fl_Input__maximum_size(self, *args)


    def position(self, *args):
        """
        position(Fl_Input_ self) -> int
        position(Fl_Input_ self, int p, int m) -> int
        position(Fl_Input_ self, int p) -> int
        """
        return _fltk.Fl_Input__position(self, *args)


    def mark(self, *args):
        """
        mark(Fl_Input_ self) -> int
        mark(Fl_Input_ self, int m) -> int
        """
        return _fltk.Fl_Input__mark(self, *args)


    def replace(self, *args):
        """replace(Fl_Input_ self, int b, int e, char const * text, int ilen=0) -> int"""
        return _fltk.Fl_Input__replace(self, *args)


    def cut(self, *args):
        """
        cut(Fl_Input_ self) -> int
        cut(Fl_Input_ self, int n) -> int
        cut(Fl_Input_ self, int a, int b) -> int
        """
        return _fltk.Fl_Input__cut(self, *args)


    def insert(self, *args):
        """insert(Fl_Input_ self, char const * t, int l=0) -> int"""
        return _fltk.Fl_Input__insert(self, *args)


    def copy(self, *args):
        """copy(Fl_Input_ self, int clipboard) -> int"""
        return _fltk.Fl_Input__copy(self, *args)


    def undo(self, *args):
        """undo(Fl_Input_ self) -> int"""
        return _fltk.Fl_Input__undo(self, *args)


    def copy_cuts(self, *args):
        """copy_cuts(Fl_Input_ self) -> int"""
        return _fltk.Fl_Input__copy_cuts(self, *args)


    def shortcut(self, *args):
        """
        shortcut(Fl_Input_ self) -> int
        shortcut(Fl_Input_ self, int s)
        """
        return _fltk.Fl_Input__shortcut(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Input_ self) -> Fl_Font
        textfont(Fl_Input_ self, Fl_Font s)
        """
        return _fltk.Fl_Input__textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Input_ self) -> Fl_Fontsize
        textsize(Fl_Input_ self, Fl_Fontsize s)
        """
        return _fltk.Fl_Input__textsize(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Input_ self) -> Fl_Color
        textcolor(Fl_Input_ self, Fl_Color n)
        """
        return _fltk.Fl_Input__textcolor(self, *args)


    def cursor_color(self, *args):
        """
        cursor_color(Fl_Input_ self) -> Fl_Color
        cursor_color(Fl_Input_ self, Fl_Color n)
        """
        return _fltk.Fl_Input__cursor_color(self, *args)


    def input_type(self, *args):
        """
        input_type(Fl_Input_ self) -> int
        input_type(Fl_Input_ self, int t)
        """
        return _fltk.Fl_Input__input_type(self, *args)


    def readonly(self, *args):
        """
        readonly(Fl_Input_ self) -> int
        readonly(Fl_Input_ self, int b)
        """
        return _fltk.Fl_Input__readonly(self, *args)


    def wrap(self, *args):
        """
        wrap(Fl_Input_ self) -> int
        wrap(Fl_Input_ self, int b)
        """
        return _fltk.Fl_Input__wrap(self, *args)


    def tab_nav(self, *args):
        """
        tab_nav(Fl_Input_ self, int val)
        tab_nav(Fl_Input_ self) -> int
        """
        return _fltk.Fl_Input__tab_nav(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Input_(self)
        return weakref_proxy(self)
Fl_Input__swigregister = _fltk.Fl_Input__swigregister
Fl_Input__swigregister(Fl_Input_)

class Fl_Input(Fl_Input_):
    """

    This is the FLTK text input widget. It displays a single line of text and 
    lets the user edit it. Normally it is drawn with an inset box and a white 
    background. The text may contain any characters (even 0), and will correctly 
    display anything, using ^X notation for unprintable control characters 
    and 
    nn notation for unprintable characters with the high bit set. It 
    assumes the font can draw any characters in the ISO-8859-1 character set.
    Mouse button 1	Moves the cursor to this point. Drag selects characters. 
    Double click selects words. Triple click selects all text. Shift+click 
    extends the selection. When you select text it is automatically copied 
    to the clipboard.
    Mouse button 2	Insert the clipboard at the point clicked. You can also 
    select a region and replace it with the clipboard by selecting the region 
    with mouse button 2.
    Mouse button 3	Currently acts like button 1.
    Backspace	Deletes one character to the left, or deletes the selected 
    region.
    Enter	May cause the callback, see when().
    ^A or Home	Go to start of line.
    ^B or Left	Move left
    ^C	Copy the selection to the clipboard
    ^D or Delete	Deletes one character to the right or deletes the selected 
    region.
    ^E or End	Go to the end of line.
    ^F or Right	Move right
    ^K	Delete to the end of line (next 
     character) or deletes a single 

    character. These deletions are all concatenated into the clipboard.
    ^N or Down	Move down (for Fl_Multiline_Input only, otherwise it moves
    to the next input field).
    ^P or Up	Move up (for Fl_Multiline_Input only, otherwise it moves to 
    the previous input field).
    ^U	Delete everything.
    ^V or ^Y	Paste the clipboard
    ^X or ^W	Copy the region to the clipboard and delete it.
    ^Z or ^_	Undo. This is a single-level undo mechanism, but all adjacent 
    deletions and insertions are concatenated into a single 'undo'. Often this 
    will undo a lot more than you expected.
    Shift+move	Move the cursor but also extend the selection.
    RightCtrl or
    Compose	Start a compose-character sequence. The next one or two keys typed 
    define the character to insert (see table that follows.)

    The character 'nbsp' (non-breaking space) is typed by using [compose][space].

    The single-character sequences may be followed by a space if necessary to 
    remove ambiguity. 

    The same key may be used to 'quote' control characters into the text. If you 
    need a ^Q character you can get one by typing [compose][Control+Q].

    X may have a key on the keyboard defined as XK_Multi_key. If so this key 
    may be used as well as the right-hand control key. You can set this up 
    with the program xmodmap.

    If your keyboard is set to support a foreign language you should also be 
    able to type 'dead key' prefix characters. On X you will actually be able 
    to see what dead key you typed, and if you then move the cursor without 
    completing the sequence the accent will remain inserted. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Input self)"""
        return _fltk.Fl_Input_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Input self, int arg0) -> int"""
        return _fltk.Fl_Input_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Input self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Input"""
        if self.__class__ == Fl_Input:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Input(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Input
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Input(self)
        return weakref_proxy(self)
Fl_Input_swigregister = _fltk.Fl_Input_swigregister
Fl_Input_swigregister(Fl_Input)

class Fl_File_Input(Fl_Input):
    """

    This widget displays a pathname in a text input field. A navigation bar 
    located above the input field allows the user to navigate upward in the 
    directory tree.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_File_Input self, int X, int Y, int W, int H, char const * L=None) -> Fl_File_Input"""
        if self.__class__ == Fl_File_Input:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_File_Input(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def handle(self, *args):
        """handle(Fl_File_Input self, int event) -> int"""
        return _fltk.Fl_File_Input_handle(self, *args)


    def draw(self, *args):
        """draw(Fl_File_Input self)"""
        return _fltk.Fl_File_Input_draw(self, *args)


    def down_box(self, *args):
        """
        down_box(Fl_File_Input self) -> Fl_Boxtype
        down_box(Fl_File_Input self, Fl_Boxtype b)
        """
        return _fltk.Fl_File_Input_down_box(self, *args)


    def errorcolor(self, *args):
        """
        errorcolor(Fl_File_Input self) -> Fl_Color
        errorcolor(Fl_File_Input self, Fl_Color c)
        """
        return _fltk.Fl_File_Input_errorcolor(self, *args)


    def value(self, *args):
        """
        value(Fl_File_Input self, char const * str) -> int
        value(Fl_File_Input self, char const * str, int len) -> int
        value(Fl_File_Input self) -> char const *
        """
        return _fltk.Fl_File_Input_value(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_File_Input
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_File_Input(self)
        return weakref_proxy(self)
Fl_File_Input_swigregister = _fltk.Fl_File_Input_swigregister
Fl_File_Input_swigregister(Fl_File_Input)

class Fl_Fill_Dial(Fl_Dial):
    """

    The Fl_Fill_Dial widget provides a filled, circular dial to control a single 
    floating point value.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Fill_Dial self, int X, int Y, int W, int H, char const * L) -> Fl_Fill_Dial"""
        if self.__class__ == Fl_Fill_Dial:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Fill_Dial(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Fill_Dial
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Fill_Dial(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Fill_Dial self)"""
        return _fltk.Fl_Fill_Dial_draw(self, *args)

Fl_Fill_Dial_swigregister = _fltk.Fl_Fill_Dial_swigregister
Fl_Fill_Dial_swigregister(Fl_Fill_Dial)


_fltk.FL_VERT_SLIDER_swigconstant(_fltk)
FL_VERT_SLIDER = _fltk.FL_VERT_SLIDER

_fltk.FL_HOR_SLIDER_swigconstant(_fltk)
FL_HOR_SLIDER = _fltk.FL_HOR_SLIDER

_fltk.FL_VERT_FILL_SLIDER_swigconstant(_fltk)
FL_VERT_FILL_SLIDER = _fltk.FL_VERT_FILL_SLIDER

_fltk.FL_HOR_FILL_SLIDER_swigconstant(_fltk)
FL_HOR_FILL_SLIDER = _fltk.FL_HOR_FILL_SLIDER

_fltk.FL_VERT_NICE_SLIDER_swigconstant(_fltk)
FL_VERT_NICE_SLIDER = _fltk.FL_VERT_NICE_SLIDER

_fltk.FL_HOR_NICE_SLIDER_swigconstant(_fltk)
FL_HOR_NICE_SLIDER = _fltk.FL_HOR_NICE_SLIDER
class Fl_Slider(Fl_Valuator):
    """

    The Fl_Slider widget contains a sliding knob inside a box. It if often 
    used as a scrollbar. Moving the box all the way to the top/left sets it 
    to the minimum(), and to the bottom/right to the maximum(). The minimum() 
    may be greater than the maximum() to reverse the slider direction.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Slider self)"""
        return _fltk.Fl_Slider_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Slider self, int arg0) -> int"""
        return _fltk.Fl_Slider_handle(self, *args)


    def __init__(self, *args):
        """
        __init__(Fl_Slider self, int X, int Y, int W, int H, char const * L=None) -> Fl_Slider
        __init__(Fl_Slider self, uchar t, int X, int Y, int W, int H, char const * L) -> Fl_Slider
        """
        if self.__class__ == Fl_Slider:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Slider(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def scrollvalue(self, *args):
        """scrollvalue(Fl_Slider self, int pos, int size, int first, int total) -> int"""
        return _fltk.Fl_Slider_scrollvalue(self, *args)


    def bounds(self, *args):
        """bounds(Fl_Slider self, double a, double b)"""
        return _fltk.Fl_Slider_bounds(self, *args)


    def slider_size(self, *args):
        """
        slider_size(Fl_Slider self) -> float
        slider_size(Fl_Slider self, double v)
        """
        return _fltk.Fl_Slider_slider_size(self, *args)


    def slider(self, *args):
        """
        slider(Fl_Slider self) -> Fl_Boxtype
        slider(Fl_Slider self, Fl_Boxtype c)
        """
        return _fltk.Fl_Slider_slider(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Slider
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Slider(self)
        return weakref_proxy(self)
Fl_Slider_swigregister = _fltk.Fl_Slider_swigregister
Fl_Slider_swigregister(Fl_Slider)

class Fl_Fill_Slider(Fl_Slider):
    """

    The Fl_Fill_Slider widget contains a sliding knob inside a box. It if often 
    used as a scrollbar. Moving the box all the way to the top/left sets it to 
    the minimum(), and to the bottom/right to the maximum(). The minimum() may 
    be greater than the maximum() to reverse the slider direction.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Fill_Slider self, int X, int Y, int W, int H, char const * L=None) -> Fl_Fill_Slider"""
        if self.__class__ == Fl_Fill_Slider:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Fill_Slider(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Fill_Slider
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Fill_Slider(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Fill_Slider self)"""
        return _fltk.Fl_Fill_Slider_draw(self, *args)

Fl_Fill_Slider_swigregister = _fltk.Fl_Fill_Slider_swigregister
Fl_Fill_Slider_swigregister(Fl_Fill_Slider)

class Fl_Float_Input(Fl_Input):
    """

    The Fl_Float_Input class is a subclass of Fl_Input  that only allows the 
    user to type floating point numbers (sign, digits, decimal point, more 
    digits, 'E' or 'e', sign, digits).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Float_Input self, int X, int Y, int W, int H, char const * l=None) -> Fl_Float_Input"""
        if self.__class__ == Fl_Float_Input:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Float_Input(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Float_Input
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Float_Input(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Float_Input self)"""
        return _fltk.Fl_Float_Input_draw(self, *args)

Fl_Float_Input_swigregister = _fltk.Fl_Float_Input_swigregister
Fl_Float_Input_swigregister(Fl_Float_Input)

class Fl_FormsBitmap(Fl_Widget):
    """Proxy of C++ Fl_FormsBitmap class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_FormsBitmap self)"""
        return _fltk.Fl_FormsBitmap_draw(self, *args)


    def __init__(self, *args):
        """__init__(Fl_FormsBitmap self, Fl_Boxtype arg2, int arg3, int arg4, int arg5, int arg6, char const * arg7=None) -> Fl_FormsBitmap"""
        if self.__class__ == Fl_FormsBitmap:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_FormsBitmap(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def set(self, *args):
        """set(Fl_FormsBitmap self, int W, int H, uchar const * bits)"""
        return _fltk.Fl_FormsBitmap_set(self, *args)


    def bitmap(self, *args):
        """
        bitmap(Fl_FormsBitmap self, Fl_Bitmap B)
        bitmap(Fl_FormsBitmap self) -> Fl_Bitmap
        """
        return _fltk.Fl_FormsBitmap_bitmap(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_FormsBitmap
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_FormsBitmap(self)
        return weakref_proxy(self)
Fl_FormsBitmap_swigregister = _fltk.Fl_FormsBitmap_swigregister
Fl_FormsBitmap_swigregister(Fl_FormsBitmap)

class Fl_FormsPixmap(Fl_Widget):
    """Proxy of C++ Fl_FormsPixmap class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_FormsPixmap self)"""
        return _fltk.Fl_FormsPixmap_draw(self, *args)


    def __init__(self, *args):
        """__init__(Fl_FormsPixmap self, Fl_Boxtype t, int X, int Y, int W, int H, char const * L=None) -> Fl_FormsPixmap"""
        if self.__class__ == Fl_FormsPixmap:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_FormsPixmap(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def set(self, *args):
        """set(Fl_FormsPixmap self, char *const * bits)"""
        return _fltk.Fl_FormsPixmap_set(self, *args)


    def Pixmap(self, *args):
        """
        Pixmap(Fl_FormsPixmap self, Fl_Pixmap B)
        Pixmap(Fl_FormsPixmap self) -> Fl_Pixmap
        """
        return _fltk.Fl_FormsPixmap_Pixmap(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_FormsPixmap
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_FormsPixmap(self)
        return weakref_proxy(self)
Fl_FormsPixmap_swigregister = _fltk.Fl_FormsPixmap_swigregister
Fl_FormsPixmap_swigregister(Fl_FormsPixmap)


_fltk.FL_NORMAL_FREE_swigconstant(_fltk)
FL_NORMAL_FREE = _fltk.FL_NORMAL_FREE

_fltk.FL_SLEEPING_FREE_swigconstant(_fltk)
FL_SLEEPING_FREE = _fltk.FL_SLEEPING_FREE

_fltk.FL_INPUT_FREE_swigconstant(_fltk)
FL_INPUT_FREE = _fltk.FL_INPUT_FREE

_fltk.FL_CONTINUOUS_FREE_swigconstant(_fltk)
FL_CONTINUOUS_FREE = _fltk.FL_CONTINUOUS_FREE

_fltk.FL_ALL_FREE_swigconstant(_fltk)
FL_ALL_FREE = _fltk.FL_ALL_FREE
class Fl_Free(Fl_Widget):
    """

    Emulation of the Forms 'free' widget. This emulation allows the free demo 
    to run, and appears to be useful for porting programs written in Forms which 
    use the free widget or make subclasses of the Forms widgets.

    There are five types of free, which determine when the handle function is 
    called:

          FL_NORMAL_FREE		1
          FL_SLEEPING_FREE		2
          FL_INPUT_FREE		3
          FL_CONTINUOUS_FREE	4
          FL_ALL_FREE		5

    An FL_INPUT_FREE accepts FL_FOCUS events. A FL_CONTINUOUS_FREE sets a 
    timeout callback 100 times a second and provides a FL_STEP event, this 
    has obvious detrimental effects on machine performance. FL_ALL_FREE does 
    both. FL_SLEEPING_FREE are deactivated. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Free self)"""
        return _fltk.Fl_Free_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Free self, int e) -> int"""
        return _fltk.Fl_Free_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Free self, uchar t, int X, int Y, int W, int H, char const * L, FL_HANDLEPTR hdl) -> Fl_Free"""
        if self.__class__ == Fl_Free:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Free(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Free
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Free(self)
        return weakref_proxy(self)
Fl_Free_swigregister = _fltk.Fl_Free_swigregister
Fl_Free_swigregister(Fl_Free)


_fltk.FL_DRAW_swigconstant(_fltk)
FL_DRAW = _fltk.FL_DRAW

_fltk.FL_STEP_swigconstant(_fltk)
FL_STEP = _fltk.FL_STEP

_fltk.FL_FREEMEM_swigconstant(_fltk)
FL_FREEMEM = _fltk.FL_FREEMEM

_fltk.FL_FREEZE_swigconstant(_fltk)
FL_FREEZE = _fltk.FL_FREEZE

_fltk.FL_THAW_swigconstant(_fltk)
FL_THAW = _fltk.FL_THAW
class Fl_Pixmap(Fl_Image):
    """

    The Fl_Pixmap class supports caching and drawing of colormap (pixmap) images, including transparency.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Pixmap self, char const *const * D) -> Fl_Pixmap"""
        if self.__class__ == Fl_Pixmap:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Pixmap(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Pixmap
    __del__ = lambda self: None

    def copy(self, *args):
        """
        copy(Fl_Pixmap self, int W, int H) -> Fl_Image
        copy(Fl_Pixmap self) -> Fl_Image
        """
        return _fltk.Fl_Pixmap_copy(self, *args)


    def color_average(self, *args):
        """color_average(Fl_Pixmap self, Fl_Color c, float i)"""
        return _fltk.Fl_Pixmap_color_average(self, *args)


    def desaturate(self, *args):
        """desaturate(Fl_Pixmap self)"""
        return _fltk.Fl_Pixmap_desaturate(self, *args)


    def draw(self, *args):
        """
        draw(Fl_Pixmap self, int X, int Y, int W, int H, int cx=0, int cy=0)
        draw(Fl_Pixmap self, int X, int Y)
        """
        return _fltk.Fl_Pixmap_draw(self, *args)


    def label(self, *args):
        """
        label(Fl_Pixmap self, Fl_Widget w)
        label(Fl_Pixmap self, Fl_Menu_Item m)
        """
        return _fltk.Fl_Pixmap_label(self, *args)


    def uncache(self, *args):
        """uncache(Fl_Pixmap self)"""
        return _fltk.Fl_Pixmap_uncache(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Pixmap(self)
        return weakref_proxy(self)
Fl_Pixmap_swigregister = _fltk.Fl_Pixmap_swigregister
Fl_Pixmap_swigregister(Fl_Pixmap)

class Fl_GIF_Image(Fl_Pixmap):
    """

    The Fl_GIF_Image class supports loading, caching, and drawing of Compuserve 
    GIF images. The class loads the first image and supports transparency.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_GIF_Image self, char const * filename) -> Fl_GIF_Image"""
        if self.__class__ == Fl_GIF_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_GIF_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_GIF_Image
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_GIF_Image(self)
        return weakref_proxy(self)
Fl_GIF_Image_swigregister = _fltk.Fl_GIF_Image_swigregister
Fl_GIF_Image_swigregister(Fl_GIF_Image)

class Fl_Gl_Window(Fl_Window):
    """

    The Fl_Gl_Window widget sets things up so OpenGL works, and also keeps an 
    OpenGL 'context' for that window, so that changes to the lighting and 
    projection may be reused between redraws. Fl_Gl_Window also flushes the 
    OpenGL streams and swaps buffers after draw()  returns.

    OpenGL hardware typically provides some overlay bit planes, which are very 
    useful for drawing UI controls atop your 3D graphics. If the overlay hardware 
    is not provided, FLTK tries to simulate the overlay, This works pretty well 
    if your graphics are double buffered, but not very well for single-buffered. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def flush(self, *args):
        """flush(Fl_Gl_Window self)"""
        return _fltk.Fl_Gl_Window_flush(self, *args)


    def hide(self, *args):
        """hide(Fl_Gl_Window self)"""
        return _fltk.Fl_Gl_Window_hide(self, *args)


    def resize(self, *args):
        """resize(Fl_Gl_Window self, int arg0, int arg1, int arg2, int arg3)"""
        return _fltk.Fl_Gl_Window_resize(self, *args)


    def handle(self, *args):
        """handle(Fl_Gl_Window self, int arg0) -> int"""
        return _fltk.Fl_Gl_Window_handle(self, *args)


    def valid(self, *args):
        """
        valid(Fl_Gl_Window self) -> char
        valid(Fl_Gl_Window self, char v)
        """
        return _fltk.Fl_Gl_Window_valid(self, *args)


    def invalidate(self, *args):
        """invalidate(Fl_Gl_Window self)"""
        return _fltk.Fl_Gl_Window_invalidate(self, *args)


    def context_valid(self, *args):
        """
        context_valid(Fl_Gl_Window self) -> char
        context_valid(Fl_Gl_Window self, char v)
        """
        return _fltk.Fl_Gl_Window_context_valid(self, *args)


    def can_do(self, *args):
        """
        can_do(Fl_Gl_Window self, int m) -> int
        can_do(Fl_Gl_Window self, int const * m) -> int
        can_do(Fl_Gl_Window self) -> int
        """
        return _fltk.Fl_Gl_Window_can_do(self, *args)


    def mode(self, *args):
        """
        mode(Fl_Gl_Window self) -> Fl_Mode
        mode(Fl_Gl_Window self, int a) -> int
        mode(Fl_Gl_Window self, int const * a) -> int
        """
        return _fltk.Fl_Gl_Window_mode(self, *args)


    def context(self, *args):
        """
        context(Fl_Gl_Window self)
        context(Fl_Gl_Window self, void * arg2, int destroy_flag=0)
        """
        return _fltk.Fl_Gl_Window_context(self, *args)


    def make_current(self, *args):
        """make_current(Fl_Gl_Window self)"""
        return _fltk.Fl_Gl_Window_make_current(self, *args)


    def swap_buffers(self, *args):
        """swap_buffers(Fl_Gl_Window self)"""
        return _fltk.Fl_Gl_Window_swap_buffers(self, *args)


    def ortho(self, *args):
        """ortho(Fl_Gl_Window self)"""
        return _fltk.Fl_Gl_Window_ortho(self, *args)


    def can_do_overlay(self, *args):
        """can_do_overlay(Fl_Gl_Window self) -> int"""
        return _fltk.Fl_Gl_Window_can_do_overlay(self, *args)


    def redraw_overlay(self, *args):
        """redraw_overlay(Fl_Gl_Window self)"""
        return _fltk.Fl_Gl_Window_redraw_overlay(self, *args)


    def hide_overlay(self, *args):
        """hide_overlay(Fl_Gl_Window self)"""
        return _fltk.Fl_Gl_Window_hide_overlay(self, *args)


    def make_overlay_current(self, *args):
        """make_overlay_current(Fl_Gl_Window self)"""
        return _fltk.Fl_Gl_Window_make_overlay_current(self, *args)


    def as_gl_window(self, *args):
        """as_gl_window(Fl_Gl_Window self) -> Fl_Gl_Window"""
        return _fltk.Fl_Gl_Window_as_gl_window(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Gl_Window
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Fl_Gl_Window self, int W, int H, char const * l=None) -> Fl_Gl_Window
        __init__(Fl_Gl_Window self, int X, int Y, int W, int H, char const * l=None) -> Fl_Gl_Window
        """
        if self.__class__ == Fl_Gl_Window:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Gl_Window(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def draw(self, *args):
        """draw(Fl_Gl_Window self)"""
        return _fltk.Fl_Gl_Window_draw(self, *args)


    def show(self, *args):
        """show(Fl_Gl_Window self, PyObject * count=None, PyObject * data=None)"""
        return _fltk.Fl_Gl_Window_show(self, *args)


    def drawPixels(self, *args):
        """
        drawPixels(Fl_Gl_Window self, PyObject * rgb_py)

        Writes a raw RGB string to the canvas.

        Arguments:
            - rgb - a string of width * height * 3 bytes, comprising
              the raw image in RGB format

        """
        return _fltk.Fl_Gl_Window_drawPixels(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Gl_Window(self)
        return weakref_proxy(self)
Fl_Gl_Window_swigregister = _fltk.Fl_Gl_Window_swigregister
Fl_Gl_Window_swigregister(Fl_Gl_Window)


def gl_start(*args):
    """gl_start()"""
    return _fltk.gl_start(*args)

def gl_finish(*args):
    """gl_finish()"""
    return _fltk.gl_finish(*args)

def gl_color(*args):
    """
    gl_color(Fl_Color i)
    gl_color(int c)
    """
    return _fltk.gl_color(*args)

def gl_rect(*args):
    """gl_rect(int x, int y, int w, int h)"""
    return _fltk.gl_rect(*args)

def gl_rectf(*args):
    """gl_rectf(int x, int y, int w, int h)"""
    return _fltk.gl_rectf(*args)

def gl_font(*args):
    """gl_font(int fontid, int size)"""
    return _fltk.gl_font(*args)

def gl_height(*args):
    """gl_height() -> int"""
    return _fltk.gl_height(*args)

def gl_descent(*args):
    """gl_descent() -> int"""
    return _fltk.gl_descent(*args)

def gl_width(*args):
    """
    gl_width(char const * arg1) -> double
    gl_width(char const * arg1, int n) -> double
    gl_width(uchar arg1) -> double
    """
    return _fltk.gl_width(*args)

def gl_draw(*args):
    """
    gl_draw(char const * arg1)
    gl_draw(char const * arg1, int n)
    gl_draw(char const * arg1, int x, int y)
    gl_draw(char const * arg1, float x, float y)
    gl_draw(char const * arg1, int n, int x, int y)
    gl_draw(char const * arg1, int n, float x, float y)
    gl_draw(char const * arg1, int x, int y, int w, int h, Fl_Align arg6)
    """
    return _fltk.gl_draw(*args)

def gl_measure(*args):
    """gl_measure(char const * arg1)"""
    return _fltk.gl_measure(*args)

def gl_draw_image(*args):
    """gl_draw_image(uchar const * arg1, int x, int y, int w, int h, int d=3, int ld=0)"""
    return _fltk.gl_draw_image(*args)
class Fl_Help_Dialog(object):
    """

    The Fl_Help_Dialog widget displays a standard help dialog window using the 
    Fl_Help_View widget.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Help_Dialog self) -> Fl_Help_Dialog"""
        this = _fltk.new_Fl_Help_Dialog(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Help_Dialog
    __del__ = lambda self: None

    def h(self, *args):
        """h(Fl_Help_Dialog self) -> int"""
        return _fltk.Fl_Help_Dialog_h(self, *args)


    def hide(self, *args):
        """hide(Fl_Help_Dialog self)"""
        return _fltk.Fl_Help_Dialog_hide(self, *args)


    def load(self, *args):
        """load(Fl_Help_Dialog self, char const * f)"""
        return _fltk.Fl_Help_Dialog_load(self, *args)


    def position(self, *args):
        """position(Fl_Help_Dialog self, int xx, int yy)"""
        return _fltk.Fl_Help_Dialog_position(self, *args)


    def resize(self, *args):
        """resize(Fl_Help_Dialog self, int xx, int yy, int ww, int hh)"""
        return _fltk.Fl_Help_Dialog_resize(self, *args)


    def show(self, *args):
        """
        show(Fl_Help_Dialog self)
        show(Fl_Help_Dialog self, int argc, char ** argv)
        """
        return _fltk.Fl_Help_Dialog_show(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Help_Dialog self, Fl_Fontsize s)
        textsize(Fl_Help_Dialog self) -> Fl_Fontsize
        """
        return _fltk.Fl_Help_Dialog_textsize(self, *args)


    def topline(self, *args):
        """
        topline(Fl_Help_Dialog self, char const * n)
        topline(Fl_Help_Dialog self, int n)
        """
        return _fltk.Fl_Help_Dialog_topline(self, *args)


    def value(self, *args):
        """
        value(Fl_Help_Dialog self, char const * f)
        value(Fl_Help_Dialog self) -> char const *
        """
        return _fltk.Fl_Help_Dialog_value(self, *args)


    def visible(self, *args):
        """visible(Fl_Help_Dialog self) -> int"""
        return _fltk.Fl_Help_Dialog_visible(self, *args)


    def w(self, *args):
        """w(Fl_Help_Dialog self) -> int"""
        return _fltk.Fl_Help_Dialog_w(self, *args)


    def x(self, *args):
        """x(Fl_Help_Dialog self) -> int"""
        return _fltk.Fl_Help_Dialog_x(self, *args)


    def y(self, *args):
        """y(Fl_Help_Dialog self) -> int"""
        return _fltk.Fl_Help_Dialog_y(self, *args)

Fl_Help_Dialog_swigregister = _fltk.Fl_Help_Dialog_swigregister
Fl_Help_Dialog_swigregister(Fl_Help_Dialog)

class Fl_Help_Block(object):
    """Proxy of C++ Fl_Help_Block class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Help_Block self) -> Fl_Help_Block"""
        this = _fltk.new_Fl_Help_Block(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Help_Block
    __del__ = lambda self: None
Fl_Help_Block_swigregister = _fltk.Fl_Help_Block_swigregister
Fl_Help_Block_swigregister(Fl_Help_Block)

class Fl_Help_Link(object):
    """Proxy of C++ Fl_Help_Link class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Help_Link self) -> Fl_Help_Link"""
        this = _fltk.new_Fl_Help_Link(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Help_Link
    __del__ = lambda self: None
Fl_Help_Link_swigregister = _fltk.Fl_Help_Link_swigregister
Fl_Help_Link_swigregister(Fl_Help_Link)

class Fl_Help_Font_Style(object):
    """Proxy of C++ Fl_Help_Font_Style class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def get(self, *args):
        """get(Fl_Help_Font_Style self, Fl_Color & acolor)"""
        return _fltk.Fl_Help_Font_Style_get(self, *args)


    def set(self, *args):
        """set(Fl_Help_Font_Style self, Fl_Font afont, Fl_Fontsize asize, Fl_Color acolor)"""
        return _fltk.Fl_Help_Font_Style_set(self, *args)


    def __init__(self, *args):
        """
        __init__(Fl_Help_Font_Style self, Fl_Font afont, Fl_Fontsize asize, Fl_Color acolor) -> Fl_Help_Font_Style
        __init__(Fl_Help_Font_Style self) -> Fl_Help_Font_Style
        """
        this = _fltk.new_Fl_Help_Font_Style(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Help_Font_Style
    __del__ = lambda self: None
Fl_Help_Font_Style_swigregister = _fltk.Fl_Help_Font_Style_swigregister
Fl_Help_Font_Style_swigregister(Fl_Help_Font_Style)

class Fl_Help_Font_Stack(object):
    """Proxy of C++ Fl_Help_Font_Stack class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Help_Font_Stack self) -> Fl_Help_Font_Stack"""
        this = _fltk.new_Fl_Help_Font_Stack(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def init(self, *args):
        """init(Fl_Help_Font_Stack self, Fl_Font f, Fl_Fontsize s, Fl_Color c)"""
        return _fltk.Fl_Help_Font_Stack_init(self, *args)


    def top(self, *args):
        """top(Fl_Help_Font_Stack self, Fl_Color & c)"""
        return _fltk.Fl_Help_Font_Stack_top(self, *args)


    def push(self, *args):
        """push(Fl_Help_Font_Stack self, Fl_Font f, Fl_Fontsize s, Fl_Color c)"""
        return _fltk.Fl_Help_Font_Stack_push(self, *args)


    def pop(self, *args):
        """pop(Fl_Help_Font_Stack self, Fl_Color & c)"""
        return _fltk.Fl_Help_Font_Stack_pop(self, *args)


    def count(self, *args):
        """count(Fl_Help_Font_Stack self) -> size_t"""
        return _fltk.Fl_Help_Font_Stack_count(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Help_Font_Stack
    __del__ = lambda self: None
Fl_Help_Font_Stack_swigregister = _fltk.Fl_Help_Font_Stack_swigregister
Fl_Help_Font_Stack_swigregister(Fl_Help_Font_Stack)

class Fl_Help_Target(object):
    """Proxy of C++ Fl_Help_Target class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Help_Target self) -> Fl_Help_Target"""
        this = _fltk.new_Fl_Help_Target(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Help_Target
    __del__ = lambda self: None
Fl_Help_Target_swigregister = _fltk.Fl_Help_Target_swigregister
Fl_Help_Target_swigregister(Fl_Help_Target)

class Fl_Help_View(Fl_Group):
    """

    The Fl_Help_View widget displays HTML text. Most HTML 2.0 elements are 
    supported, as well as a primitive implementation of tables. GIF, JPEG, 
    and PNG images are displayed inline.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Help_View self, int xx, int yy, int ww, int hh, char const * l=None) -> Fl_Help_View"""
        if self.__class__ == Fl_Help_View:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Help_View(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Help_View
    __del__ = lambda self: None

    def directory(self, *args):
        """directory(Fl_Help_View self) -> char const *"""
        return _fltk.Fl_Help_View_directory(self, *args)


    def filename(self, *args):
        """filename(Fl_Help_View self) -> char const *"""
        return _fltk.Fl_Help_View_filename(self, *args)


    def find(self, *args):
        """find(Fl_Help_View self, char const * s, int p=0) -> int"""
        return _fltk.Fl_Help_View_find(self, *args)


    def load(self, *args):
        """load(Fl_Help_View self, char const * f) -> int"""
        return _fltk.Fl_Help_View_load(self, *args)


    def resize(self, *args):
        """resize(Fl_Help_View self, int arg0, int arg1, int arg2, int arg3)"""
        return _fltk.Fl_Help_View_resize(self, *args)


    def size(self, *args):
        """
        size(Fl_Help_View self) -> int
        size(Fl_Help_View self, int W, int H)
        """
        return _fltk.Fl_Help_View_size(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Help_View self, Fl_Color c)
        textcolor(Fl_Help_View self) -> Fl_Color
        """
        return _fltk.Fl_Help_View_textcolor(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Help_View self, Fl_Font f)
        textfont(Fl_Help_View self) -> Fl_Font
        """
        return _fltk.Fl_Help_View_textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Help_View self, Fl_Fontsize s)
        textsize(Fl_Help_View self) -> Fl_Fontsize
        """
        return _fltk.Fl_Help_View_textsize(self, *args)


    def title(self, *args):
        """title(Fl_Help_View self) -> char const *"""
        return _fltk.Fl_Help_View_title(self, *args)


    def topline(self, *args):
        """
        topline(Fl_Help_View self, char const * n)
        topline(Fl_Help_View self, int arg2)
        topline(Fl_Help_View self) -> int
        """
        return _fltk.Fl_Help_View_topline(self, *args)


    def leftline(self, *args):
        """
        leftline(Fl_Help_View self, int arg2)
        leftline(Fl_Help_View self) -> int
        """
        return _fltk.Fl_Help_View_leftline(self, *args)


    def value(self, *args):
        """
        value(Fl_Help_View self, char const * val)
        value(Fl_Help_View self) -> char const *
        """
        return _fltk.Fl_Help_View_value(self, *args)


    def clear_selection(self, *args):
        """clear_selection(Fl_Help_View self)"""
        return _fltk.Fl_Help_View_clear_selection(self, *args)


    def select_all(self, *args):
        """select_all(Fl_Help_View self)"""
        return _fltk.Fl_Help_View_select_all(self, *args)


    def scrollbar_size(self, *args):
        """
        scrollbar_size(Fl_Help_View self) -> int
        scrollbar_size(Fl_Help_View self, int newSize)
        """
        return _fltk.Fl_Help_View_scrollbar_size(self, *args)


    def link(self, *args):
        """
        link(Fl_Help_View self, Fl_Help_Func * fn)
        link(Fl_Help_View self, PyObject * PyFunc, PyObject * PyWidget)
        """
        return _fltk.Fl_Help_View_link(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Help_View(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Help_View self)"""
        return _fltk.Fl_Help_View_draw(self, *args)

Fl_Help_View_swigregister = _fltk.Fl_Help_View_swigregister
Fl_Help_View_swigregister(Fl_Help_View)

class Fl_Hold_Browser(Fl_Browser):
    """

    The Fl_Hold_Browser class is a subclass of Fl_Browser  which lets the user 
    select a single item, or no items by clicking on the empty space. As long 
    as the mouse button is held down the item pointed to by it is highlighted, 
    and this highlighting remains on when the mouse button is released. Normally 
    the callback is done when the user releases the mouse, but you can change 
    this with when().

    See Fl_Browser for methods to add and remove lines from the browser. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Hold_Browser self, int X, int Y, int W, int H, char const * L=None) -> Fl_Hold_Browser"""
        if self.__class__ == Fl_Hold_Browser:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Hold_Browser(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Hold_Browser
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Hold_Browser(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Hold_Browser self)"""
        return _fltk.Fl_Hold_Browser_draw(self, *args)


    def item_first(self, *args):
        """item_first(Fl_Hold_Browser self) -> void *"""
        return _fltk.Fl_Hold_Browser_item_first(self, *args)


    def item_next(self, *args):
        """item_next(Fl_Hold_Browser self, void * item) -> void *"""
        return _fltk.Fl_Hold_Browser_item_next(self, *args)


    def item_prev(self, *args):
        """item_prev(Fl_Hold_Browser self, void * item) -> void *"""
        return _fltk.Fl_Hold_Browser_item_prev(self, *args)


    def item_last(self, *args):
        """item_last(Fl_Hold_Browser self) -> void *"""
        return _fltk.Fl_Hold_Browser_item_last(self, *args)


    def item_height(self, *args):
        """item_height(Fl_Hold_Browser self, void * item) -> int"""
        return _fltk.Fl_Hold_Browser_item_height(self, *args)


    def item_width(self, *args):
        """item_width(Fl_Hold_Browser self, void * item) -> int"""
        return _fltk.Fl_Hold_Browser_item_width(self, *args)


    def item_quick_height(self, *args):
        """item_quick_height(Fl_Hold_Browser self, void * item) -> int"""
        return _fltk.Fl_Hold_Browser_item_quick_height(self, *args)


    def item_draw(self, *args):
        """item_draw(Fl_Hold_Browser self, void * item, int X, int Y, int W, int H)"""
        return _fltk.Fl_Hold_Browser_item_draw(self, *args)


    def item_text(self, *args):
        """item_text(Fl_Hold_Browser self, void * item) -> char const *"""
        return _fltk.Fl_Hold_Browser_item_text(self, *args)


    def item_swap(self, *args):
        """item_swap(Fl_Hold_Browser self, void * a, void * b)"""
        return _fltk.Fl_Hold_Browser_item_swap(self, *args)


    def item_at(self, *args):
        """item_at(Fl_Hold_Browser self, int line) -> void *"""
        return _fltk.Fl_Hold_Browser_item_at(self, *args)


    def full_width(self, *args):
        """full_width(Fl_Hold_Browser self) -> int"""
        return _fltk.Fl_Hold_Browser_full_width(self, *args)


    def full_height(self, *args):
        """full_height(Fl_Hold_Browser self) -> int"""
        return _fltk.Fl_Hold_Browser_full_height(self, *args)


    def incr_height(self, *args):
        """incr_height(Fl_Hold_Browser self) -> int"""
        return _fltk.Fl_Hold_Browser_incr_height(self, *args)


    def item_select(self, *args):
        """item_select(Fl_Hold_Browser self, void * item, int val)"""
        return _fltk.Fl_Hold_Browser_item_select(self, *args)


    def item_selected(self, *args):
        """item_selected(Fl_Hold_Browser self, void * item) -> int"""
        return _fltk.Fl_Hold_Browser_item_selected(self, *args)

Fl_Hold_Browser_swigregister = _fltk.Fl_Hold_Browser_swigregister
Fl_Hold_Browser_swigregister(Fl_Hold_Browser)

class Fl_Hor_Fill_Slider(Fl_Slider):
    """

    The Fl_Hor_Fill_Slider widget contains a sliding knob inside a box. It is 
    often used as a scrollbar. Moving the box all the way to the top/left sets 
    it to the minimum(), and to the bottom/right to the maximum(). The minimum() 
    may be greater than the maximum() to reverse the slider direction.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Hor_Fill_Slider self, int X, int Y, int W, int H, char const * L=None) -> Fl_Hor_Fill_Slider"""
        if self.__class__ == Fl_Hor_Fill_Slider:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Hor_Fill_Slider(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Hor_Fill_Slider
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Hor_Fill_Slider(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Hor_Fill_Slider self)"""
        return _fltk.Fl_Hor_Fill_Slider_draw(self, *args)

Fl_Hor_Fill_Slider_swigregister = _fltk.Fl_Hor_Fill_Slider_swigregister
Fl_Hor_Fill_Slider_swigregister(Fl_Hor_Fill_Slider)

class Fl_Hor_Nice_Slider(Fl_Slider):
    """

    The Fl_Hor_Nice_Slider widget contains a sliding knob inside a box. It is 
    often used as a scrollbar. Moving the box all the way to the top/left sets 
    it to the minimum(), and to the bottom/right to the maximum(). The minimum() 
    may be greater than the maximum() to reverse the slider direction.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Hor_Nice_Slider self, int X, int Y, int W, int H, char const * L=None) -> Fl_Hor_Nice_Slider"""
        if self.__class__ == Fl_Hor_Nice_Slider:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Hor_Nice_Slider(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Hor_Nice_Slider
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Hor_Nice_Slider(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Hor_Nice_Slider self)"""
        return _fltk.Fl_Hor_Nice_Slider_draw(self, *args)

Fl_Hor_Nice_Slider_swigregister = _fltk.Fl_Hor_Nice_Slider_swigregister
Fl_Hor_Nice_Slider_swigregister(Fl_Hor_Nice_Slider)

class Fl_Hor_Slider(Fl_Slider):
    """

    The Fl_Hor_Slider widget contains a sliding knob inside a box. It is 
    often used as a scrollbar. Moving the box all the way to the top/left sets 
    it to the minimum(), and to the bottom/right to the maximum(). The minimum() 
    may be greater than the maximum() to reverse the slider direction.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Hor_Slider self, int X, int Y, int W, int H, char const * l=None) -> Fl_Hor_Slider"""
        if self.__class__ == Fl_Hor_Slider:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Hor_Slider(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Hor_Slider
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Hor_Slider(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Hor_Slider self)"""
        return _fltk.Fl_Hor_Slider_draw(self, *args)

Fl_Hor_Slider_swigregister = _fltk.Fl_Hor_Slider_swigregister
Fl_Hor_Slider_swigregister(Fl_Hor_Slider)

class Fl_Value_Slider(Fl_Slider):
    """

    The Fl_Value_Slider widget is a Fl_Slider widget with a box displaying 
    the current value.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Value_Slider self)"""
        return _fltk.Fl_Value_Slider_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Value_Slider self, int arg0) -> int"""
        return _fltk.Fl_Value_Slider_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Value_Slider self, int x, int y, int w, int h, char const * l=None) -> Fl_Value_Slider"""
        if self.__class__ == Fl_Value_Slider:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Value_Slider(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def textfont(self, *args):
        """
        textfont(Fl_Value_Slider self) -> Fl_Font
        textfont(Fl_Value_Slider self, Fl_Font s)
        """
        return _fltk.Fl_Value_Slider_textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Value_Slider self) -> Fl_Fontsize
        textsize(Fl_Value_Slider self, Fl_Fontsize s)
        """
        return _fltk.Fl_Value_Slider_textsize(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Value_Slider self) -> Fl_Color
        textcolor(Fl_Value_Slider self, Fl_Color s)
        """
        return _fltk.Fl_Value_Slider_textcolor(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Value_Slider
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Value_Slider(self)
        return weakref_proxy(self)
Fl_Value_Slider_swigregister = _fltk.Fl_Value_Slider_swigregister
Fl_Value_Slider_swigregister(Fl_Value_Slider)

class Fl_Hor_Value_Slider(Fl_Value_Slider):
    """

    The Fl_Hor_Value_Slider widget contains a sliding knob inside a box. It is 
    often used as a scrollbar. Moving the box all the way to the top/left sets 
    it to the minimum(), and to the bottom/right to the maximum(). The minimum() 
    may be greater than the maximum() to reverse the slider direction.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Hor_Value_Slider self, int X, int Y, int W, int H, char const * l=None) -> Fl_Hor_Value_Slider"""
        if self.__class__ == Fl_Hor_Value_Slider:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Hor_Value_Slider(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Hor_Value_Slider
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Hor_Value_Slider(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Hor_Value_Slider self)"""
        return _fltk.Fl_Hor_Value_Slider_draw(self, *args)

Fl_Hor_Value_Slider_swigregister = _fltk.Fl_Hor_Value_Slider_swigregister
Fl_Hor_Value_Slider_swigregister(Fl_Hor_Value_Slider)

class Fl_Int_Input(Fl_Input):
    """

    The Fl_Int_Input class is a subclass of Fl_Input  that only allows the user 
    to type decimal digits (or hex numbers of the form 0xaef).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Int_Input self, int X, int Y, int W, int H, char const * l=None) -> Fl_Int_Input"""
        if self.__class__ == Fl_Int_Input:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Int_Input(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Int_Input
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Int_Input(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Int_Input self)"""
        return _fltk.Fl_Int_Input_draw(self, *args)

Fl_Int_Input_swigregister = _fltk.Fl_Int_Input_swigregister
Fl_Int_Input_swigregister(Fl_Int_Input)

class Fl_Input_Choice(Fl_Group):
    """

    A combination of the input widget and a menu button. The user can either 
    type into the input area, or use the menu button chooser on the right, 
    which loads the input area with predefined text. Normally it is drawn with 
    an inset box and a white background.

    The application can directly access both the input and menu widgets directly, 
    using the menubutton() and input() accessor methods. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Input_Choice self, int X, int Y, int W, int H, char const * L=None) -> Fl_Input_Choice"""
        if self.__class__ == Fl_Input_Choice:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Input_Choice(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def add(self, *args):
        """add(Fl_Input_Choice self, char const * s)"""
        val = _fltk.Fl_Input_Choice_add(self, *args)

        #self = args[0]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()
        else:                       
        #give ownership back to Python
            self.this.own() 


        return val


    def changed(self, *args):
        """changed(Fl_Input_Choice self) -> int"""
        return _fltk.Fl_Input_Choice_changed(self, *args)


    def clear_changed(self, *args):
        """clear_changed(Fl_Input_Choice self)"""
        return _fltk.Fl_Input_Choice_clear_changed(self, *args)


    def set_changed(self, *args):
        """set_changed(Fl_Input_Choice self)"""
        return _fltk.Fl_Input_Choice_set_changed(self, *args)


    def clear(self, *args):
        """clear(Fl_Input_Choice self)"""
        return _fltk.Fl_Input_Choice_clear(self, *args)


    def down_box(self, *args):
        """
        down_box(Fl_Input_Choice self) -> Fl_Boxtype
        down_box(Fl_Input_Choice self, Fl_Boxtype b)
        """
        return _fltk.Fl_Input_Choice_down_box(self, *args)


    def menu(self, *args):
        """
        menu(Fl_Input_Choice self) -> Fl_Menu_Item
        menu(Fl_Input_Choice self, Fl_Menu_Item m)
        """
        return _fltk.Fl_Input_Choice_menu(self, *args)


    def resize(self, *args):
        """resize(Fl_Input_Choice self, int X, int Y, int W, int H)"""
        return _fltk.Fl_Input_Choice_resize(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Input_Choice self) -> Fl_Color
        textcolor(Fl_Input_Choice self, Fl_Color c)
        """
        return _fltk.Fl_Input_Choice_textcolor(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Input_Choice self) -> Fl_Font
        textfont(Fl_Input_Choice self, Fl_Font f)
        """
        return _fltk.Fl_Input_Choice_textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Input_Choice self) -> Fl_Fontsize
        textsize(Fl_Input_Choice self, Fl_Fontsize s)
        """
        return _fltk.Fl_Input_Choice_textsize(self, *args)


    def value(self, *args):
        """
        value(Fl_Input_Choice self) -> char const
        value(Fl_Input_Choice self, char const * val)
        value(Fl_Input_Choice self, int val)
        """
        return _fltk.Fl_Input_Choice_value(self, *args)


    def menubutton(self, *args):
        """menubutton(Fl_Input_Choice self) -> Fl_Menu_Button"""
        return _fltk.Fl_Input_Choice_menubutton(self, *args)


    def input(self, *args):
        """input(Fl_Input_Choice self) -> Fl_Input"""
        return _fltk.Fl_Input_Choice_input(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Input_Choice
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Input_Choice(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Input_Choice self)"""
        return _fltk.Fl_Input_Choice_draw(self, *args)

Fl_Input_Choice_swigregister = _fltk.Fl_Input_Choice_swigregister
Fl_Input_Choice_swigregister(Fl_Input_Choice)

class Fl_JPEG_Image(Fl_RGB_Image):
    """

    The Fl_JPEG_Image class supports loading, caching, and drawing of Joint 
    Photographic Experts Group (JPEG) File Interchange Format (JFIF) images. 
    The class supports grayscale and color (RGB) JPEG image files.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Fl_JPEG_Image self, char const * filename) -> Fl_JPEG_Image
        __init__(Fl_JPEG_Image self, char const * name, unsigned char const * data) -> Fl_JPEG_Image
        """
        if self.__class__ == Fl_JPEG_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_JPEG_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_JPEG_Image
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_JPEG_Image(self)
        return weakref_proxy(self)
Fl_JPEG_Image_swigregister = _fltk.Fl_JPEG_Image_swigregister
Fl_JPEG_Image_swigregister(Fl_JPEG_Image)

class Fl_Line_Dial(Fl_Dial):
    """

    The Fl_Line_Dial widget provides a circular dial to control a single 
    floating point value.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Line_Dial self, int X, int Y, int W, int H, char const * L=None) -> Fl_Line_Dial"""
        if self.__class__ == Fl_Line_Dial:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Line_Dial(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Line_Dial
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Line_Dial(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Line_Dial self)"""
        return _fltk.Fl_Line_Dial_draw(self, *args)

Fl_Line_Dial_swigregister = _fltk.Fl_Line_Dial_swigregister
Fl_Line_Dial_swigregister(Fl_Line_Dial)

class Fl_Menu_Bar(Fl_Menu_):
    """

    This widget provides a standard menubar interface. Usually you will put 
    this widget along the top edge of your window. The height of the widget 
    should be 30 for the menu titles to draw correctly with the default font.

    The items on the bar and the menus they bring up are defined by a single 
    Fl_Menu_Item array. Because a Fl_Menu_Item array defines a hierarchy, the 
    top level menu defines the items in the menubar, while the submenus define 
    the pull-down menus. Sub-sub menus and lower pop up to the right of the 
    submenus.

    If there is an item in the top menu that is not a title of a submenu, then 
    it acts like a 'button' in the menubar. Clicking on it will pick it.

    When the user picks an item off the menu, the item's callback is done with 
    the menubar as the Fl_Widget* argument. If the item does not have a callback 
    the menubar's callback is done instead.

    Submenus will also pop up in response to shortcuts indicated by putting 
    a '&' character in the name field of the menu item. If you put a '&' 
    character in a top-level 'button' then the shortcut picks it. The '&' 
    character in submenus is ignored until the menu is popped up.

    Typing the shortcut() of any of the menu items will cause callbacks 
    exactly the same as when you pick the item with the mouse. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Menu_Bar self)"""
        return _fltk.Fl_Menu_Bar_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Menu_Bar self, int arg0) -> int"""
        return _fltk.Fl_Menu_Bar_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Menu_Bar self, int X, int Y, int W, int H, char const * l=None) -> Fl_Menu_Bar"""
        if self.__class__ == Fl_Menu_Bar:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Menu_Bar(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Menu_Bar
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Menu_Bar(self)
        return weakref_proxy(self)
Fl_Menu_Bar_swigregister = _fltk.Fl_Menu_Bar_swigregister
Fl_Menu_Bar_swigregister(Fl_Menu_Bar)

class Fl_Menu_Button(Fl_Menu_):
    """

    This is a button that when pushed pops up a menu (or hierarchy of menus) 
    defined by an array of Fl_Menu_Item objects.

    Fl_Menu_Button widget.

    Normally any mouse button will pop up a menu and it is lined up below the 
    button as shown in the picture. However an Fl_Menu_Button may also control 
    a pop-up menu. This is done by setting the type() , see below.

    The menu will also pop up in response to shortcuts indicated by putting 
    a '&' character in the label().

    Typing the shortcut() of any of the menu items will cause callbacks exactly 
    the same as when you pick the item with the mouse. The '&' character in menu 
    item names are only looked at when the menu is popped up, however.

    When the user picks an item off the menu, the item's callback is done with 
    the menu_button as the Fl_Widget* argument. If the item does not have a 
    callback the menu_button's callback is done instead. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Menu_Button self)"""
        return _fltk.Fl_Menu_Button_draw(self, *args)

    POPUP1 = _fltk.Fl_Menu_Button_POPUP1
    POPUP2 = _fltk.Fl_Menu_Button_POPUP2
    POPUP12 = _fltk.Fl_Menu_Button_POPUP12
    POPUP3 = _fltk.Fl_Menu_Button_POPUP3
    POPUP13 = _fltk.Fl_Menu_Button_POPUP13
    POPUP23 = _fltk.Fl_Menu_Button_POPUP23
    POPUP123 = _fltk.Fl_Menu_Button_POPUP123

    def handle(self, *args):
        """handle(Fl_Menu_Button self, int arg0) -> int"""
        return _fltk.Fl_Menu_Button_handle(self, *args)


    def popup(self, *args):
        """popup(Fl_Menu_Button self) -> Fl_Menu_Item"""
        return _fltk.Fl_Menu_Button_popup(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Menu_Button self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Menu_Button"""
        if self.__class__ == Fl_Menu_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Menu_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Menu_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Menu_Button(self)
        return weakref_proxy(self)
Fl_Menu_Button_swigregister = _fltk.Fl_Menu_Button_swigregister
Fl_Menu_Button_swigregister(Fl_Menu_Button)


_fltk.FL_MENU_INACTIVE_swigconstant(_fltk)
FL_MENU_INACTIVE = _fltk.FL_MENU_INACTIVE

_fltk.FL_MENU_TOGGLE_swigconstant(_fltk)
FL_MENU_TOGGLE = _fltk.FL_MENU_TOGGLE

_fltk.FL_MENU_VALUE_swigconstant(_fltk)
FL_MENU_VALUE = _fltk.FL_MENU_VALUE

_fltk.FL_MENU_RADIO_swigconstant(_fltk)
FL_MENU_RADIO = _fltk.FL_MENU_RADIO

_fltk.FL_MENU_INVISIBLE_swigconstant(_fltk)
FL_MENU_INVISIBLE = _fltk.FL_MENU_INVISIBLE

_fltk.FL_SUBMENU_POINTER_swigconstant(_fltk)
FL_SUBMENU_POINTER = _fltk.FL_SUBMENU_POINTER

_fltk.FL_SUBMENU_swigconstant(_fltk)
FL_SUBMENU = _fltk.FL_SUBMENU

_fltk.FL_MENU_DIVIDER_swigconstant(_fltk)
FL_MENU_DIVIDER = _fltk.FL_MENU_DIVIDER

_fltk.FL_MENU_HORIZONTAL_swigconstant(_fltk)
FL_MENU_HORIZONTAL = _fltk.FL_MENU_HORIZONTAL
class Fl_Menu_Item(object):
    """

    The Fl_Menu_Item structure defines a single menu item that is used by the 
    Fl_Menu_ class. This structure is defined as

          Fl_Menu_Item :
            text 		-> character array # label()
            shortcut_ 	-> unsigned long
            callback_	-> Fl_Callback
            user_data_	
            flags		-> int
            labeltype_	-> unsigned character
            labelfont_	-> unsigned character
            labelsize_	-> unsigned character
            labelcolor_	-> unsigned character


          enum: # values for flags:
            FL_MENU_INACTIVE	= 1,
            FL_MENU_TOGGLE		= 2,
            FL_MENU_VALUE		= 4,
            FL_MENU_RADIO		= 8,
            FL_MENU_INVISIBLE	= 0x10,
            FL_SUBMENU_POINTER	= 0x20,
            FL_SUBMENU		= 0x40,
            FL_MENU_DIVIDER		= 0x80,
            FL_MENU_HORIZONTAL	= 0x100


    Typically menu items are statically defined; for example:

          MenuTable = (
            ('&alpha',   FL_ALT+ord('a'), the_cb, 1),
            ('&beta',    FL_ALT+ord('b'), the_cb, 2),
            ('gamma',    FL_ALT+ord('c'), the_cb, 3, FL_MENU_DIVIDER),
            ('&strange',  0,   strange_cb),
            ('&charm',    0,   charm_cb),
            ('&truth',    0,   truth_cb),
            ('b&eauty',   0,   beauty_cb),
            ('sub&menu',	0,   0, 0, FL_SUBMENU),
              ('one'),
              ('two'),
              ('three'),
            (None,),
            ('inactive', FL_ALT+'i', 0, 0, FL_MENU_INACTIVE|FL_MENU_DIVIDER),
            ('invisible',FL_ALT+'i', 0, 0, FL_MENU_INVISIBLE),
            ('check',    FL_ALT+'i', 0, 0, FL_MENU_TOGGLE|FL_MENU_VALUE),
            ('box',      FL_ALT+'i', 0, 0, FL_MENU_TOGGLE),
          (None,);

    A submenu title is identified by the bit FL_SUBMENU in the flags field, 
    and ends with a label() that is NULL. You can nest menus to any depth. A 
    pointer to the first item in the submenu can be treated as an Fl_Menu array 
    itself. It is also possible to make seperate submenu arrays with 
    FL_SUBMENU_POINTER flags.

    You should use the method functions to access structure members and not 
    access them directly to avoid compatibility problems with future releases 
    of FLTK. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def next(self, *args):
        """
        next(Fl_Menu_Item self, int arg2=1) -> Fl_Menu_Item
        next(Fl_Menu_Item self, int i=1) -> Fl_Menu_Item
        """
        return _fltk.Fl_Menu_Item_next(self, *args)


    def first(self, *args):
        """
        first(Fl_Menu_Item self) -> Fl_Menu_Item
        first(Fl_Menu_Item self) -> Fl_Menu_Item
        """
        return _fltk.Fl_Menu_Item_first(self, *args)


    def label(self, *args):
        """
        label(Fl_Menu_Item self) -> char const
        label(Fl_Menu_Item self, char const * a)
        label(Fl_Menu_Item self, Fl_Labeltype a, char const * b)
        """
        return _fltk.Fl_Menu_Item_label(self, *args)


    def labeltype(self, *args):
        """
        labeltype(Fl_Menu_Item self) -> Fl_Labeltype
        labeltype(Fl_Menu_Item self, Fl_Labeltype a)
        """
        return _fltk.Fl_Menu_Item_labeltype(self, *args)


    def labelcolor(self, *args):
        """
        labelcolor(Fl_Menu_Item self) -> Fl_Color
        labelcolor(Fl_Menu_Item self, Fl_Color a)
        """
        return _fltk.Fl_Menu_Item_labelcolor(self, *args)


    def labelfont(self, *args):
        """
        labelfont(Fl_Menu_Item self) -> Fl_Font
        labelfont(Fl_Menu_Item self, Fl_Font a)
        """
        return _fltk.Fl_Menu_Item_labelfont(self, *args)


    def labelsize(self, *args):
        """
        labelsize(Fl_Menu_Item self) -> Fl_Fontsize
        labelsize(Fl_Menu_Item self, Fl_Fontsize a)
        """
        return _fltk.Fl_Menu_Item_labelsize(self, *args)


    def argument(self, *args):
        """
        argument(Fl_Menu_Item self) -> long
        argument(Fl_Menu_Item self, long v)
        """
        return _fltk.Fl_Menu_Item_argument(self, *args)


    def shortcut(self, *args):
        """
        shortcut(Fl_Menu_Item self) -> int
        shortcut(Fl_Menu_Item self, int s)
        """
        return _fltk.Fl_Menu_Item_shortcut(self, *args)


    def submenu(self, *args):
        """submenu(Fl_Menu_Item self) -> int"""
        return _fltk.Fl_Menu_Item_submenu(self, *args)


    def checkbox(self, *args):
        """checkbox(Fl_Menu_Item self) -> int"""
        return _fltk.Fl_Menu_Item_checkbox(self, *args)


    def radio(self, *args):
        """radio(Fl_Menu_Item self) -> int"""
        return _fltk.Fl_Menu_Item_radio(self, *args)


    def value(self, *args):
        """value(Fl_Menu_Item self) -> int"""
        return _fltk.Fl_Menu_Item_value(self, *args)


    def set(self, *args):
        """set(Fl_Menu_Item self)"""
        return _fltk.Fl_Menu_Item_set(self, *args)


    def clear(self, *args):
        """clear(Fl_Menu_Item self)"""
        return _fltk.Fl_Menu_Item_clear(self, *args)


    def setonly(self, *args):
        """setonly(Fl_Menu_Item self)"""
        return _fltk.Fl_Menu_Item_setonly(self, *args)


    def visible(self, *args):
        """visible(Fl_Menu_Item self) -> int"""
        return _fltk.Fl_Menu_Item_visible(self, *args)


    def show(self, *args):
        """show(Fl_Menu_Item self)"""
        return _fltk.Fl_Menu_Item_show(self, *args)


    def hide(self, *args):
        """hide(Fl_Menu_Item self)"""
        return _fltk.Fl_Menu_Item_hide(self, *args)


    def active(self, *args):
        """active(Fl_Menu_Item self) -> int"""
        return _fltk.Fl_Menu_Item_active(self, *args)


    def activate(self, *args):
        """activate(Fl_Menu_Item self)"""
        return _fltk.Fl_Menu_Item_activate(self, *args)


    def deactivate(self, *args):
        """deactivate(Fl_Menu_Item self)"""
        return _fltk.Fl_Menu_Item_deactivate(self, *args)


    def activevisible(self, *args):
        """activevisible(Fl_Menu_Item self) -> int"""
        return _fltk.Fl_Menu_Item_activevisible(self, *args)


    def image(self, *args):
        """image(Fl_Menu_Item self, Fl_Image a)"""
        return _fltk.Fl_Menu_Item_image(self, *args)


    def measure(self, *args):
        """measure(Fl_Menu_Item self, int * h, Fl_Menu_ arg3) -> int"""
        return _fltk.Fl_Menu_Item_measure(self, *args)


    def draw(self, *args):
        """draw(Fl_Menu_Item self, int x, int y, int w, int h, Fl_Menu_ arg6, int t=0)"""
        return _fltk.Fl_Menu_Item_draw(self, *args)


    def popup(self, *args):
        """popup(Fl_Menu_Item self, int X, int Y, char const * title=None, Fl_Menu_Item picked=None, Fl_Menu_ arg6=None) -> Fl_Menu_Item"""
        return _fltk.Fl_Menu_Item_popup(self, *args)


    def pulldown(self, *args):
        """pulldown(Fl_Menu_Item self, int X, int Y, int W, int H, Fl_Menu_Item picked=None, Fl_Menu_ arg7=None, Fl_Menu_Item title=None, int menubar=0) -> Fl_Menu_Item"""
        return _fltk.Fl_Menu_Item_pulldown(self, *args)


    def test_shortcut(self, *args):
        """test_shortcut(Fl_Menu_Item self) -> Fl_Menu_Item"""
        return _fltk.Fl_Menu_Item_test_shortcut(self, *args)


    def find_shortcut(self, *args):
        """find_shortcut(Fl_Menu_Item self, int * ip=None, bool const require_alt=False) -> Fl_Menu_Item"""
        return _fltk.Fl_Menu_Item_find_shortcut(self, *args)


    def do_callback(self, *args):
        """
        do_callback(Fl_Menu_Item self, Fl_Widget o)
        do_callback(Fl_Menu_Item self, Fl_Widget o, void * arg)
        do_callback(Fl_Menu_Item self, Fl_Widget o, long arg)
        """
        return _fltk.Fl_Menu_Item_do_callback(self, *args)


    def checked(self, *args):
        """checked(Fl_Menu_Item self) -> int"""
        return _fltk.Fl_Menu_Item_checked(self, *args)


    def check(self, *args):
        """check(Fl_Menu_Item self)"""
        return _fltk.Fl_Menu_Item_check(self, *args)


    def uncheck(self, *args):
        """uncheck(Fl_Menu_Item self)"""
        return _fltk.Fl_Menu_Item_uncheck(self, *args)


    def insert(self, *args):
        """insert(Fl_Menu_Item self, int arg2, char const * arg3, int arg4, Fl_Callback * arg5, void * arg6=None, int arg7=0) -> int"""
        return _fltk.Fl_Menu_Item_insert(self, *args)


    def add(self, *args):
        """
        add(Fl_Menu_Item self, char const * arg2, int shortcut, Fl_Callback * arg4, void * arg5=None, int arg6=0) -> int
        add(Fl_Menu_Item self, char const * a, char const * b, Fl_Callback * c, void * d=None, int e=0) -> int
        """
        return _fltk.Fl_Menu_Item_add(self, *args)


    def size(self, *args):
        """size(Fl_Menu_Item self) -> int"""
        return _fltk.Fl_Menu_Item_size(self, *args)


    def callback(self, *args):
        """
        callback(Fl_Menu_Item self, Fl_Callback * c, void * p)
        callback(Fl_Menu_Item self, Fl_Callback * c)
        callback(Fl_Menu_Item self, Fl_Callback0 * c)
        callback(Fl_Menu_Item self, Fl_Callback1 * c, long p=0)
        callback(Fl_Menu_Item self) -> PyObject *
        """
        return _fltk.Fl_Menu_Item_callback(self, *args)


    def user_data(self, *args):
        """
        user_data(Fl_Menu_Item self)
        user_data(Fl_Menu_Item self, void * v)
        user_data(Fl_Menu_Item self) -> PyObject *
        """
        return _fltk.Fl_Menu_Item_user_data(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Menu_Item self) -> Fl_Menu_Item"""
        this = _fltk.new_Fl_Menu_Item(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Menu_Item
    __del__ = lambda self: None
Fl_Menu_Item_swigregister = _fltk.Fl_Menu_Item_swigregister
Fl_Menu_Item_swigregister(Fl_Menu_Item)


_fltk.FL_PUP_NONE_swigconstant(_fltk)
FL_PUP_NONE = _fltk.FL_PUP_NONE

_fltk.FL_PUP_GREY_swigconstant(_fltk)
FL_PUP_GREY = _fltk.FL_PUP_GREY

_fltk.FL_PUP_GRAY_swigconstant(_fltk)
FL_PUP_GRAY = _fltk.FL_PUP_GRAY

_fltk.FL_MENU_BOX_swigconstant(_fltk)
FL_MENU_BOX = _fltk.FL_MENU_BOX

_fltk.FL_PUP_BOX_swigconstant(_fltk)
FL_PUP_BOX = _fltk.FL_PUP_BOX

_fltk.FL_MENU_CHECK_swigconstant(_fltk)
FL_MENU_CHECK = _fltk.FL_MENU_CHECK

_fltk.FL_PUP_CHECK_swigconstant(_fltk)
FL_PUP_CHECK = _fltk.FL_PUP_CHECK

_fltk.FL_PUP_RADIO_swigconstant(_fltk)
FL_PUP_RADIO = _fltk.FL_PUP_RADIO

_fltk.FL_PUP_INVISIBLE_swigconstant(_fltk)
FL_PUP_INVISIBLE = _fltk.FL_PUP_INVISIBLE

_fltk.FL_PUP_SUBMENU_swigconstant(_fltk)
FL_PUP_SUBMENU = _fltk.FL_PUP_SUBMENU
class Fl_Single_Window(Fl_Window):
    """

    This is the same as Fl_Window. However, it is possible that some 
    implementations will provide double-buffered windows by default. This 
    subclass can be used to force single-buffering. This may be useful for 
    modifying existing programs that use incremental update, or for some 
    types of image data, such as a movie flipbook.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def flush(self, *args):
        """flush(Fl_Single_Window self)"""
        return _fltk.Fl_Single_Window_flush(self, *args)


    def __init__(self, *args):
        """
        __init__(Fl_Single_Window self, int W, int H, char const * l=None) -> Fl_Single_Window
        __init__(Fl_Single_Window self, int X, int Y, int W, int H, char const * l=None) -> Fl_Single_Window
        """
        if self.__class__ == Fl_Single_Window:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Single_Window(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def show(self, *args):
        """show(Fl_Single_Window self, PyObject * count=None, PyObject * data=None)"""
        return _fltk.Fl_Single_Window_show(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Single_Window
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Single_Window(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Single_Window self)"""
        return _fltk.Fl_Single_Window_draw(self, *args)

Fl_Single_Window_swigregister = _fltk.Fl_Single_Window_swigregister
Fl_Single_Window_swigregister(Fl_Single_Window)

class Fl_Menu_Window(Fl_Single_Window):
    """

    The Fl_Menu_Window widget is a window type used for menus. By default the 
    window is drawn in the hardware overlay planes if they are available so that 
    the menu don't force the rest of the window to redraw.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def erase(self, *args):
        """erase(Fl_Menu_Window self)"""
        return _fltk.Fl_Menu_Window_erase(self, *args)


    def flush(self, *args):
        """flush(Fl_Menu_Window self)"""
        return _fltk.Fl_Menu_Window_flush(self, *args)


    def hide(self, *args):
        """hide(Fl_Menu_Window self)"""
        return _fltk.Fl_Menu_Window_hide(self, *args)


    def overlay(self, *args):
        """overlay(Fl_Menu_Window self) -> unsigned int"""
        return _fltk.Fl_Menu_Window_overlay(self, *args)


    def set_overlay(self, *args):
        """set_overlay(Fl_Menu_Window self)"""
        return _fltk.Fl_Menu_Window_set_overlay(self, *args)


    def clear_overlay(self, *args):
        """clear_overlay(Fl_Menu_Window self)"""
        return _fltk.Fl_Menu_Window_clear_overlay(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Menu_Window
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Fl_Menu_Window self, int W, int H, char const * l=None) -> Fl_Menu_Window
        __init__(Fl_Menu_Window self, int X, int Y, int W, int H, char const * l=None) -> Fl_Menu_Window
        """
        if self.__class__ == Fl_Menu_Window:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Menu_Window(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Menu_Window(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Menu_Window self)"""
        return _fltk.Fl_Menu_Window_draw(self, *args)

Fl_Menu_Window_swigregister = _fltk.Fl_Menu_Window_swigregister
Fl_Menu_Window_swigregister(Fl_Menu_Window)

class Fl_Multiline_Input(Fl_Input):
    """

    This input field displays '
    ' characters as new lines rather than ^J, and 
    accepts the Return, Tab, and up and down arrow keys. This is for editing 
    multiline text.

    This is far from the nirvana of text editors, and is probably only good for 
    small bits of text, 10 lines at most. I think FLTK can be used to write a 
    powerful text editor, but it is not going to be a built-in feature. Powerful 
    text editors in a toolkit are a big source of bloat. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Multiline_Input self, int X, int Y, int W, int H, char const * l=None) -> Fl_Multiline_Input"""
        if self.__class__ == Fl_Multiline_Input:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Multiline_Input(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Multiline_Input
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Multiline_Input(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Multiline_Input self)"""
        return _fltk.Fl_Multiline_Input_draw(self, *args)

Fl_Multiline_Input_swigregister = _fltk.Fl_Multiline_Input_swigregister
Fl_Multiline_Input_swigregister(Fl_Multiline_Input)

class Fl_Output(Fl_Input):
    """

    This widget displays a piece of text. When you set the value() , Fl_Output 
    does a strcpy() to it's own storage, which is useful for program-generated 
    values. The user may select portions of the text using the mouse and paste 
    the contents into other fields or programs.

    There is a single subclass, Fl_Multiline_Output, which allows you to 
    display multiple lines of text.

    The text may contain any characters except 
    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Output self, int X, int Y, int W, int H, char const * l=None) -> Fl_Output"""
        if self.__class__ == Fl_Output:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Output(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Output
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Output(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Output self)"""
        return _fltk.Fl_Output_draw(self, *args)

Fl_Output_swigregister = _fltk.Fl_Output_swigregister
Fl_Output_swigregister(Fl_Output)

class Fl_Multiline_Output(Fl_Output):
    """

    This widget is a subclass of Fl_Output that displays multiple lines of text. 
    It also displays tab characters as whitespace to the next column.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Multiline_Output self, int X, int Y, int W, int H, char const * l=None) -> Fl_Multiline_Output"""
        if self.__class__ == Fl_Multiline_Output:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Multiline_Output(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Multiline_Output
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Multiline_Output(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Multiline_Output self)"""
        return _fltk.Fl_Multiline_Output_draw(self, *args)

Fl_Multiline_Output_swigregister = _fltk.Fl_Multiline_Output_swigregister
Fl_Multiline_Output_swigregister(Fl_Multiline_Output)

class Fl_Multi_Browser(Fl_Browser):
    """

    The Fl_Multi_Browser class is a subclass of Fl_Browser  which lets the user 
    select any set of the lines. The user interface is Macintosh style: clicking 
    an item turns off all the others and selects that one, dragging selects all 
    the items the mouse moves over, and shift + click toggles the items. This 
    is different then how forms did it. Normally the callback is done when the 
    user releases the mouse, but you can change this with when().

    See Fl_Browser for methods to add and remove lines from the browser. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Multi_Browser self, int X, int Y, int W, int H, char const * L=None) -> Fl_Multi_Browser"""
        if self.__class__ == Fl_Multi_Browser:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Multi_Browser(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Multi_Browser
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Multi_Browser(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Multi_Browser self)"""
        return _fltk.Fl_Multi_Browser_draw(self, *args)


    def item_first(self, *args):
        """item_first(Fl_Multi_Browser self) -> void *"""
        return _fltk.Fl_Multi_Browser_item_first(self, *args)


    def item_next(self, *args):
        """item_next(Fl_Multi_Browser self, void * item) -> void *"""
        return _fltk.Fl_Multi_Browser_item_next(self, *args)


    def item_prev(self, *args):
        """item_prev(Fl_Multi_Browser self, void * item) -> void *"""
        return _fltk.Fl_Multi_Browser_item_prev(self, *args)


    def item_last(self, *args):
        """item_last(Fl_Multi_Browser self) -> void *"""
        return _fltk.Fl_Multi_Browser_item_last(self, *args)


    def item_height(self, *args):
        """item_height(Fl_Multi_Browser self, void * item) -> int"""
        return _fltk.Fl_Multi_Browser_item_height(self, *args)


    def item_width(self, *args):
        """item_width(Fl_Multi_Browser self, void * item) -> int"""
        return _fltk.Fl_Multi_Browser_item_width(self, *args)


    def item_quick_height(self, *args):
        """item_quick_height(Fl_Multi_Browser self, void * item) -> int"""
        return _fltk.Fl_Multi_Browser_item_quick_height(self, *args)


    def item_draw(self, *args):
        """item_draw(Fl_Multi_Browser self, void * item, int X, int Y, int W, int H)"""
        return _fltk.Fl_Multi_Browser_item_draw(self, *args)


    def item_text(self, *args):
        """item_text(Fl_Multi_Browser self, void * item) -> char const *"""
        return _fltk.Fl_Multi_Browser_item_text(self, *args)


    def item_swap(self, *args):
        """item_swap(Fl_Multi_Browser self, void * a, void * b)"""
        return _fltk.Fl_Multi_Browser_item_swap(self, *args)


    def item_at(self, *args):
        """item_at(Fl_Multi_Browser self, int line) -> void *"""
        return _fltk.Fl_Multi_Browser_item_at(self, *args)


    def full_width(self, *args):
        """full_width(Fl_Multi_Browser self) -> int"""
        return _fltk.Fl_Multi_Browser_full_width(self, *args)


    def full_height(self, *args):
        """full_height(Fl_Multi_Browser self) -> int"""
        return _fltk.Fl_Multi_Browser_full_height(self, *args)


    def incr_height(self, *args):
        """incr_height(Fl_Multi_Browser self) -> int"""
        return _fltk.Fl_Multi_Browser_incr_height(self, *args)


    def item_select(self, *args):
        """item_select(Fl_Multi_Browser self, void * item, int val)"""
        return _fltk.Fl_Multi_Browser_item_select(self, *args)


    def item_selected(self, *args):
        """item_selected(Fl_Multi_Browser self, void * item) -> int"""
        return _fltk.Fl_Multi_Browser_item_selected(self, *args)

Fl_Multi_Browser_swigregister = _fltk.Fl_Multi_Browser_swigregister
Fl_Multi_Browser_swigregister(Fl_Multi_Browser)

class Fl_Multi_Label(object):
    """Proxy of C++ Fl_Multi_Label class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def label(self, *args):
        """
        label(Fl_Multi_Label self, Fl_Widget arg2)
        label(Fl_Multi_Label self, Fl_Menu_Item arg2)
        """
        return _fltk.Fl_Multi_Label_label(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Multi_Label self) -> Fl_Multi_Label"""
        this = _fltk.new_Fl_Multi_Label(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Multi_Label
    __del__ = lambda self: None
Fl_Multi_Label_swigregister = _fltk.Fl_Multi_Label_swigregister
Fl_Multi_Label_swigregister(Fl_Multi_Label)

class Fl_Nice_Slider(Fl_Slider):
    """

    The Fl_Nice_Slider widget contains a sliding knob inside a box. It is 
    often used as a scrollbar. Moving the box all the way to the top/left sets 
    it to the minimum(), and to the bottom/right to the maximum(). The minimum() 
    may be greater than the maximum() to reverse the slider direction.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Nice_Slider self, int X, int Y, int W, int H, char const * L=None) -> Fl_Nice_Slider"""
        if self.__class__ == Fl_Nice_Slider:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Nice_Slider(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Nice_Slider
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Nice_Slider(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Nice_Slider self)"""
        return _fltk.Fl_Nice_Slider_draw(self, *args)

Fl_Nice_Slider_swigregister = _fltk.Fl_Nice_Slider_swigregister
Fl_Nice_Slider_swigregister(Fl_Nice_Slider)

class Fl_Overlay_Window(Fl_Double_Window):
    """

    This window provides double buffering and also the ability to draw the 
    'overlay' which is another picture placed on top of the main image. The 
    overlay is designed to be a rapidly-changing but simple graphic such as 
    a mouse selection box. Fl_Overlay_Window uses the overlay planes provided 
    by your graphics hardware if they are available.

    If no hardware support is found the overlay is simulated by drawing directly 
    into the on-screen copy of the double-buffered window, and 'erased' by 
    copying the backbuffer over it again. This means the overlay will blink if 
    you change the image in the window. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw_overlay(self, *args):
        """draw_overlay(Fl_Overlay_Window self)"""
        return _fltk.Fl_Overlay_Window_draw_overlay(self, *args)


    def flush(self, *args):
        """flush(Fl_Overlay_Window self)"""
        return _fltk.Fl_Overlay_Window_flush(self, *args)


    def hide(self, *args):
        """hide(Fl_Overlay_Window self)"""
        return _fltk.Fl_Overlay_Window_hide(self, *args)


    def resize(self, *args):
        """resize(Fl_Overlay_Window self, int arg0, int arg1, int arg2, int arg3)"""
        return _fltk.Fl_Overlay_Window_resize(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Overlay_Window
    __del__ = lambda self: None

    def can_do_overlay(self, *args):
        """can_do_overlay(Fl_Overlay_Window self) -> int"""
        return _fltk.Fl_Overlay_Window_can_do_overlay(self, *args)


    def redraw_overlay(self, *args):
        """redraw_overlay(Fl_Overlay_Window self)"""
        return _fltk.Fl_Overlay_Window_redraw_overlay(self, *args)


    def __init__(self, *args):
        """
        __init__(Fl_Overlay_Window self, int W, int H, char const * l=None) -> Fl_Overlay_Window
        __init__(Fl_Overlay_Window self, int X, int Y, int W, int H, char const * l=None) -> Fl_Overlay_Window
        """
        if self.__class__ == Fl_Overlay_Window:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Overlay_Window(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def show(self, *args):
        """show(Fl_Overlay_Window self, PyObject * count=None, PyObject * data=None)"""
        return _fltk.Fl_Overlay_Window_show(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Overlay_Window(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Overlay_Window self)"""
        return _fltk.Fl_Overlay_Window_draw(self, *args)

Fl_Overlay_Window_swigregister = _fltk.Fl_Overlay_Window_swigregister
Fl_Overlay_Window_swigregister(Fl_Overlay_Window)

class Fl_Pack(Fl_Group):
    """

    This widget was designed to add the functionality of compressing and 
    aligning widgets.

    If type() is FL_HORIZONTAL all the children are resized to the height of 
    the Fl_Pack, and are moved next to each other horizontally. If type() is 
    not FL_HORIZONTAL then the children are resized to the width and are stacked 
    below each other. Then the Fl_Pack resizes itself to surround the child 
    widgets.

    This widget is needed for the Fl_Tabs. In addition you may want to put the 
    Fl_Pack inside an Fl_Scroll. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    VERTICAL = _fltk.Fl_Pack_VERTICAL
    HORIZONTAL = _fltk.Fl_Pack_HORIZONTAL

    def draw(self, *args):
        """draw(Fl_Pack self)"""
        return _fltk.Fl_Pack_draw(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Pack self, int x, int y, int w, int h, char const * l=None) -> Fl_Pack"""
        if self.__class__ == Fl_Pack:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Pack(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def spacing(self, *args):
        """
        spacing(Fl_Pack self) -> int
        spacing(Fl_Pack self, int i)
        """
        return _fltk.Fl_Pack_spacing(self, *args)


    def horizontal(self, *args):
        """horizontal(Fl_Pack self) -> uchar"""
        return _fltk.Fl_Pack_horizontal(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Pack
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Pack(self)
        return weakref_proxy(self)
Fl_Pack_swigregister = _fltk.Fl_Pack_swigregister
Fl_Pack_swigregister(Fl_Pack)

class Fl_PNG_Image(Fl_RGB_Image):
    """

    The Fl_PNG_Image class supports loading, caching, and drawing of Portable 
    Network Graphics (PNG) image files. The class loads colormapped and 
    full-color images and handles color- and alpha-based transparency.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Fl_PNG_Image self, char const * filename) -> Fl_PNG_Image
        __init__(Fl_PNG_Image self, char const * name_png, unsigned char const * buffer, int datasize) -> Fl_PNG_Image
        """
        if self.__class__ == Fl_PNG_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_PNG_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_PNG_Image
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_PNG_Image(self)
        return weakref_proxy(self)
Fl_PNG_Image_swigregister = _fltk.Fl_PNG_Image_swigregister
Fl_PNG_Image_swigregister(Fl_PNG_Image)

class Fl_PNM_Image(Fl_RGB_Image):
    """

    The Fl_PNM_Image class supports loading, caching, and drawing of Portable 
    Anymap (PNM, PBM, PGM, PPM) image files. The class loads bitmap, grayscale, 
    and full-color images in both ASCII and binary formats.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_PNM_Image self, char const * filename) -> Fl_PNM_Image"""
        if self.__class__ == Fl_PNM_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_PNM_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_PNM_Image
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_PNM_Image(self)
        return weakref_proxy(self)
Fl_PNM_Image_swigregister = _fltk.Fl_PNM_Image_swigregister
Fl_PNM_Image_swigregister(Fl_PNM_Image)

class Fl_Positioner(Fl_Widget):
    """

    This class is provided for Forms compatibility. It provides 2D input. It 
    would be useful if this could be put atop another widget so that the 
    crosshairs are on top, but this is not implemented. The color of the 
    crosshairs is selection_color().

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Positioner self)"""
        return _fltk.Fl_Positioner_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Positioner self, int arg0) -> int"""
        return _fltk.Fl_Positioner_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Positioner self, int x, int y, int w, int h, char const * l=None) -> Fl_Positioner"""
        if self.__class__ == Fl_Positioner:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Positioner(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def xvalue(self, *args):
        """
        xvalue(Fl_Positioner self) -> double
        xvalue(Fl_Positioner self, double arg2) -> int
        """
        return _fltk.Fl_Positioner_xvalue(self, *args)


    def yvalue(self, *args):
        """
        yvalue(Fl_Positioner self) -> double
        yvalue(Fl_Positioner self, double arg2) -> int
        """
        return _fltk.Fl_Positioner_yvalue(self, *args)


    def value(self, *args):
        """value(Fl_Positioner self, double arg2, double arg3) -> int"""
        return _fltk.Fl_Positioner_value(self, *args)


    def xbounds(self, *args):
        """xbounds(Fl_Positioner self, double arg2, double arg3)"""
        return _fltk.Fl_Positioner_xbounds(self, *args)


    def xminimum(self, *args):
        """
        xminimum(Fl_Positioner self) -> double
        xminimum(Fl_Positioner self, double a)
        """
        return _fltk.Fl_Positioner_xminimum(self, *args)


    def xmaximum(self, *args):
        """
        xmaximum(Fl_Positioner self) -> double
        xmaximum(Fl_Positioner self, double a)
        """
        return _fltk.Fl_Positioner_xmaximum(self, *args)


    def ybounds(self, *args):
        """ybounds(Fl_Positioner self, double arg2, double arg3)"""
        return _fltk.Fl_Positioner_ybounds(self, *args)


    def yminimum(self, *args):
        """
        yminimum(Fl_Positioner self) -> double
        yminimum(Fl_Positioner self, double a)
        """
        return _fltk.Fl_Positioner_yminimum(self, *args)


    def ymaximum(self, *args):
        """
        ymaximum(Fl_Positioner self) -> double
        ymaximum(Fl_Positioner self, double a)
        """
        return _fltk.Fl_Positioner_ymaximum(self, *args)


    def xstep(self, *args):
        """xstep(Fl_Positioner self, double a)"""
        return _fltk.Fl_Positioner_xstep(self, *args)


    def ystep(self, *args):
        """ystep(Fl_Positioner self, double a)"""
        return _fltk.Fl_Positioner_ystep(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Positioner
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Positioner(self)
        return weakref_proxy(self)
Fl_Positioner_swigregister = _fltk.Fl_Positioner_swigregister
Fl_Positioner_swigregister(Fl_Positioner)

class Fl_Preferences(object):
    """

    Fl_Preferences provides methods to store user setting between application 
    starts. It is similar to the Registry on WIN32 and Preferences on MacOS, 
    and provides a simple configuration mechanism for UNIX.

    Fl_Preferences uses a hierarchy to store data. It bundles similar data into 
    groups and manages entries into those groups as name/value pairs.

    Preferences are stored in text files that can be edited manually. The file 
    format is easy to read and relatively forgiving. Preferences files are the 
    same on all platforms. User comments in preference files are preserved. 
    Filenames are unique for each application by using a vendor/application 
    naming scheme. The user must provide default values for all entries to 
    ensure proper operation should preferences be corrupted or not yet exist.

    Entries can be of any length. However, the size of each preferences file 
    should be kept under 100k for performance reasons. One application can 
    have multiple preferences files. Extensive binary data however should be 
    stored in seperate files; see the getUserdataPath() method. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    SYSTEM = _fltk.Fl_Preferences_SYSTEM
    USER = _fltk.Fl_Preferences_USER

    def __init__(self, *args):
        """
        __init__(Fl_Preferences self, Fl_Preferences::Root root, char const * vendor, char const * application) -> Fl_Preferences
        __init__(Fl_Preferences self, char const * path, char const * vendor, char const * application) -> Fl_Preferences
        __init__(Fl_Preferences self, Fl_Preferences arg2, char const * group) -> Fl_Preferences
        """
        this = _fltk.new_Fl_Preferences(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Preferences
    __del__ = lambda self: None

    def groups(self, *args):
        """groups(Fl_Preferences self) -> int"""
        return _fltk.Fl_Preferences_groups(self, *args)


    def group(self, *args):
        """group(Fl_Preferences self, int arg2) -> char const *"""
        return _fltk.Fl_Preferences_group(self, *args)


    def groupExists(self, *args):
        """groupExists(Fl_Preferences self, char const * group) -> char"""
        return _fltk.Fl_Preferences_groupExists(self, *args)


    def deleteGroup(self, *args):
        """deleteGroup(Fl_Preferences self, char const * group) -> char"""
        return _fltk.Fl_Preferences_deleteGroup(self, *args)


    def entries(self, *args):
        """entries(Fl_Preferences self) -> int"""
        return _fltk.Fl_Preferences_entries(self, *args)


    def entry(self, *args):
        """entry(Fl_Preferences self, int arg2) -> char const *"""
        return _fltk.Fl_Preferences_entry(self, *args)


    def entryExists(self, *args):
        """entryExists(Fl_Preferences self, char const * entry) -> char"""
        return _fltk.Fl_Preferences_entryExists(self, *args)


    def deleteEntry(self, *args):
        """deleteEntry(Fl_Preferences self, char const * entry) -> char"""
        return _fltk.Fl_Preferences_deleteEntry(self, *args)


    def set(self, *args):
        """
        set(Fl_Preferences self, char const * entry, int value) -> char
        set(Fl_Preferences self, char const * entry, float value, int precision) -> char
        set(Fl_Preferences self, char const * entry, double value) -> char
        set(Fl_Preferences self, char const * entry, double value, int precision) -> char
        set(Fl_Preferences self, char const * entry, char const * cvalue) -> char
        set(Fl_Preferences self, char const * entry, void const * cvalue, int size) -> char
        """
        return _fltk.Fl_Preferences_set(self, *args)


    def get(self, *args):
        """
        get(Fl_Preferences self, char const * entry, int defaultValue) -> char
        get(Fl_Preferences self, char const * entry, float defaultValue) -> char
        get(Fl_Preferences self, char const * entry, double defaultValue) -> char
        get(Fl_Preferences self, char const * entry, char const * defaultValue, int maxSize) -> char
        get(Fl_Preferences self, char const * entry, void * value, void const * defaultValue, int defaultSize, int maxSize) -> char
        """
        return _fltk.Fl_Preferences_get(self, *args)


    def size(self, *args):
        """size(Fl_Preferences self, char const * entry) -> int"""
        return _fltk.Fl_Preferences_size(self, *args)


    def getUserdataPath(self, *args):
        """getUserdataPath(Fl_Preferences self, char * path) -> char"""
        return _fltk.Fl_Preferences_getUserdataPath(self, *args)


    def flush(self, *args):
        """flush(Fl_Preferences self)"""
        return _fltk.Fl_Preferences_flush(self, *args)

Fl_Preferences_swigregister = _fltk.Fl_Preferences_swigregister
Fl_Preferences_swigregister(Fl_Preferences)

class Fl_Progress(Fl_Widget):
    """

    The Fl_Progress widget displays a progress bar for the user.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Progress self)"""
        return _fltk.Fl_Progress_draw(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Progress self, int x, int y, int w, int h, char const * l=None) -> Fl_Progress"""
        if self.__class__ == Fl_Progress:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Progress(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def maximum(self, *args):
        """
        maximum(Fl_Progress self, float v)
        maximum(Fl_Progress self) -> float
        """
        return _fltk.Fl_Progress_maximum(self, *args)


    def minimum(self, *args):
        """
        minimum(Fl_Progress self, float v)
        minimum(Fl_Progress self) -> float
        """
        return _fltk.Fl_Progress_minimum(self, *args)


    def value(self, *args):
        """
        value(Fl_Progress self, float v)
        value(Fl_Progress self) -> float
        """
        return _fltk.Fl_Progress_value(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Progress
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Progress(self)
        return weakref_proxy(self)
Fl_Progress_swigregister = _fltk.Fl_Progress_swigregister
Fl_Progress_swigregister(Fl_Progress)

class Fl_Radio_Button(Fl_Button):
    """Proxy of C++ Fl_Radio_Button class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Radio_Button self, int X, int Y, int W, int H, char const * L=None) -> Fl_Radio_Button"""
        if self.__class__ == Fl_Radio_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Radio_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Radio_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Radio_Button(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Radio_Button self)"""
        return _fltk.Fl_Radio_Button_draw(self, *args)

Fl_Radio_Button_swigregister = _fltk.Fl_Radio_Button_swigregister
Fl_Radio_Button_swigregister(Fl_Radio_Button)

class Fl_Radio_Light_Button(Fl_Light_Button):
    """Proxy of C++ Fl_Radio_Light_Button class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Radio_Light_Button self, int X, int Y, int W, int H, char const * l=None) -> Fl_Radio_Light_Button"""
        if self.__class__ == Fl_Radio_Light_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Radio_Light_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Radio_Light_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Radio_Light_Button(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Radio_Light_Button self)"""
        return _fltk.Fl_Radio_Light_Button_draw(self, *args)

Fl_Radio_Light_Button_swigregister = _fltk.Fl_Radio_Light_Button_swigregister
Fl_Radio_Light_Button_swigregister(Fl_Radio_Light_Button)

class Fl_Round_Button(Fl_Light_Button):
    """

    Buttons generate callbacks when they are clicked by the user. You control 
    exactly when and how by changing the values for type() and when().

    The Fl_Round_Button subclass display the 'on' state by turning on a light, 
    rather than drawing pushed in. The shape of the 'light' is initially set 
    to FL_ROUND_DOWN_BOX. The color of the light when on is controlled with 
    selection_color(), which defaults to FL_RED.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Round_Button self, int x, int y, int w, int h, char const * l=None) -> Fl_Round_Button"""
        if self.__class__ == Fl_Round_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Round_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Round_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Round_Button(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Round_Button self)"""
        return _fltk.Fl_Round_Button_draw(self, *args)

Fl_Round_Button_swigregister = _fltk.Fl_Round_Button_swigregister
Fl_Round_Button_swigregister(Fl_Round_Button)

class Fl_Radio_Round_Button(Fl_Round_Button):
    """Proxy of C++ Fl_Radio_Round_Button class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Radio_Round_Button self, int X, int Y, int W, int H, char const * L=None) -> Fl_Radio_Round_Button"""
        if self.__class__ == Fl_Radio_Round_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Radio_Round_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Radio_Round_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Radio_Round_Button(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Radio_Round_Button self)"""
        return _fltk.Fl_Radio_Round_Button_draw(self, *args)

Fl_Radio_Round_Button_swigregister = _fltk.Fl_Radio_Round_Button_swigregister
Fl_Radio_Round_Button_swigregister(Fl_Radio_Round_Button)

class Fl_Repeat_Button(Fl_Button):
    """

    The Fl_Repeat_Button is a subclass of Fl_Button that generates a callback 
    when it is pressed and then repeatedly generates callbacks as long as it 
    is held down. The speed of the repeat is fixed and depends on the 
    implementation.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def handle(self, *args):
        """handle(Fl_Repeat_Button self, int arg0) -> int"""
        return _fltk.Fl_Repeat_Button_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Repeat_Button self, int X, int Y, int W, int H, char const * l=None) -> Fl_Repeat_Button"""
        if self.__class__ == Fl_Repeat_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Repeat_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def deactivate(self, *args):
        """deactivate(Fl_Repeat_Button self)"""
        return _fltk.Fl_Repeat_Button_deactivate(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Repeat_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Repeat_Button(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Repeat_Button self)"""
        return _fltk.Fl_Repeat_Button_draw(self, *args)

Fl_Repeat_Button_swigregister = _fltk.Fl_Repeat_Button_swigregister
Fl_Repeat_Button_swigregister(Fl_Repeat_Button)

class Fl_Return_Button(Fl_Button):
    """

    The Fl_Return_Button is a subclass of Fl_Button that generates a callback 
    when it is pressed or when the user presses the Enter key. A carriage-return 
    symbol is drawn next to the button label.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Return_Button self)"""
        return _fltk.Fl_Return_Button_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Return_Button self, int arg0) -> int"""
        return _fltk.Fl_Return_Button_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Return_Button self, int X, int Y, int W, int H, char const * l=None) -> Fl_Return_Button"""
        if self.__class__ == Fl_Return_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Return_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Return_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Return_Button(self)
        return weakref_proxy(self)
Fl_Return_Button_swigregister = _fltk.Fl_Return_Button_swigregister
Fl_Return_Button_swigregister(Fl_Return_Button)

class Fl_Roller(Fl_Valuator):
    """

    The Fl_Roller widget is a 'dolly' control commonly used to move 3D objects.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Roller self)"""
        return _fltk.Fl_Roller_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Roller self, int arg0) -> int"""
        return _fltk.Fl_Roller_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Roller self, int X, int Y, int W, int H, char const * L=None) -> Fl_Roller"""
        if self.__class__ == Fl_Roller:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Roller(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Roller
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Roller(self)
        return weakref_proxy(self)
Fl_Roller_swigregister = _fltk.Fl_Roller_swigregister
Fl_Roller_swigregister(Fl_Roller)

class Fl_Round_Clock(Fl_Clock):
    """

    This widget provides a round analog clock display and is provided for 
    Forms compatibility. It installs a 1-second timeout callback using 
    Fl::add_timeout().

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Round_Clock self, int X, int Y, int W, int H, char const * L=None) -> Fl_Round_Clock"""
        if self.__class__ == Fl_Round_Clock:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Round_Clock(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Round_Clock
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Round_Clock(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Round_Clock self)"""
        return _fltk.Fl_Round_Clock_draw(self, *args)

Fl_Round_Clock_swigregister = _fltk.Fl_Round_Clock_swigregister
Fl_Round_Clock_swigregister(Fl_Round_Clock)

class Fl_Scroll(Fl_Group):
    """

    This container widget lets you maneuver around a set of widgets much larger 
    than your window. If the child widgets are larger than the size of this 
    object then scrollbars will appear so that you can scroll over to them:

    If all of the child widgets are packed together into a solid rectangle then 
    you want to set box() to FL_NO_BOX or one of the _FRAME types. This will 
    result in the best output. However, if the child widgets are a sparse 
    arrangment you must set box() to a real _BOX type. This can result in some 
    blinking during redrawing, but that can be solved by using a Fl_Double_Window.

    This widget can also be used to pan around a single child widget 'canvas'. 
    This child widget should be of your own class, with a draw() method that 
    draws the contents. The scrolling is done by changing the x() and y() of 
    the widget, so this child must use the x() and y() to position it's drawing. 
    To speed up drawing it should test fl_push_clip() .

    Another very useful child is a single Fl_Pack, which is itself a group that 
    packs it's children together and changes size to surround them. Filling the 
    Fl_Pack with Fl_Tabs groups (and then putting normal widgets inside those) 
    gives you a very powerful scrolling list of individually-openable panels.

    Fluid lets you create these, but you can only lay out objects that fit 
    inside the Fl_Scroll without scrolling. Be sure to leave space for the 
    scrollbars, as Fluid won't show these either.

    You cannot use Fl_Window as a child of this since the clipping is not 
    conveyed to it when drawn, and it will draw over the scrollbars and 
    neighboring objects.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Scroll self)"""
        return _fltk.Fl_Scroll_draw(self, *args)


    def resize(self, *args):
        """resize(Fl_Scroll self, int arg0, int arg1, int arg2, int arg3)"""
        return _fltk.Fl_Scroll_resize(self, *args)


    def handle(self, *args):
        """handle(Fl_Scroll self, int arg0) -> int"""
        return _fltk.Fl_Scroll_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Scroll self, int X, int Y, int W, int H, char const * l=None) -> Fl_Scroll"""
        if self.__class__ == Fl_Scroll:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Scroll(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    HORIZONTAL = _fltk.Fl_Scroll_HORIZONTAL
    VERTICAL = _fltk.Fl_Scroll_VERTICAL
    BOTH = _fltk.Fl_Scroll_BOTH
    ALWAYS_ON = _fltk.Fl_Scroll_ALWAYS_ON
    HORIZONTAL_ALWAYS = _fltk.Fl_Scroll_HORIZONTAL_ALWAYS
    VERTICAL_ALWAYS = _fltk.Fl_Scroll_VERTICAL_ALWAYS
    BOTH_ALWAYS = _fltk.Fl_Scroll_BOTH_ALWAYS

    def xposition(self, *args):
        """xposition(Fl_Scroll self) -> int"""
        return _fltk.Fl_Scroll_xposition(self, *args)


    def yposition(self, *args):
        """yposition(Fl_Scroll self) -> int"""
        return _fltk.Fl_Scroll_yposition(self, *args)


    def scroll_to(self, *args):
        """scroll_to(Fl_Scroll self, int arg2, int arg3)"""
        return _fltk.Fl_Scroll_scroll_to(self, *args)


    def clear(self, *args):
        """clear(Fl_Scroll self)"""
        return _fltk.Fl_Scroll_clear(self, *args)


    def scrollbar_size(self, *args):
        """
        scrollbar_size(Fl_Scroll self) -> int
        scrollbar_size(Fl_Scroll self, int newSize)
        """
        return _fltk.Fl_Scroll_scrollbar_size(self, *args)


    def getScrollbar(self, *args):
        """getScrollbar(Fl_Scroll self) -> Fl_Scrollbar"""
        return _fltk.Fl_Scroll_getScrollbar(self, *args)


    def getHScrollbar(self, *args):
        """getHScrollbar(Fl_Scroll self) -> Fl_Scrollbar"""
        return _fltk.Fl_Scroll_getHScrollbar(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Scroll
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Scroll(self)
        return weakref_proxy(self)
Fl_Scroll_swigregister = _fltk.Fl_Scroll_swigregister
Fl_Scroll_swigregister(Fl_Scroll)

class Fl_Scrollbar(Fl_Slider):
    """

    The Fl_Scrollbar widget displays a slider with arrow buttons at the ends 
    of the scrollbar. Clicking on the arrows move up/left and down/right by 
    linesize(). Scrollbars also accept FL_SHORTCUT events: the arrows move by 
    linesize(), and vertical scrollbars take Page Up/Down (they move by the 
    page size minus linesize()) and Home/End (they jump to the top or bottom).

    Scrollbars have step(1) preset (they always return integers). If desired 
    you can set the step() to non-integer values. You will then have to use 
    casts to get at the floating-point versions of value() from Fl_Slider. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Scrollbar self)"""
        return _fltk.Fl_Scrollbar_draw(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Scrollbar self, int X, int Y, int W, int H, char const * L=None) -> Fl_Scrollbar"""
        if self.__class__ == Fl_Scrollbar:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Scrollbar(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Scrollbar
    __del__ = lambda self: None

    def handle(self, *args):
        """handle(Fl_Scrollbar self, int arg0) -> int"""
        return _fltk.Fl_Scrollbar_handle(self, *args)


    def value(self, *args):
        """
        value(Fl_Scrollbar self) -> int
        value(Fl_Scrollbar self, int p) -> int
        value(Fl_Scrollbar self, int pos, int windowSize, int first, int total) -> int
        """
        return _fltk.Fl_Scrollbar_value(self, *args)


    def linesize(self, *args):
        """
        linesize(Fl_Scrollbar self) -> int
        linesize(Fl_Scrollbar self, int i)
        """
        return _fltk.Fl_Scrollbar_linesize(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Scrollbar(self)
        return weakref_proxy(self)
Fl_Scrollbar_swigregister = _fltk.Fl_Scrollbar_swigregister
Fl_Scrollbar_swigregister(Fl_Scrollbar)

class Fl_Secret_Input(Fl_Input):
    """

    The Fl_Secret_Input class is a subclass of Fl_Input  that displays its input 
    as a string of asterisks. This subclass is usually used to receive passwords 
    and other 'secret' information.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Secret_Input self, int X, int Y, int W, int H, char const * l=None) -> Fl_Secret_Input"""
        if self.__class__ == Fl_Secret_Input:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Secret_Input(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def handle(self, *args):
        """handle(Fl_Secret_Input self, int arg0) -> int"""
        return _fltk.Fl_Secret_Input_handle(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Secret_Input
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Secret_Input(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Secret_Input self)"""
        return _fltk.Fl_Secret_Input_draw(self, *args)

Fl_Secret_Input_swigregister = _fltk.Fl_Secret_Input_swigregister
Fl_Secret_Input_swigregister(Fl_Secret_Input)

class Fl_Select_Browser(Fl_Browser):
    """

    The Fl_Select_Browser class is a subclass of Fl_Browser  which lets the 
    user select a single item, or no items by clicking on the empty space. As 
    long as the mouse button is held down the item pointed to by it is 
    highlighted. Normally the callback is done when the user presses the mouse, 
    but you can change this with when().

    See Fl_Browser for methods to add and remove lines from the browser. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Select_Browser self, int X, int Y, int W, int H, char const * L=None) -> Fl_Select_Browser"""
        if self.__class__ == Fl_Select_Browser:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Select_Browser(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Select_Browser
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Select_Browser(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Select_Browser self)"""
        return _fltk.Fl_Select_Browser_draw(self, *args)


    def item_first(self, *args):
        """item_first(Fl_Select_Browser self) -> void *"""
        return _fltk.Fl_Select_Browser_item_first(self, *args)


    def item_next(self, *args):
        """item_next(Fl_Select_Browser self, void * item) -> void *"""
        return _fltk.Fl_Select_Browser_item_next(self, *args)


    def item_prev(self, *args):
        """item_prev(Fl_Select_Browser self, void * item) -> void *"""
        return _fltk.Fl_Select_Browser_item_prev(self, *args)


    def item_last(self, *args):
        """item_last(Fl_Select_Browser self) -> void *"""
        return _fltk.Fl_Select_Browser_item_last(self, *args)


    def item_height(self, *args):
        """item_height(Fl_Select_Browser self, void * item) -> int"""
        return _fltk.Fl_Select_Browser_item_height(self, *args)


    def item_width(self, *args):
        """item_width(Fl_Select_Browser self, void * item) -> int"""
        return _fltk.Fl_Select_Browser_item_width(self, *args)


    def item_quick_height(self, *args):
        """item_quick_height(Fl_Select_Browser self, void * item) -> int"""
        return _fltk.Fl_Select_Browser_item_quick_height(self, *args)


    def item_draw(self, *args):
        """item_draw(Fl_Select_Browser self, void * item, int X, int Y, int W, int H)"""
        return _fltk.Fl_Select_Browser_item_draw(self, *args)


    def item_text(self, *args):
        """item_text(Fl_Select_Browser self, void * item) -> char const *"""
        return _fltk.Fl_Select_Browser_item_text(self, *args)


    def item_swap(self, *args):
        """item_swap(Fl_Select_Browser self, void * a, void * b)"""
        return _fltk.Fl_Select_Browser_item_swap(self, *args)


    def item_at(self, *args):
        """item_at(Fl_Select_Browser self, int line) -> void *"""
        return _fltk.Fl_Select_Browser_item_at(self, *args)


    def full_width(self, *args):
        """full_width(Fl_Select_Browser self) -> int"""
        return _fltk.Fl_Select_Browser_full_width(self, *args)


    def full_height(self, *args):
        """full_height(Fl_Select_Browser self) -> int"""
        return _fltk.Fl_Select_Browser_full_height(self, *args)


    def incr_height(self, *args):
        """incr_height(Fl_Select_Browser self) -> int"""
        return _fltk.Fl_Select_Browser_incr_height(self, *args)


    def item_select(self, *args):
        """item_select(Fl_Select_Browser self, void * item, int val)"""
        return _fltk.Fl_Select_Browser_item_select(self, *args)


    def item_selected(self, *args):
        """item_selected(Fl_Select_Browser self, void * item) -> int"""
        return _fltk.Fl_Select_Browser_item_selected(self, *args)

Fl_Select_Browser_swigregister = _fltk.Fl_Select_Browser_swigregister
Fl_Select_Browser_swigregister(Fl_Select_Browser)

class Fl_Shared_Image(Fl_Image):
    """

    The Fl_Shared_Image class supports caching, loading, and drawing of image 
    files. Most applications will also want to link against the fltk_images 
    library and call the fl_register_images() function to support standard image 
    formats such as BMP, GIF, JPEG, and PNG.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Fl_Shared_Image self) -> Fl_Shared_Image
        __init__(Fl_Shared_Image self, char const * n, Fl_Image img=None) -> Fl_Shared_Image
        """
        if self.__class__ == Fl_Shared_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Shared_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def name(self, *args):
        """name(Fl_Shared_Image self) -> char const *"""
        return _fltk.Fl_Shared_Image_name(self, *args)


    def refcount(self, *args):
        """refcount(Fl_Shared_Image self) -> int"""
        return _fltk.Fl_Shared_Image_refcount(self, *args)


    def release(self, *args):
        """release(Fl_Shared_Image self)"""
        return _fltk.Fl_Shared_Image_release(self, *args)


    def reload(self, *args):
        """reload(Fl_Shared_Image self)"""
        return _fltk.Fl_Shared_Image_reload(self, *args)


    def copy(self, *args):
        """
        copy(Fl_Shared_Image self, int W, int H) -> Fl_Image
        copy(Fl_Shared_Image self) -> Fl_Image
        """
        return _fltk.Fl_Shared_Image_copy(self, *args)


    def color_average(self, *args):
        """color_average(Fl_Shared_Image self, Fl_Color c, float i)"""
        return _fltk.Fl_Shared_Image_color_average(self, *args)


    def desaturate(self, *args):
        """desaturate(Fl_Shared_Image self)"""
        return _fltk.Fl_Shared_Image_desaturate(self, *args)


    def draw(self, *args):
        """
        draw(Fl_Shared_Image self, int X, int Y, int W, int H, int cx, int cy)
        draw(Fl_Shared_Image self, int X, int Y)
        """
        return _fltk.Fl_Shared_Image_draw(self, *args)


    def uncache(self, *args):
        """uncache(Fl_Shared_Image self)"""
        return _fltk.Fl_Shared_Image_uncache(self, *args)


    def find(*args):
        """find(char const * n, int W=0, int H=0) -> Fl_Shared_Image"""
        return _fltk.Fl_Shared_Image_find(*args)

    find = staticmethod(find)

    def get(*args):
        """get(char const * n, int W=0, int H=0) -> Fl_Shared_Image"""
        return _fltk.Fl_Shared_Image_get(*args)

    get = staticmethod(get)

    def images(*args):
        """images() -> Fl_Shared_Image **"""
        return _fltk.Fl_Shared_Image_images(*args)

    images = staticmethod(images)

    def num_images(*args):
        """num_images() -> int"""
        return _fltk.Fl_Shared_Image_num_images(*args)

    num_images = staticmethod(num_images)

    def add_handler(*args):
        """add_handler(Fl_Shared_Handler f)"""
        return _fltk.Fl_Shared_Image_add_handler(*args)

    add_handler = staticmethod(add_handler)

    def remove_handler(*args):
        """remove_handler(Fl_Shared_Handler f)"""
        return _fltk.Fl_Shared_Image_remove_handler(*args)

    remove_handler = staticmethod(remove_handler)
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Shared_Image(self)
        return weakref_proxy(self)
Fl_Shared_Image_swigregister = _fltk.Fl_Shared_Image_swigregister
Fl_Shared_Image_swigregister(Fl_Shared_Image)

def Fl_Shared_Image_find(*args):
    """Fl_Shared_Image_find(char const * n, int W=0, int H=0) -> Fl_Shared_Image"""
    return _fltk.Fl_Shared_Image_find(*args)

def Fl_Shared_Image_get(*args):
    """Fl_Shared_Image_get(char const * n, int W=0, int H=0) -> Fl_Shared_Image"""
    return _fltk.Fl_Shared_Image_get(*args)

def Fl_Shared_Image_images(*args):
    """Fl_Shared_Image_images() -> Fl_Shared_Image **"""
    return _fltk.Fl_Shared_Image_images(*args)

def Fl_Shared_Image_num_images(*args):
    """Fl_Shared_Image_num_images() -> int"""
    return _fltk.Fl_Shared_Image_num_images(*args)

def Fl_Shared_Image_add_handler(*args):
    """Fl_Shared_Image_add_handler(Fl_Shared_Handler f)"""
    return _fltk.Fl_Shared_Image_add_handler(*args)

def Fl_Shared_Image_remove_handler(*args):
    """Fl_Shared_Image_remove_handler(Fl_Shared_Handler f)"""
    return _fltk.Fl_Shared_Image_remove_handler(*args)


def fl_register_images(*args):
    """fl_register_images()"""
    return _fltk.fl_register_images(*args)
class Fl_Spinner(Fl_Group):
    """

    The Fl_Spinner widget is a combination of the input widget and repeat 
    buttons. The user can either type into the input area or use the buttons 
    to change the value.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Spinner self, int X, int Y, int W, int H, char const * L=None) -> Fl_Spinner"""
        if self.__class__ == Fl_Spinner:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Spinner(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def format(self, *args):
        """
        format(Fl_Spinner self) -> char const
        format(Fl_Spinner self, char const * f)
        """
        return _fltk.Fl_Spinner_format(self, *args)


    def handle(self, *args):
        """handle(Fl_Spinner self, int event) -> int"""
        return _fltk.Fl_Spinner_handle(self, *args)


    def maxinum(self, *args):
        """maxinum(Fl_Spinner self) -> double"""
        return _fltk.Fl_Spinner_maxinum(self, *args)


    def mininum(self, *args):
        """mininum(Fl_Spinner self) -> double"""
        return _fltk.Fl_Spinner_mininum(self, *args)


    def range(self, *args):
        """range(Fl_Spinner self, double a, double b)"""
        return _fltk.Fl_Spinner_range(self, *args)


    def resize(self, *args):
        """resize(Fl_Spinner self, int X, int Y, int W, int H)"""
        return _fltk.Fl_Spinner_resize(self, *args)


    def step(self, *args):
        """
        step(Fl_Spinner self) -> double
        step(Fl_Spinner self, double s)
        """
        return _fltk.Fl_Spinner_step(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Spinner self) -> Fl_Color
        textcolor(Fl_Spinner self, Fl_Color c)
        """
        return _fltk.Fl_Spinner_textcolor(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Spinner self) -> Fl_Font
        textfont(Fl_Spinner self, Fl_Font f)
        """
        return _fltk.Fl_Spinner_textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Spinner self) -> Fl_Fontsize
        textsize(Fl_Spinner self, Fl_Fontsize s)
        """
        return _fltk.Fl_Spinner_textsize(self, *args)


    def type(self, *args):
        """
        type(Fl_Spinner self) -> uchar
        type(Fl_Spinner self, uchar v)
        """
        return _fltk.Fl_Spinner_type(self, *args)


    def value(self, *args):
        """
        value(Fl_Spinner self) -> double
        value(Fl_Spinner self, double v)
        """
        return _fltk.Fl_Spinner_value(self, *args)


    def color(self, *args):
        """
        color(Fl_Spinner self, Fl_Color v)
        color(Fl_Spinner self) -> Fl_Color
        """
        return _fltk.Fl_Spinner_color(self, *args)


    def selection_color(self, *args):
        """
        selection_color(Fl_Spinner self, Fl_Color val)
        selection_color(Fl_Spinner self) -> Fl_Color
        """
        return _fltk.Fl_Spinner_selection_color(self, *args)


    def minimum(self, *args):
        """
        minimum(Fl_Spinner self, double m)
        minimum(Fl_Spinner self) -> double
        """
        return _fltk.Fl_Spinner_minimum(self, *args)


    def maximum(self, *args):
        """
        maximum(Fl_Spinner self, double m)
        maximum(Fl_Spinner self) -> double
        """
        return _fltk.Fl_Spinner_maximum(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Spinner
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Spinner(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Spinner self)"""
        return _fltk.Fl_Spinner_draw(self, *args)

Fl_Spinner_swigregister = _fltk.Fl_Spinner_swigregister
Fl_Spinner_swigregister(Fl_Spinner)


def fl_show_colormap(*args):
    """fl_show_colormap(Fl_Color oldcol) -> Fl_Color"""
    return _fltk.fl_show_colormap(*args)
class Fl_Simple_Counter(Fl_Counter):
    """Proxy of C++ Fl_Simple_Counter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Simple_Counter self, int X, int Y, int W, int H, char const * L=None) -> Fl_Simple_Counter"""
        if self.__class__ == Fl_Simple_Counter:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Simple_Counter(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Simple_Counter
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Simple_Counter(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Simple_Counter self)"""
        return _fltk.Fl_Simple_Counter_draw(self, *args)

Fl_Simple_Counter_swigregister = _fltk.Fl_Simple_Counter_swigregister
Fl_Simple_Counter_swigregister(Fl_Simple_Counter)

class Fl_Tabs(Fl_Group):
    """

    The Fl_Tabs widget is the 'file card tabs' interface that allows you to 
    put lots and lots of buttons and switches in a panel, as popularized by 
    many toolkits.

    Clicking the tab makes a child visible() by calling show() on it, and 
    all other children are made invisible by calling hide() on them. Usually 
    the children are Fl_Group widgets containing several widgets themselves.

    Each child makes a card, and it's label() is printed on the card tab, 
    including the label font and style. The selection color of that child 
    is used to color the tab, while the color of the child determines the 
    background color of the pane.

    The size of the tabs is controlled by the bounding box of the children 
    (there should be some space between the children and the edge of the Fl_Tabs), 
    and the tabs may be placed 'inverted' on the bottom, this is determined 
    by which gap is larger. It is easiest to lay this out in fluid, using the 
    fluid browser to select each child group and resize them until the tabs 
    look the way you want them to. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Tabs self)"""
        return _fltk.Fl_Tabs_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Tabs self, int arg0) -> int"""
        return _fltk.Fl_Tabs_handle(self, *args)


    def value(self, *args):
        """
        value(Fl_Tabs self) -> Fl_Widget
        value(Fl_Tabs self, Fl_Widget arg2) -> int
        """
        return _fltk.Fl_Tabs_value(self, *args)


    def push(self, *args):
        """
        push(Fl_Tabs self) -> Fl_Widget
        push(Fl_Tabs self, Fl_Widget arg2) -> int
        """
        return _fltk.Fl_Tabs_push(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Tabs self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Tabs"""
        if self.__class__ == Fl_Tabs:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Tabs(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def which(self, *args):
        """which(Fl_Tabs self, int event_x, int event_y) -> Fl_Widget"""
        return _fltk.Fl_Tabs_which(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Tabs
    __del__ = lambda self: None

    def client_area(self, *args):
        """client_area(Fl_Tabs self, int tabh=0)"""
        return _fltk.Fl_Tabs_client_area(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Tabs(self)
        return weakref_proxy(self)
Fl_Tabs_swigregister = _fltk.Fl_Tabs_swigregister
Fl_Tabs_swigregister(Fl_Tabs)


_fltk.FL_TEXT_MAX_EXP_CHAR_LEN_swigconstant(_fltk)
FL_TEXT_MAX_EXP_CHAR_LEN = _fltk.FL_TEXT_MAX_EXP_CHAR_LEN
class Fl_Text_Selection(object):
    """Proxy of C++ Fl_Text_Selection class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def set(self, *args):
        """set(Fl_Text_Selection self, int start, int end)"""
        return _fltk.Fl_Text_Selection_set(self, *args)


    def update(self, *args):
        """update(Fl_Text_Selection self, int pos, int nDeleted, int nInserted)"""
        return _fltk.Fl_Text_Selection_update(self, *args)


    def start(self, *args):
        """start(Fl_Text_Selection self) -> int"""
        return _fltk.Fl_Text_Selection_start(self, *args)


    def end(self, *args):
        """end(Fl_Text_Selection self) -> int"""
        return _fltk.Fl_Text_Selection_end(self, *args)


    def selected(self, *args):
        """
        selected(Fl_Text_Selection self) -> bool
        selected(Fl_Text_Selection self, bool b)
        """
        return _fltk.Fl_Text_Selection_selected(self, *args)


    def includes(self, *args):
        """includes(Fl_Text_Selection self, int pos) -> int"""
        return _fltk.Fl_Text_Selection_includes(self, *args)


    def position(self, *args):
        """position(Fl_Text_Selection self, int * start, int * end) -> int"""
        return _fltk.Fl_Text_Selection_position(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Text_Selection self) -> Fl_Text_Selection"""
        this = _fltk.new_Fl_Text_Selection(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Text_Selection
    __del__ = lambda self: None
Fl_Text_Selection_swigregister = _fltk.Fl_Text_Selection_swigregister
Fl_Text_Selection_swigregister(Fl_Text_Selection)

class Fl_Text_Buffer(object):
    """

    The Fl_Text_Buffer class is used by the Fl_Text_Display and Fl_Text_Editor 
    to manage complex text data and is based upon the excellent NEdit text 
    editor engine - see http://www.nedit.org/.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Text_Buffer self, int requestedSize=0, int preferredGapSize=1024) -> Fl_Text_Buffer"""
        this = _fltk.new_Fl_Text_Buffer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Text_Buffer
    __del__ = lambda self: None

    def length(self, *args):
        """length(Fl_Text_Buffer self) -> int"""
        return _fltk.Fl_Text_Buffer_length(self, *args)


    def text(self, *args):
        """
        text(Fl_Text_Buffer self) -> char
        text(Fl_Text_Buffer self, char const * text)
        """
        return _fltk.Fl_Text_Buffer_text(self, *args)


    def text_range(self, *args):
        """text_range(Fl_Text_Buffer self, int start, int end) -> char *"""
        return _fltk.Fl_Text_Buffer_text_range(self, *args)


    def char_at(self, *args):
        """char_at(Fl_Text_Buffer self, int pos) -> unsigned int"""
        return _fltk.Fl_Text_Buffer_char_at(self, *args)


    def byte_at(self, *args):
        """byte_at(Fl_Text_Buffer self, int pos) -> char"""
        return _fltk.Fl_Text_Buffer_byte_at(self, *args)


    def address(self, *args):
        """
        address(Fl_Text_Buffer self, int pos) -> char const
        address(Fl_Text_Buffer self, int pos) -> char *
        """
        return _fltk.Fl_Text_Buffer_address(self, *args)


    def insert(self, *args):
        """insert(Fl_Text_Buffer self, int pos, char const * text)"""
        return _fltk.Fl_Text_Buffer_insert(self, *args)


    def append(self, *args):
        """append(Fl_Text_Buffer self, char const * t)"""
        return _fltk.Fl_Text_Buffer_append(self, *args)


    def remove(self, *args):
        """remove(Fl_Text_Buffer self, int start, int end)"""
        return _fltk.Fl_Text_Buffer_remove(self, *args)


    def replace(self, *args):
        """replace(Fl_Text_Buffer self, int start, int end, char const * text)"""
        return _fltk.Fl_Text_Buffer_replace(self, *args)


    def copy(self, *args):
        """copy(Fl_Text_Buffer self, Fl_Text_Buffer fromBuf, int fromStart, int fromEnd, int toPos)"""
        return _fltk.Fl_Text_Buffer_copy(self, *args)


    def undo(self, *args):
        """undo(Fl_Text_Buffer self, int * cp=None) -> int"""
        return _fltk.Fl_Text_Buffer_undo(self, *args)


    def canUndo(self, *args):
        """canUndo(Fl_Text_Buffer self, char flag=1)"""
        return _fltk.Fl_Text_Buffer_canUndo(self, *args)


    def insertfile(self, *args):
        """insertfile(Fl_Text_Buffer self, char const * file, int pos, int buflen=128) -> int"""
        return _fltk.Fl_Text_Buffer_insertfile(self, *args)


    def appendfile(self, *args):
        """appendfile(Fl_Text_Buffer self, char const * file, int buflen=128) -> int"""
        return _fltk.Fl_Text_Buffer_appendfile(self, *args)


    def loadfile(self, *args):
        """loadfile(Fl_Text_Buffer self, char const * file, int buflen=128) -> int"""
        return _fltk.Fl_Text_Buffer_loadfile(self, *args)


    def outputfile(self, *args):
        """outputfile(Fl_Text_Buffer self, char const * file, int start, int end, int buflen=128) -> int"""
        return _fltk.Fl_Text_Buffer_outputfile(self, *args)


    def savefile(self, *args):
        """savefile(Fl_Text_Buffer self, char const * file, int buflen=128) -> int"""
        return _fltk.Fl_Text_Buffer_savefile(self, *args)


    def tab_distance(self, *args):
        """
        tab_distance(Fl_Text_Buffer self) -> int
        tab_distance(Fl_Text_Buffer self, int tabDist)
        """
        return _fltk.Fl_Text_Buffer_tab_distance(self, *args)


    def select(self, *args):
        """select(Fl_Text_Buffer self, int start, int end)"""
        return _fltk.Fl_Text_Buffer_select(self, *args)


    def selected(self, *args):
        """selected(Fl_Text_Buffer self) -> int"""
        return _fltk.Fl_Text_Buffer_selected(self, *args)


    def unselect(self, *args):
        """unselect(Fl_Text_Buffer self)"""
        return _fltk.Fl_Text_Buffer_unselect(self, *args)


    def selection_position(self, *args):
        """selection_position(Fl_Text_Buffer self, int * start, int * end) -> int"""
        return _fltk.Fl_Text_Buffer_selection_position(self, *args)


    def selection_text(self, *args):
        """selection_text(Fl_Text_Buffer self) -> char *"""
        return _fltk.Fl_Text_Buffer_selection_text(self, *args)


    def remove_selection(self, *args):
        """remove_selection(Fl_Text_Buffer self)"""
        return _fltk.Fl_Text_Buffer_remove_selection(self, *args)


    def replace_selection(self, *args):
        """replace_selection(Fl_Text_Buffer self, char const * text)"""
        return _fltk.Fl_Text_Buffer_replace_selection(self, *args)


    def secondary_select(self, *args):
        """secondary_select(Fl_Text_Buffer self, int start, int end)"""
        return _fltk.Fl_Text_Buffer_secondary_select(self, *args)


    def secondary_selected(self, *args):
        """secondary_selected(Fl_Text_Buffer self) -> int"""
        return _fltk.Fl_Text_Buffer_secondary_selected(self, *args)


    def secondary_unselect(self, *args):
        """secondary_unselect(Fl_Text_Buffer self)"""
        return _fltk.Fl_Text_Buffer_secondary_unselect(self, *args)


    def secondary_selection_position(self, *args):
        """secondary_selection_position(Fl_Text_Buffer self, int * start, int * end) -> int"""
        return _fltk.Fl_Text_Buffer_secondary_selection_position(self, *args)


    def secondary_selection_text(self, *args):
        """secondary_selection_text(Fl_Text_Buffer self) -> char *"""
        return _fltk.Fl_Text_Buffer_secondary_selection_text(self, *args)


    def remove_secondary_selection(self, *args):
        """remove_secondary_selection(Fl_Text_Buffer self)"""
        return _fltk.Fl_Text_Buffer_remove_secondary_selection(self, *args)


    def replace_secondary_selection(self, *args):
        """replace_secondary_selection(Fl_Text_Buffer self, char const * text)"""
        return _fltk.Fl_Text_Buffer_replace_secondary_selection(self, *args)


    def highlight(self, *args):
        """
        highlight(Fl_Text_Buffer self, int start, int end)
        highlight(Fl_Text_Buffer self) -> int
        """
        return _fltk.Fl_Text_Buffer_highlight(self, *args)


    def unhighlight(self, *args):
        """unhighlight(Fl_Text_Buffer self)"""
        return _fltk.Fl_Text_Buffer_unhighlight(self, *args)


    def highlight_position(self, *args):
        """highlight_position(Fl_Text_Buffer self, int * start, int * end) -> int"""
        return _fltk.Fl_Text_Buffer_highlight_position(self, *args)


    def highlight_text(self, *args):
        """highlight_text(Fl_Text_Buffer self) -> char *"""
        return _fltk.Fl_Text_Buffer_highlight_text(self, *args)


    def call_modify_callbacks(self, *args):
        """call_modify_callbacks(Fl_Text_Buffer self)"""
        return _fltk.Fl_Text_Buffer_call_modify_callbacks(self, *args)


    def add_predelete_callback(self, *args):
        """add_predelete_callback(Fl_Text_Buffer self, Fl_Text_Predelete_Cb bufPredelCB, void * cbArg)"""
        return _fltk.Fl_Text_Buffer_add_predelete_callback(self, *args)


    def remove_predelete_callback(self, *args):
        """remove_predelete_callback(Fl_Text_Buffer self, Fl_Text_Predelete_Cb predelCB, void * cbArg)"""
        return _fltk.Fl_Text_Buffer_remove_predelete_callback(self, *args)


    def call_predelete_callbacks(self, *args):
        """call_predelete_callbacks(Fl_Text_Buffer self)"""
        return _fltk.Fl_Text_Buffer_call_predelete_callbacks(self, *args)


    def line_text(self, *args):
        """line_text(Fl_Text_Buffer self, int pos) -> char *"""
        return _fltk.Fl_Text_Buffer_line_text(self, *args)


    def line_start(self, *args):
        """line_start(Fl_Text_Buffer self, int pos) -> int"""
        return _fltk.Fl_Text_Buffer_line_start(self, *args)


    def line_end(self, *args):
        """line_end(Fl_Text_Buffer self, int pos) -> int"""
        return _fltk.Fl_Text_Buffer_line_end(self, *args)


    def word_start(self, *args):
        """word_start(Fl_Text_Buffer self, int pos) -> int"""
        return _fltk.Fl_Text_Buffer_word_start(self, *args)


    def word_end(self, *args):
        """word_end(Fl_Text_Buffer self, int pos) -> int"""
        return _fltk.Fl_Text_Buffer_word_end(self, *args)


    def count_displayed_characters(self, *args):
        """count_displayed_characters(Fl_Text_Buffer self, int lineStartPos, int targetPos) -> int"""
        return _fltk.Fl_Text_Buffer_count_displayed_characters(self, *args)


    def skip_displayed_characters(self, *args):
        """skip_displayed_characters(Fl_Text_Buffer self, int lineStartPos, int nChars) -> int"""
        return _fltk.Fl_Text_Buffer_skip_displayed_characters(self, *args)


    def count_lines(self, *args):
        """count_lines(Fl_Text_Buffer self, int startPos, int endPos) -> int"""
        return _fltk.Fl_Text_Buffer_count_lines(self, *args)


    def skip_lines(self, *args):
        """skip_lines(Fl_Text_Buffer self, int startPos, int nLines) -> int"""
        return _fltk.Fl_Text_Buffer_skip_lines(self, *args)


    def rewind_lines(self, *args):
        """rewind_lines(Fl_Text_Buffer self, int startPos, int nLines) -> int"""
        return _fltk.Fl_Text_Buffer_rewind_lines(self, *args)


    def findchar_forward(self, *args):
        """findchar_forward(Fl_Text_Buffer self, int startPos, unsigned int searchChar) -> int"""
        return _fltk.Fl_Text_Buffer_findchar_forward(self, *args)


    def findchar_backward(self, *args):
        """findchar_backward(Fl_Text_Buffer self, int startPos, unsigned int searchChar) -> int"""
        return _fltk.Fl_Text_Buffer_findchar_backward(self, *args)


    def search_forward(self, *args):
        """search_forward(Fl_Text_Buffer self, int startPos, char const * searchString, int matchCase=0) -> int"""
        return _fltk.Fl_Text_Buffer_search_forward(self, *args)


    def search_backward(self, *args):
        """search_backward(Fl_Text_Buffer self, int startPos, char const * searchString, int matchCase=0) -> int"""
        return _fltk.Fl_Text_Buffer_search_backward(self, *args)


    def primary_selection(self, *args):
        """
        primary_selection(Fl_Text_Buffer self) -> Fl_Text_Selection
        primary_selection(Fl_Text_Buffer self) -> Fl_Text_Selection
        """
        return _fltk.Fl_Text_Buffer_primary_selection(self, *args)


    def secondary_selection(self, *args):
        """secondary_selection(Fl_Text_Buffer self) -> Fl_Text_Selection"""
        return _fltk.Fl_Text_Buffer_secondary_selection(self, *args)


    def highlight_selection(self, *args):
        """highlight_selection(Fl_Text_Buffer self) -> Fl_Text_Selection"""
        return _fltk.Fl_Text_Buffer_highlight_selection(self, *args)


    def prev_char(self, *args):
        """prev_char(Fl_Text_Buffer self, int ix) -> int"""
        return _fltk.Fl_Text_Buffer_prev_char(self, *args)


    def prev_char_clipped(self, *args):
        """prev_char_clipped(Fl_Text_Buffer self, int ix) -> int"""
        return _fltk.Fl_Text_Buffer_prev_char_clipped(self, *args)


    def next_char(self, *args):
        """next_char(Fl_Text_Buffer self, int ix) -> int"""
        return _fltk.Fl_Text_Buffer_next_char(self, *args)


    def next_char_clipped(self, *args):
        """next_char_clipped(Fl_Text_Buffer self, int ix) -> int"""
        return _fltk.Fl_Text_Buffer_next_char_clipped(self, *args)


    def utf8_align(self, *args):
        """utf8_align(Fl_Text_Buffer self, int arg2) -> int"""
        return _fltk.Fl_Text_Buffer_utf8_align(self, *args)


    def add_modify_callback(self, *args):
        """
        add_modify_callback(Fl_Text_Buffer self, Fl_Text_Modify_Cb bufModifiedCB, void * cbArg)
        add_modify_callback(Fl_Text_Buffer self, PyObject * PyFunc, PyObject * PyTarget=None)
        """
        return _fltk.Fl_Text_Buffer_add_modify_callback(self, *args)


    def remove_modify_callback(self, *args):
        """
        remove_modify_callback(Fl_Text_Buffer self, Fl_Text_Modify_Cb bufModifiedCB, void * cbArg)
        remove_modify_callback(Fl_Text_Buffer self, PyObject * PyFunc, PyObject * PyWidget, PyObject * PyTarget)
        """
        return _fltk.Fl_Text_Buffer_remove_modify_callback(self, *args)

Fl_Text_Buffer_swigregister = _fltk.Fl_Text_Buffer_swigregister
Fl_Text_Buffer_swigregister(Fl_Text_Buffer)

class Style_Table_Entry(object):
    """Proxy of C++ Style_Table_Entry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Style_Table_Entry self) -> Style_Table_Entry"""
        this = _fltk.new_Style_Table_Entry(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Style_Table_Entry
    __del__ = lambda self: None
Style_Table_Entry_swigregister = _fltk.Style_Table_Entry_swigregister
Style_Table_Entry_swigregister(Style_Table_Entry)

class Fl_Text_Display(Fl_Group):
    """

    This is the FLTK text display widget. It allows the user to view multiple 
    lines of text and supports highlighting and scrolling. The buffer that is 
    displayed in the widget is managed by the Fl_Text_Buffer class.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NORMAL_CURSOR = _fltk.Fl_Text_Display_NORMAL_CURSOR
    CARET_CURSOR = _fltk.Fl_Text_Display_CARET_CURSOR
    DIM_CURSOR = _fltk.Fl_Text_Display_DIM_CURSOR
    BLOCK_CURSOR = _fltk.Fl_Text_Display_BLOCK_CURSOR
    HEAVY_CURSOR = _fltk.Fl_Text_Display_HEAVY_CURSOR
    SIMPLE_CURSOR = _fltk.Fl_Text_Display_SIMPLE_CURSOR
    CURSOR_POS = _fltk.Fl_Text_Display_CURSOR_POS
    CHARACTER_POS = _fltk.Fl_Text_Display_CHARACTER_POS
    DRAG_NONE = _fltk.Fl_Text_Display_DRAG_NONE
    DRAG_START_DND = _fltk.Fl_Text_Display_DRAG_START_DND
    DRAG_CHAR = _fltk.Fl_Text_Display_DRAG_CHAR
    DRAG_WORD = _fltk.Fl_Text_Display_DRAG_WORD
    DRAG_LINE = _fltk.Fl_Text_Display_DRAG_LINE
    WRAP_NONE = _fltk.Fl_Text_Display_WRAP_NONE
    WRAP_AT_COLUMN = _fltk.Fl_Text_Display_WRAP_AT_COLUMN
    WRAP_AT_PIXEL = _fltk.Fl_Text_Display_WRAP_AT_PIXEL
    WRAP_AT_BOUNDS = _fltk.Fl_Text_Display_WRAP_AT_BOUNDS

    def __init__(self, *args):
        """__init__(Fl_Text_Display self, int X, int Y, int W, int H, char const * l=None) -> Fl_Text_Display"""
        if self.__class__ == Fl_Text_Display:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Text_Display(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Text_Display
    __del__ = lambda self: None

    def handle(self, *args):
        """handle(Fl_Text_Display self, int e) -> int"""
        return _fltk.Fl_Text_Display_handle(self, *args)


    def buffer(self, *args):
        """
        buffer(Fl_Text_Display self, Fl_Text_Buffer buf)
        buffer(Fl_Text_Display self) -> Fl_Text_Buffer
        """
        val = _fltk.Fl_Text_Display_buffer(self, *args)

        if len(args) > 0 and args[0] != None:
        #delegate ownership to C++
            args[0].this.disown()


        return val


    def redisplay_range(self, *args):
        """redisplay_range(Fl_Text_Display self, int start, int end)"""
        return _fltk.Fl_Text_Display_redisplay_range(self, *args)


    def scroll(self, *args):
        """scroll(Fl_Text_Display self, int topLineNum, int horizOffset)"""
        return _fltk.Fl_Text_Display_scroll(self, *args)


    def insert(self, *args):
        """insert(Fl_Text_Display self, char const * text)"""
        return _fltk.Fl_Text_Display_insert(self, *args)


    def overstrike(self, *args):
        """overstrike(Fl_Text_Display self, char const * text)"""
        return _fltk.Fl_Text_Display_overstrike(self, *args)


    def insert_position(self, *args):
        """
        insert_position(Fl_Text_Display self, int newPos)
        insert_position(Fl_Text_Display self) -> int
        """
        return _fltk.Fl_Text_Display_insert_position(self, *args)


    def position_to_xy(self, *args):
        """position_to_xy(Fl_Text_Display self, int pos, int * x, int * y) -> int"""
        return _fltk.Fl_Text_Display_position_to_xy(self, *args)


    def in_selection(self, *args):
        """in_selection(Fl_Text_Display self, int x, int y) -> int"""
        return _fltk.Fl_Text_Display_in_selection(self, *args)


    def show_insert_position(self, *args):
        """show_insert_position(Fl_Text_Display self)"""
        return _fltk.Fl_Text_Display_show_insert_position(self, *args)


    def move_right(self, *args):
        """move_right(Fl_Text_Display self) -> int"""
        return _fltk.Fl_Text_Display_move_right(self, *args)


    def move_left(self, *args):
        """move_left(Fl_Text_Display self) -> int"""
        return _fltk.Fl_Text_Display_move_left(self, *args)


    def move_up(self, *args):
        """move_up(Fl_Text_Display self) -> int"""
        return _fltk.Fl_Text_Display_move_up(self, *args)


    def move_down(self, *args):
        """move_down(Fl_Text_Display self) -> int"""
        return _fltk.Fl_Text_Display_move_down(self, *args)


    def count_lines(self, *args):
        """count_lines(Fl_Text_Display self, int start, int end, bool start_pos_is_line_start) -> int"""
        return _fltk.Fl_Text_Display_count_lines(self, *args)


    def line_start(self, *args):
        """line_start(Fl_Text_Display self, int pos) -> int"""
        return _fltk.Fl_Text_Display_line_start(self, *args)


    def line_end(self, *args):
        """line_end(Fl_Text_Display self, int startPos, bool startPosIsLineStart) -> int"""
        return _fltk.Fl_Text_Display_line_end(self, *args)


    def skip_lines(self, *args):
        """skip_lines(Fl_Text_Display self, int startPos, int nLines, bool startPosIsLineStart) -> int"""
        return _fltk.Fl_Text_Display_skip_lines(self, *args)


    def rewind_lines(self, *args):
        """rewind_lines(Fl_Text_Display self, int startPos, int nLines) -> int"""
        return _fltk.Fl_Text_Display_rewind_lines(self, *args)


    def next_word(self, *args):
        """next_word(Fl_Text_Display self)"""
        return _fltk.Fl_Text_Display_next_word(self, *args)


    def previous_word(self, *args):
        """previous_word(Fl_Text_Display self)"""
        return _fltk.Fl_Text_Display_previous_word(self, *args)


    def show_cursor(self, *args):
        """show_cursor(Fl_Text_Display self, int b=1)"""
        return _fltk.Fl_Text_Display_show_cursor(self, *args)


    def hide_cursor(self, *args):
        """hide_cursor(Fl_Text_Display self)"""
        return _fltk.Fl_Text_Display_hide_cursor(self, *args)


    def cursor_style(self, *args):
        """cursor_style(Fl_Text_Display self, int style)"""
        return _fltk.Fl_Text_Display_cursor_style(self, *args)


    def cursor_color(self, *args):
        """
        cursor_color(Fl_Text_Display self) -> Fl_Color
        cursor_color(Fl_Text_Display self, Fl_Color n)
        """
        return _fltk.Fl_Text_Display_cursor_color(self, *args)


    def scrollbar_width(self, *args):
        """
        scrollbar_width(Fl_Text_Display self) -> int
        scrollbar_width(Fl_Text_Display self, int W)
        """
        return _fltk.Fl_Text_Display_scrollbar_width(self, *args)


    def scrollbar_align(self, *args):
        """
        scrollbar_align(Fl_Text_Display self) -> Fl_Align
        scrollbar_align(Fl_Text_Display self, Fl_Align a)
        """
        return _fltk.Fl_Text_Display_scrollbar_align(self, *args)


    def word_start(self, *args):
        """word_start(Fl_Text_Display self, int pos) -> int"""
        return _fltk.Fl_Text_Display_word_start(self, *args)


    def word_end(self, *args):
        """word_end(Fl_Text_Display self, int pos) -> int"""
        return _fltk.Fl_Text_Display_word_end(self, *args)


    def position_style(self, *args):
        """position_style(Fl_Text_Display self, int lineStartPos, int lineLen, int lineIndex) -> int"""
        return _fltk.Fl_Text_Display_position_style(self, *args)


    def shortcut(self, *args):
        """
        shortcut(Fl_Text_Display self) -> int
        shortcut(Fl_Text_Display self, int s)
        """
        return _fltk.Fl_Text_Display_shortcut(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Text_Display self) -> Fl_Font
        textfont(Fl_Text_Display self, Fl_Font s)
        """
        return _fltk.Fl_Text_Display_textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Text_Display self) -> Fl_Fontsize
        textsize(Fl_Text_Display self, Fl_Fontsize s)
        """
        return _fltk.Fl_Text_Display_textsize(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Text_Display self) -> Fl_Color
        textcolor(Fl_Text_Display self, Fl_Color n)
        """
        return _fltk.Fl_Text_Display_textcolor(self, *args)


    def wrapped_column(self, *args):
        """wrapped_column(Fl_Text_Display self, int row, int column) -> int"""
        return _fltk.Fl_Text_Display_wrapped_column(self, *args)


    def wrapped_row(self, *args):
        """wrapped_row(Fl_Text_Display self, int row) -> int"""
        return _fltk.Fl_Text_Display_wrapped_row(self, *args)


    def wrap_mode(self, *args):
        """wrap_mode(Fl_Text_Display self, int wrap, int wrap_margin)"""
        return _fltk.Fl_Text_Display_wrap_mode(self, *args)


    def resize(self, *args):
        """resize(Fl_Text_Display self, int X, int Y, int W, int H)"""
        return _fltk.Fl_Text_Display_resize(self, *args)


    def x_to_col(self, *args):
        """x_to_col(Fl_Text_Display self, double x) -> double"""
        return _fltk.Fl_Text_Display_x_to_col(self, *args)


    def col_to_x(self, *args):
        """col_to_x(Fl_Text_Display self, double col) -> double"""
        return _fltk.Fl_Text_Display_col_to_x(self, *args)


    def linenumber_width(self, *args):
        """
        linenumber_width(Fl_Text_Display self, int width)
        linenumber_width(Fl_Text_Display self) -> int
        """
        return _fltk.Fl_Text_Display_linenumber_width(self, *args)


    def linenumber_font(self, *args):
        """
        linenumber_font(Fl_Text_Display self, Fl_Font val)
        linenumber_font(Fl_Text_Display self) -> Fl_Font
        """
        return _fltk.Fl_Text_Display_linenumber_font(self, *args)


    def linenumber_size(self, *args):
        """
        linenumber_size(Fl_Text_Display self, Fl_Fontsize val)
        linenumber_size(Fl_Text_Display self) -> Fl_Fontsize
        """
        return _fltk.Fl_Text_Display_linenumber_size(self, *args)


    def linenumber_fgcolor(self, *args):
        """
        linenumber_fgcolor(Fl_Text_Display self, Fl_Color val)
        linenumber_fgcolor(Fl_Text_Display self) -> Fl_Color
        """
        return _fltk.Fl_Text_Display_linenumber_fgcolor(self, *args)


    def linenumber_bgcolor(self, *args):
        """
        linenumber_bgcolor(Fl_Text_Display self, Fl_Color val)
        linenumber_bgcolor(Fl_Text_Display self) -> Fl_Color
        """
        return _fltk.Fl_Text_Display_linenumber_bgcolor(self, *args)


    def linenumber_align(self, *args):
        """
        linenumber_align(Fl_Text_Display self, Fl_Align val)
        linenumber_align(Fl_Text_Display self) -> Fl_Align
        """
        return _fltk.Fl_Text_Display_linenumber_align(self, *args)


    def linenumber_format(self, *args):
        """
        linenumber_format(Fl_Text_Display self, char const * val)
        linenumber_format(Fl_Text_Display self) -> char const *
        """
        return _fltk.Fl_Text_Display_linenumber_format(self, *args)


    def draw(self, *args):
        """draw(Fl_Text_Display self)"""
        return _fltk.Fl_Text_Display_draw(self, *args)


    def highlight_data(self, *args):
        """highlight_data(Fl_Text_Display self, Fl_Text_Buffer styleBuffer, Fl_Text_Display::Style_Table_Entry const * styleTable, int nStyles, char unfinishedStyle, PyObject * func, PyObject * cbArg)"""
        return _fltk.Fl_Text_Display_highlight_data(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Text_Display(self)
        return weakref_proxy(self)
Fl_Text_Display_swigregister = _fltk.Fl_Text_Display_swigregister
Fl_Text_Display_swigregister(Fl_Text_Display)


_fltk.FL_TEXT_EDITOR_ANY_STATE_swigconstant(_fltk)
FL_TEXT_EDITOR_ANY_STATE = _fltk.FL_TEXT_EDITOR_ANY_STATE
class Fl_Text_Editor(Fl_Text_Display):
    """

    This is the FLTK text editor widget. It allows the user to edit multiple 
    lines of text and supports highlighting and scrolling. The buffer that is 
    displayed in the widget is managed by the Fl_Text_Buffer class.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Text_Editor self, int X, int Y, int W, int H, char const * l=None) -> Fl_Text_Editor"""
        if self.__class__ == Fl_Text_Editor:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Text_Editor(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Text_Editor
    __del__ = lambda self: None

    def handle(self, *args):
        """handle(Fl_Text_Editor self, int e) -> int"""
        return _fltk.Fl_Text_Editor_handle(self, *args)


    def insert_mode(self, *args):
        """
        insert_mode(Fl_Text_Editor self, int b)
        insert_mode(Fl_Text_Editor self) -> int
        """
        return _fltk.Fl_Text_Editor_insert_mode(self, *args)


    def add_key_binding(self, *args):
        """add_key_binding(Fl_Text_Editor self, int key, int state, Fl_Text_Editor::Key_Func f)"""
        return _fltk.Fl_Text_Editor_add_key_binding(self, *args)


    def remove_key_binding(self, *args):
        """remove_key_binding(Fl_Text_Editor self, int key, int state)"""
        return _fltk.Fl_Text_Editor_remove_key_binding(self, *args)


    def remove_all_key_bindings(self, *args):
        """remove_all_key_bindings(Fl_Text_Editor self)"""
        return _fltk.Fl_Text_Editor_remove_all_key_bindings(self, *args)


    def bound_key_function(self, *args):
        """bound_key_function(Fl_Text_Editor self, int key, int state) -> Fl_Text_Editor::Key_Func"""
        return _fltk.Fl_Text_Editor_bound_key_function(self, *args)


    def default_key_function(self, *args):
        """default_key_function(Fl_Text_Editor self, Fl_Text_Editor::Key_Func f)"""
        return _fltk.Fl_Text_Editor_default_key_function(self, *args)


    def kf_default(*args):
        """kf_default(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_default(*args)

    kf_default = staticmethod(kf_default)

    def kf_ignore(*args):
        """kf_ignore(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_ignore(*args)

    kf_ignore = staticmethod(kf_ignore)

    def kf_backspace(*args):
        """kf_backspace(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_backspace(*args)

    kf_backspace = staticmethod(kf_backspace)

    def kf_enter(*args):
        """kf_enter(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_enter(*args)

    kf_enter = staticmethod(kf_enter)

    def kf_move(*args):
        """kf_move(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_move(*args)

    kf_move = staticmethod(kf_move)

    def kf_shift_move(*args):
        """kf_shift_move(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_shift_move(*args)

    kf_shift_move = staticmethod(kf_shift_move)

    def kf_ctrl_move(*args):
        """kf_ctrl_move(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_ctrl_move(*args)

    kf_ctrl_move = staticmethod(kf_ctrl_move)

    def kf_c_s_move(*args):
        """kf_c_s_move(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_c_s_move(*args)

    kf_c_s_move = staticmethod(kf_c_s_move)

    def kf_meta_move(*args):
        """kf_meta_move(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_meta_move(*args)

    kf_meta_move = staticmethod(kf_meta_move)

    def kf_m_s_move(*args):
        """kf_m_s_move(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_m_s_move(*args)

    kf_m_s_move = staticmethod(kf_m_s_move)

    def kf_home(*args):
        """kf_home(int arg1, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_home(*args)

    kf_home = staticmethod(kf_home)

    def kf_end(*args):
        """kf_end(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_end(*args)

    kf_end = staticmethod(kf_end)

    def kf_left(*args):
        """kf_left(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_left(*args)

    kf_left = staticmethod(kf_left)

    def kf_up(*args):
        """kf_up(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_up(*args)

    kf_up = staticmethod(kf_up)

    def kf_right(*args):
        """kf_right(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_right(*args)

    kf_right = staticmethod(kf_right)

    def kf_down(*args):
        """kf_down(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_down(*args)

    kf_down = staticmethod(kf_down)

    def kf_page_up(*args):
        """kf_page_up(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_page_up(*args)

    kf_page_up = staticmethod(kf_page_up)

    def kf_page_down(*args):
        """kf_page_down(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_page_down(*args)

    kf_page_down = staticmethod(kf_page_down)

    def kf_insert(*args):
        """kf_insert(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_insert(*args)

    kf_insert = staticmethod(kf_insert)

    def kf_delete(*args):
        """kf_delete(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_delete(*args)

    kf_delete = staticmethod(kf_delete)

    def kf_copy(*args):
        """kf_copy(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_copy(*args)

    kf_copy = staticmethod(kf_copy)

    def kf_cut(*args):
        """kf_cut(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_cut(*args)

    kf_cut = staticmethod(kf_cut)

    def kf_paste(*args):
        """kf_paste(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_paste(*args)

    kf_paste = staticmethod(kf_paste)

    def kf_select_all(*args):
        """kf_select_all(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_select_all(*args)

    kf_select_all = staticmethod(kf_select_all)

    def kf_undo(*args):
        """kf_undo(int c, Fl_Text_Editor e) -> int"""
        return _fltk.Fl_Text_Editor_kf_undo(*args)

    kf_undo = staticmethod(kf_undo)
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Text_Editor(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Text_Editor self)"""
        return _fltk.Fl_Text_Editor_draw(self, *args)

Fl_Text_Editor_swigregister = _fltk.Fl_Text_Editor_swigregister
Fl_Text_Editor_swigregister(Fl_Text_Editor)

def Fl_Text_Editor_kf_default(*args):
    """Fl_Text_Editor_kf_default(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_default(*args)

def Fl_Text_Editor_kf_ignore(*args):
    """Fl_Text_Editor_kf_ignore(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_ignore(*args)

def Fl_Text_Editor_kf_backspace(*args):
    """Fl_Text_Editor_kf_backspace(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_backspace(*args)

def Fl_Text_Editor_kf_enter(*args):
    """Fl_Text_Editor_kf_enter(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_enter(*args)

def Fl_Text_Editor_kf_move(*args):
    """Fl_Text_Editor_kf_move(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_move(*args)

def Fl_Text_Editor_kf_shift_move(*args):
    """Fl_Text_Editor_kf_shift_move(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_shift_move(*args)

def Fl_Text_Editor_kf_ctrl_move(*args):
    """Fl_Text_Editor_kf_ctrl_move(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_ctrl_move(*args)

def Fl_Text_Editor_kf_c_s_move(*args):
    """Fl_Text_Editor_kf_c_s_move(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_c_s_move(*args)

def Fl_Text_Editor_kf_meta_move(*args):
    """Fl_Text_Editor_kf_meta_move(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_meta_move(*args)

def Fl_Text_Editor_kf_m_s_move(*args):
    """Fl_Text_Editor_kf_m_s_move(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_m_s_move(*args)

def Fl_Text_Editor_kf_home(*args):
    """Fl_Text_Editor_kf_home(int arg2, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_home(*args)

def Fl_Text_Editor_kf_end(*args):
    """Fl_Text_Editor_kf_end(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_end(*args)

def Fl_Text_Editor_kf_left(*args):
    """Fl_Text_Editor_kf_left(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_left(*args)

def Fl_Text_Editor_kf_up(*args):
    """Fl_Text_Editor_kf_up(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_up(*args)

def Fl_Text_Editor_kf_right(*args):
    """Fl_Text_Editor_kf_right(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_right(*args)

def Fl_Text_Editor_kf_down(*args):
    """Fl_Text_Editor_kf_down(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_down(*args)

def Fl_Text_Editor_kf_page_up(*args):
    """Fl_Text_Editor_kf_page_up(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_page_up(*args)

def Fl_Text_Editor_kf_page_down(*args):
    """Fl_Text_Editor_kf_page_down(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_page_down(*args)

def Fl_Text_Editor_kf_insert(*args):
    """Fl_Text_Editor_kf_insert(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_insert(*args)

def Fl_Text_Editor_kf_delete(*args):
    """Fl_Text_Editor_kf_delete(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_delete(*args)

def Fl_Text_Editor_kf_copy(*args):
    """Fl_Text_Editor_kf_copy(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_copy(*args)

def Fl_Text_Editor_kf_cut(*args):
    """Fl_Text_Editor_kf_cut(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_cut(*args)

def Fl_Text_Editor_kf_paste(*args):
    """Fl_Text_Editor_kf_paste(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_paste(*args)

def Fl_Text_Editor_kf_select_all(*args):
    """Fl_Text_Editor_kf_select_all(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_select_all(*args)

def Fl_Text_Editor_kf_undo(*args):
    """Fl_Text_Editor_kf_undo(int c, Fl_Text_Editor e) -> int"""
    return _fltk.Fl_Text_Editor_kf_undo(*args)

class Fl_Tile(Fl_Group):
    """

    The Fl_Tile class lets you resize the children by dragging the border between 
    them:

    Fl_Tile allows objects to be resized to zero dimensions. To prevent this you 
    can use the resizable() to limit where corners can be dragged to.

    Even though objects can be resized to zero sizes, they must initially have 
    non-zero sizes so the Fl_Tile can figure out their layout. If desired, call 
    position() after creating the children but before displaying the window to 
    set the borders where you want.

    The 'borders' are part of the children - Fl_Tile does not draw any graphics 
    of its own. In the example above, all of the children have FL_DOWN_BOX types, 
    and the 'ridges' you see are actually two adjacent FL_DOWN_BOX's drawn next 
    to each other. All neighboring widgets share the same edge - the widget's 
    thick borders make it appear as though the widgets aren't actually touching, 
    but they are. If the edges of adjacent widgets do not touch, then it will be 
    impossible to drag the corresponding edges.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def handle(self, *args):
        """handle(Fl_Tile self, int arg0) -> int"""
        return _fltk.Fl_Tile_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Tile self, int X, int Y, int W, int H, char const * l=None) -> Fl_Tile"""
        if self.__class__ == Fl_Tile:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Tile(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def resize(self, *args):
        """resize(Fl_Tile self, int arg0, int arg1, int arg2, int arg3)"""
        return _fltk.Fl_Tile_resize(self, *args)


    def position(self, *args):
        """position(Fl_Tile self, int arg2, int arg3, int arg4, int arg5)"""
        return _fltk.Fl_Tile_position(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Tile
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Tile(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Tile self)"""
        return _fltk.Fl_Tile_draw(self, *args)

Fl_Tile_swigregister = _fltk.Fl_Tile_swigregister
Fl_Tile_swigregister(Fl_Tile)

class Fl_Tiled_Image(Fl_Image):
    """

    The Fl_Tiled_Image class supports tiling of images over a specified area. 
    The source (tile) image is not copied unless you call the color_average(), 
    desaturate(), or inactive() methods.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Tiled_Image self, Fl_Image i, int W=0, int H=0) -> Fl_Tiled_Image"""
        if self.__class__ == Fl_Tiled_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Tiled_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Tiled_Image
    __del__ = lambda self: None

    def copy(self, *args):
        """
        copy(Fl_Tiled_Image self, int W, int H) -> Fl_Image
        copy(Fl_Tiled_Image self) -> Fl_Image
        """
        return _fltk.Fl_Tiled_Image_copy(self, *args)


    def color_average(self, *args):
        """color_average(Fl_Tiled_Image self, Fl_Color c, float i)"""
        return _fltk.Fl_Tiled_Image_color_average(self, *args)


    def desaturate(self, *args):
        """desaturate(Fl_Tiled_Image self)"""
        return _fltk.Fl_Tiled_Image_desaturate(self, *args)


    def draw(self, *args):
        """
        draw(Fl_Tiled_Image self, int X, int Y, int W, int H, int cx, int cy)
        draw(Fl_Tiled_Image self, int X, int Y)
        """
        return _fltk.Fl_Tiled_Image_draw(self, *args)


    def image(self, *args):
        """image(Fl_Tiled_Image self) -> Fl_Image"""
        return _fltk.Fl_Tiled_Image_image(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Tiled_Image(self)
        return weakref_proxy(self)
Fl_Tiled_Image_swigregister = _fltk.Fl_Tiled_Image_swigregister
Fl_Tiled_Image_swigregister(Fl_Tiled_Image)


_fltk.FL_NORMAL_TIMER_swigconstant(_fltk)
FL_NORMAL_TIMER = _fltk.FL_NORMAL_TIMER

_fltk.FL_VALUE_TIMER_swigconstant(_fltk)
FL_VALUE_TIMER = _fltk.FL_VALUE_TIMER

_fltk.FL_HIDDEN_TIMER_swigconstant(_fltk)
FL_HIDDEN_TIMER = _fltk.FL_HIDDEN_TIMER
class Fl_Timer(Fl_Widget):
    """

    This is provided only to emulate the Forms Timer widget. It works by making 
    a timeout callback every 1/5 second. This is wasteful and inaccurate if you 
    just want something to happen a fixed time in the future. You should directly 
    call Fl::add_timeout() instead.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Timer self)"""
        return _fltk.Fl_Timer_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Timer self, int arg0) -> int"""
        return _fltk.Fl_Timer_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Timer self, uchar t, int x, int y, int w, int h, char const * l) -> Fl_Timer"""
        if self.__class__ == Fl_Timer:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Timer(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Timer
    __del__ = lambda self: None

    def value(self, *args):
        """
        value(Fl_Timer self, double arg2)
        value(Fl_Timer self) -> double
        """
        return _fltk.Fl_Timer_value(self, *args)


    def direction(self, *args):
        """
        direction(Fl_Timer self) -> char
        direction(Fl_Timer self, char d)
        """
        return _fltk.Fl_Timer_direction(self, *args)


    def suspended(self, *args):
        """
        suspended(Fl_Timer self) -> char
        suspended(Fl_Timer self, char d)
        """
        return _fltk.Fl_Timer_suspended(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Timer(self)
        return weakref_proxy(self)
Fl_Timer_swigregister = _fltk.Fl_Timer_swigregister
Fl_Timer_swigregister(Fl_Timer)

class Fl_Toggle_Button(Fl_Button):
    """Proxy of C++ Fl_Toggle_Button class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Toggle_Button self, int X, int Y, int W, int H, char const * l=None) -> Fl_Toggle_Button"""
        if self.__class__ == Fl_Toggle_Button:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Toggle_Button(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Toggle_Button
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Toggle_Button(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Toggle_Button self)"""
        return _fltk.Fl_Toggle_Button_draw(self, *args)

Fl_Toggle_Button_swigregister = _fltk.Fl_Toggle_Button_swigregister
Fl_Toggle_Button_swigregister(Fl_Toggle_Button)

class Fl_Tooltip(object):
    """

    The Fl_Tooltip class provides tooltip support for all FLTK widgets.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def delay(*args):
        """
        delay() -> float
        delay(float f)
        """
        return _fltk.Fl_Tooltip_delay(*args)

    delay = staticmethod(delay)

    def hoverdelay(*args):
        """
        hoverdelay() -> float
        hoverdelay(float f)
        """
        return _fltk.Fl_Tooltip_hoverdelay(*args)

    hoverdelay = staticmethod(hoverdelay)

    def enabled(*args):
        """enabled() -> int"""
        return _fltk.Fl_Tooltip_enabled(*args)

    enabled = staticmethod(enabled)

    def enable(*args):
        """enable(int b=1)"""
        return _fltk.Fl_Tooltip_enable(*args)

    enable = staticmethod(enable)

    def disable(*args):
        """disable()"""
        return _fltk.Fl_Tooltip_disable(*args)

    disable = staticmethod(disable)

    def enter_area(*args):
        """enter_area(Fl_Widget w, int X, int Y, int W, int H, char const * tip)"""
        return _fltk.Fl_Tooltip_enter_area(*args)

    enter_area = staticmethod(enter_area)

    def current(*args):
        """
        current() -> Fl_Widget
        current(Fl_Widget arg1)
        """
        return _fltk.Fl_Tooltip_current(*args)

    current = staticmethod(current)

    def font(*args):
        """
        font() -> Fl_Font
        font(Fl_Font i)
        """
        return _fltk.Fl_Tooltip_font(*args)

    font = staticmethod(font)

    def size(*args):
        """
        size() -> Fl_Fontsize
        size(Fl_Fontsize s)
        """
        return _fltk.Fl_Tooltip_size(*args)

    size = staticmethod(size)

    def color(*args):
        """
        color() -> Fl_Color
        color(Fl_Color c)
        """
        return _fltk.Fl_Tooltip_color(*args)

    color = staticmethod(color)

    def textcolor(*args):
        """
        textcolor() -> Fl_Color
        textcolor(Fl_Color c)
        """
        return _fltk.Fl_Tooltip_textcolor(*args)

    textcolor = staticmethod(textcolor)

    def margin_width(*args):
        """margin_width() -> int"""
        return _fltk.Fl_Tooltip_margin_width(*args)

    margin_width = staticmethod(margin_width)

    def margin_height(*args):
        """margin_height() -> int"""
        return _fltk.Fl_Tooltip_margin_height(*args)

    margin_height = staticmethod(margin_height)

    def wrap_width(*args):
        """wrap_width() -> int"""
        return _fltk.Fl_Tooltip_wrap_width(*args)

    wrap_width = staticmethod(wrap_width)

    def __init__(self, *args):
        """__init__(Fl_Tooltip self) -> Fl_Tooltip"""
        this = _fltk.new_Fl_Tooltip(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_Tooltip
    __del__ = lambda self: None
Fl_Tooltip_swigregister = _fltk.Fl_Tooltip_swigregister
Fl_Tooltip_swigregister(Fl_Tooltip)

def Fl_Tooltip_delay(*args):
    """
    delay() -> float
    Fl_Tooltip_delay(float f)
    """
    return _fltk.Fl_Tooltip_delay(*args)

def Fl_Tooltip_hoverdelay(*args):
    """
    hoverdelay() -> float
    Fl_Tooltip_hoverdelay(float f)
    """
    return _fltk.Fl_Tooltip_hoverdelay(*args)

def Fl_Tooltip_enabled(*args):
    """Fl_Tooltip_enabled() -> int"""
    return _fltk.Fl_Tooltip_enabled(*args)

def Fl_Tooltip_enable(*args):
    """Fl_Tooltip_enable(int b=1)"""
    return _fltk.Fl_Tooltip_enable(*args)

def Fl_Tooltip_disable(*args):
    """Fl_Tooltip_disable()"""
    return _fltk.Fl_Tooltip_disable(*args)

def Fl_Tooltip_enter_area(*args):
    """Fl_Tooltip_enter_area(Fl_Widget w, int X, int Y, int W, int H, char const * tip)"""
    return _fltk.Fl_Tooltip_enter_area(*args)

def Fl_Tooltip_current(*args):
    """
    current() -> Fl_Widget
    Fl_Tooltip_current(Fl_Widget arg2)
    """
    return _fltk.Fl_Tooltip_current(*args)

def Fl_Tooltip_font(*args):
    """
    font() -> Fl_Font
    Fl_Tooltip_font(Fl_Font i)
    """
    return _fltk.Fl_Tooltip_font(*args)

def Fl_Tooltip_size(*args):
    """
    size() -> Fl_Fontsize
    Fl_Tooltip_size(Fl_Fontsize s)
    """
    return _fltk.Fl_Tooltip_size(*args)

def Fl_Tooltip_color(*args):
    """
    color() -> Fl_Color
    Fl_Tooltip_color(Fl_Color c)
    """
    return _fltk.Fl_Tooltip_color(*args)

def Fl_Tooltip_textcolor(*args):
    """
    textcolor() -> Fl_Color
    Fl_Tooltip_textcolor(Fl_Color c)
    """
    return _fltk.Fl_Tooltip_textcolor(*args)

def Fl_Tooltip_margin_width(*args):
    """Fl_Tooltip_margin_width() -> int"""
    return _fltk.Fl_Tooltip_margin_width(*args)

def Fl_Tooltip_margin_height(*args):
    """Fl_Tooltip_margin_height() -> int"""
    return _fltk.Fl_Tooltip_margin_height(*args)

def Fl_Tooltip_wrap_width(*args):
    """Fl_Tooltip_wrap_width() -> int"""
    return _fltk.Fl_Tooltip_wrap_width(*args)

class Fl_Value_Output(Fl_Valuator):
    """

    The Fl_Value_Output widget displays a floating point value. If step() is 
    not zero, the user can adjust the value by dragging the mouse left and right. 
    The left button moves one step()  per pixel, the middle by 10 * step(), and 
    the right button by 100 * step().

    This is much lighter-weight than Fl_Value_Input because it contains no text 
    editing code or character buffer. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def draw(self, *args):
        """draw(Fl_Value_Output self)"""
        return _fltk.Fl_Value_Output_draw(self, *args)


    def handle(self, *args):
        """handle(Fl_Value_Output self, int arg0) -> int"""
        return _fltk.Fl_Value_Output_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Value_Output self, int x, int y, int w, int h, char const * l=None) -> Fl_Value_Output"""
        if self.__class__ == Fl_Value_Output:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Value_Output(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def soft(self, *args):
        """
        soft(Fl_Value_Output self, uchar s)
        soft(Fl_Value_Output self) -> uchar
        """
        return _fltk.Fl_Value_Output_soft(self, *args)


    def textfont(self, *args):
        """
        textfont(Fl_Value_Output self) -> Fl_Font
        textfont(Fl_Value_Output self, Fl_Font s)
        """
        return _fltk.Fl_Value_Output_textfont(self, *args)


    def textsize(self, *args):
        """
        textsize(Fl_Value_Output self) -> Fl_Fontsize
        textsize(Fl_Value_Output self, Fl_Fontsize s)
        """
        return _fltk.Fl_Value_Output_textsize(self, *args)


    def textcolor(self, *args):
        """
        textcolor(Fl_Value_Output self) -> Fl_Color
        textcolor(Fl_Value_Output self, Fl_Color s)
        """
        return _fltk.Fl_Value_Output_textcolor(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Value_Output
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Value_Output(self)
        return weakref_proxy(self)
Fl_Value_Output_swigregister = _fltk.Fl_Value_Output_swigregister
Fl_Value_Output_swigregister(Fl_Value_Output)

class Fl_Wizard(Fl_Group):
    """

    The Fl_Wizard widget is based off the Fl_Tabs widget, but instead of 
    displaying tabs it only changes 'tabs' under program control. Its primary 
    purpose is to support 'wizards' that step a user through configuration or 
    troubleshooting tasks.

    As with Fl_Tabs, wizard panes are composed of child (usually Fl_Group) 
    widgets. Navigation buttons must be added separately. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Wizard self, int arg2, int arg3, int arg4, int arg5, char const * arg6=None) -> Fl_Wizard"""
        if self.__class__ == Fl_Wizard:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Wizard(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def next(self, *args):
        """next(Fl_Wizard self)"""
        return _fltk.Fl_Wizard_next(self, *args)


    def prev(self, *args):
        """prev(Fl_Wizard self)"""
        return _fltk.Fl_Wizard_prev(self, *args)


    def value(self, *args):
        """
        value(Fl_Wizard self) -> Fl_Widget
        value(Fl_Wizard self, Fl_Widget arg2)
        """
        return _fltk.Fl_Wizard_value(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Wizard
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Wizard(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(Fl_Wizard self)"""
        return _fltk.Fl_Wizard_draw(self, *args)

Fl_Wizard_swigregister = _fltk.Fl_Wizard_swigregister
Fl_Wizard_swigregister(Fl_Wizard)

class Fl_XBM_Image(Fl_Bitmap):
    """

    The Fl_XBM_Image class supports loading, caching, and drawing of X Bitmap 
    (XBM) bitmap files.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_XBM_Image self, char const * filename) -> Fl_XBM_Image"""
        if self.__class__ == Fl_XBM_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_XBM_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_XBM_Image
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_XBM_Image(self)
        return weakref_proxy(self)
Fl_XBM_Image_swigregister = _fltk.Fl_XBM_Image_swigregister
Fl_XBM_Image_swigregister(Fl_XBM_Image)

class Fl_XPM_Image(Fl_Pixmap):
    """

    The Fl_XPM_Image class supports loading, caching, and drawing of X Pixmap (XPM) images, including transparency.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_XPM_Image self, char const * filename) -> Fl_XPM_Image"""
        if self.__class__ == Fl_XPM_Image:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_XPM_Image(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _fltk.delete_Fl_XPM_Image
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_XPM_Image(self)
        return weakref_proxy(self)
Fl_XPM_Image_swigregister = _fltk.Fl_XPM_Image_swigregister
Fl_XPM_Image_swigregister(Fl_XPM_Image)


_fltk.FL_TREE_SORT_NONE_swigconstant(_fltk)
FL_TREE_SORT_NONE = _fltk.FL_TREE_SORT_NONE

_fltk.FL_TREE_SORT_ASCENDING_swigconstant(_fltk)
FL_TREE_SORT_ASCENDING = _fltk.FL_TREE_SORT_ASCENDING

_fltk.FL_TREE_SORT_DESCENDING_swigconstant(_fltk)
FL_TREE_SORT_DESCENDING = _fltk.FL_TREE_SORT_DESCENDING

_fltk.FL_TREE_CONNECTOR_NONE_swigconstant(_fltk)
FL_TREE_CONNECTOR_NONE = _fltk.FL_TREE_CONNECTOR_NONE

_fltk.FL_TREE_CONNECTOR_DOTTED_swigconstant(_fltk)
FL_TREE_CONNECTOR_DOTTED = _fltk.FL_TREE_CONNECTOR_DOTTED

_fltk.FL_TREE_CONNECTOR_SOLID_swigconstant(_fltk)
FL_TREE_CONNECTOR_SOLID = _fltk.FL_TREE_CONNECTOR_SOLID

_fltk.FL_TREE_SELECT_NONE_swigconstant(_fltk)
FL_TREE_SELECT_NONE = _fltk.FL_TREE_SELECT_NONE

_fltk.FL_TREE_SELECT_SINGLE_swigconstant(_fltk)
FL_TREE_SELECT_SINGLE = _fltk.FL_TREE_SELECT_SINGLE

_fltk.FL_TREE_SELECT_MULTI_swigconstant(_fltk)
FL_TREE_SELECT_MULTI = _fltk.FL_TREE_SELECT_MULTI

_fltk.FL_TREE_SELECT_SINGLE_DRAGGABLE_swigconstant(_fltk)
FL_TREE_SELECT_SINGLE_DRAGGABLE = _fltk.FL_TREE_SELECT_SINGLE_DRAGGABLE
class Fl_Tree_Prefs(object):
    """Proxy of C++ Fl_Tree_Prefs class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Tree_Prefs self) -> Fl_Tree_Prefs"""
        this = _fltk.new_Fl_Tree_Prefs(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def item_labelfont(self, *args):
        """
        item_labelfont(Fl_Tree_Prefs self) -> Fl_Font
        item_labelfont(Fl_Tree_Prefs self, Fl_Font val)
        """
        return _fltk.Fl_Tree_Prefs_item_labelfont(self, *args)


    def item_labelsize(self, *args):
        """
        item_labelsize(Fl_Tree_Prefs self) -> Fl_Fontsize
        item_labelsize(Fl_Tree_Prefs self, Fl_Fontsize val)
        """
        return _fltk.Fl_Tree_Prefs_item_labelsize(self, *args)


    def item_labelfgcolor(self, *args):
        """
        item_labelfgcolor(Fl_Tree_Prefs self) -> Fl_Color
        item_labelfgcolor(Fl_Tree_Prefs self, Fl_Color val)
        """
        return _fltk.Fl_Tree_Prefs_item_labelfgcolor(self, *args)


    def item_labelbgcolor(self, *args):
        """
        item_labelbgcolor(Fl_Tree_Prefs self) -> Fl_Color
        item_labelbgcolor(Fl_Tree_Prefs self, Fl_Color val)
        """
        return _fltk.Fl_Tree_Prefs_item_labelbgcolor(self, *args)


    def labelfont(self, *args):
        """
        labelfont(Fl_Tree_Prefs self) -> Fl_Font
        labelfont(Fl_Tree_Prefs self, Fl_Font val)
        """
        return _fltk.Fl_Tree_Prefs_labelfont(self, *args)


    def labelsize(self, *args):
        """
        labelsize(Fl_Tree_Prefs self) -> Fl_Fontsize
        labelsize(Fl_Tree_Prefs self, Fl_Fontsize val)
        """
        return _fltk.Fl_Tree_Prefs_labelsize(self, *args)


    def labelfgcolor(self, *args):
        """
        labelfgcolor(Fl_Tree_Prefs self) -> Fl_Color
        labelfgcolor(Fl_Tree_Prefs self, Fl_Color val)
        """
        return _fltk.Fl_Tree_Prefs_labelfgcolor(self, *args)


    def labelbgcolor(self, *args):
        """
        labelbgcolor(Fl_Tree_Prefs self) -> Fl_Color
        labelbgcolor(Fl_Tree_Prefs self, Fl_Color val)
        """
        return _fltk.Fl_Tree_Prefs_labelbgcolor(self, *args)


    def marginleft(self, *args):
        """
        marginleft(Fl_Tree_Prefs self) -> int
        marginleft(Fl_Tree_Prefs self, int val)
        """
        return _fltk.Fl_Tree_Prefs_marginleft(self, *args)


    def margintop(self, *args):
        """
        margintop(Fl_Tree_Prefs self) -> int
        margintop(Fl_Tree_Prefs self, int val)
        """
        return _fltk.Fl_Tree_Prefs_margintop(self, *args)


    def openchild_marginbottom(self, *args):
        """
        openchild_marginbottom(Fl_Tree_Prefs self) -> int
        openchild_marginbottom(Fl_Tree_Prefs self, int val)
        """
        return _fltk.Fl_Tree_Prefs_openchild_marginbottom(self, *args)


    def usericonmarginleft(self, *args):
        """
        usericonmarginleft(Fl_Tree_Prefs self) -> int
        usericonmarginleft(Fl_Tree_Prefs self, int val)
        """
        return _fltk.Fl_Tree_Prefs_usericonmarginleft(self, *args)


    def labelmarginleft(self, *args):
        """
        labelmarginleft(Fl_Tree_Prefs self) -> int
        labelmarginleft(Fl_Tree_Prefs self, int val)
        """
        return _fltk.Fl_Tree_Prefs_labelmarginleft(self, *args)


    def linespacing(self, *args):
        """
        linespacing(Fl_Tree_Prefs self) -> int
        linespacing(Fl_Tree_Prefs self, int val)
        """
        return _fltk.Fl_Tree_Prefs_linespacing(self, *args)


    def connectorcolor(self, *args):
        """
        connectorcolor(Fl_Tree_Prefs self) -> Fl_Color
        connectorcolor(Fl_Tree_Prefs self, Fl_Color val)
        """
        return _fltk.Fl_Tree_Prefs_connectorcolor(self, *args)


    def connectorstyle(self, *args):
        """
        connectorstyle(Fl_Tree_Prefs self) -> Fl_Tree_Connector
        connectorstyle(Fl_Tree_Prefs self, Fl_Tree_Connector val)
        connectorstyle(Fl_Tree_Prefs self, int val)
        """
        return _fltk.Fl_Tree_Prefs_connectorstyle(self, *args)


    def connectorwidth(self, *args):
        """
        connectorwidth(Fl_Tree_Prefs self) -> int
        connectorwidth(Fl_Tree_Prefs self, int val)
        """
        return _fltk.Fl_Tree_Prefs_connectorwidth(self, *args)


    def openicon(self, *args):
        """
        openicon(Fl_Tree_Prefs self) -> Fl_Image
        openicon(Fl_Tree_Prefs self, Fl_Image val)
        """
        return _fltk.Fl_Tree_Prefs_openicon(self, *args)


    def closeicon(self, *args):
        """
        closeicon(Fl_Tree_Prefs self) -> Fl_Image
        closeicon(Fl_Tree_Prefs self, Fl_Image val)
        """
        return _fltk.Fl_Tree_Prefs_closeicon(self, *args)


    def usericon(self, *args):
        """
        usericon(Fl_Tree_Prefs self) -> Fl_Image
        usericon(Fl_Tree_Prefs self, Fl_Image val)
        """
        return _fltk.Fl_Tree_Prefs_usericon(self, *args)


    def showcollapse(self, *args):
        """
        showcollapse(Fl_Tree_Prefs self) -> char
        showcollapse(Fl_Tree_Prefs self, int val)
        """
        return _fltk.Fl_Tree_Prefs_showcollapse(self, *args)


    def sortorder(self, *args):
        """
        sortorder(Fl_Tree_Prefs self) -> Fl_Tree_Sort
        sortorder(Fl_Tree_Prefs self, Fl_Tree_Sort val)
        """
        return _fltk.Fl_Tree_Prefs_sortorder(self, *args)


    def selectbox(self, *args):
        """
        selectbox(Fl_Tree_Prefs self) -> Fl_Boxtype
        selectbox(Fl_Tree_Prefs self, Fl_Boxtype val)
        """
        return _fltk.Fl_Tree_Prefs_selectbox(self, *args)


    def showroot(self, *args):
        """
        showroot(Fl_Tree_Prefs self) -> int
        showroot(Fl_Tree_Prefs self, int val)
        """
        return _fltk.Fl_Tree_Prefs_showroot(self, *args)


    def selectmode(self, *args):
        """
        selectmode(Fl_Tree_Prefs self) -> Fl_Tree_Select
        selectmode(Fl_Tree_Prefs self, Fl_Tree_Select val)
        """
        return _fltk.Fl_Tree_Prefs_selectmode(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Tree_Prefs
    __del__ = lambda self: None
Fl_Tree_Prefs_swigregister = _fltk.Fl_Tree_Prefs_swigregister
Fl_Tree_Prefs_swigregister(Fl_Tree_Prefs)

class Fl_Tree_Item_Array(object):
    """

    Because FLTK 1.x.x. has mandated that templates and STL not be used, we use this class to dynamically manage the arrays.
    None of the methods do range checking on index values; the caller must be sure that index values are within the range 0<index<total() (unless otherwise noted).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fltk.delete_Fl_Tree_Item_Array
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Fl_Tree_Item_Array self, int new_chunksize=10) -> Fl_Tree_Item_Array
        __init__(Fl_Tree_Item_Array self, Fl_Tree_Item_Array o) -> Fl_Tree_Item_Array
        """
        this = _fltk.new_Fl_Tree_Item_Array(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def total(self, *args):
        """total(Fl_Tree_Item_Array self) -> int"""
        return _fltk.Fl_Tree_Item_Array_total(self, *args)


    def swap(self, *args):
        """swap(Fl_Tree_Item_Array self, int ax, int bx)"""
        return _fltk.Fl_Tree_Item_Array_swap(self, *args)


    def move(self, *args):
        """move(Fl_Tree_Item_Array self, int to, int arg3) -> int"""
        return _fltk.Fl_Tree_Item_Array_move(self, *args)


    def deparent(self, *args):
        """deparent(Fl_Tree_Item_Array self, int pos) -> int"""
        return _fltk.Fl_Tree_Item_Array_deparent(self, *args)


    def reparent(self, *args):
        """reparent(Fl_Tree_Item_Array self, Fl_Tree_Item item, Fl_Tree_Item newparent, int pos) -> int"""
        return _fltk.Fl_Tree_Item_Array_reparent(self, *args)


    def clear(self, *args):
        """clear(Fl_Tree_Item_Array self)"""
        return _fltk.Fl_Tree_Item_Array_clear(self, *args)


    def add(self, *args):
        """add(Fl_Tree_Item_Array self, Fl_Tree_Item val)"""
        return _fltk.Fl_Tree_Item_Array_add(self, *args)


    def insert(self, *args):
        """insert(Fl_Tree_Item_Array self, int pos, Fl_Tree_Item new_item)"""
        return _fltk.Fl_Tree_Item_Array_insert(self, *args)


    def replace(self, *args):
        """replace(Fl_Tree_Item_Array self, int pos, Fl_Tree_Item new_item)"""
        return _fltk.Fl_Tree_Item_Array_replace(self, *args)


    def remove(self, *args):
        """
        remove(Fl_Tree_Item_Array self, int index)
        remove(Fl_Tree_Item_Array self, Fl_Tree_Item item) -> int
        """
        return _fltk.Fl_Tree_Item_Array_remove(self, *args)

Fl_Tree_Item_Array_swigregister = _fltk.Fl_Tree_Item_Array_swigregister
Fl_Tree_Item_Array_swigregister(Fl_Tree_Item_Array)

class Fl_Tree_Item(object):
    """

    This class is a single tree item, and manages all of the item's attributes. Fl_Tree_Item is used by Fl_Tree, which is comprised of many instances of Fl_Tree_Item.
    Fl_Tree_Item is hierarchical; it dynamically manages an Fl_Tree_Item_Array of children that are themselves instances of Fl_Tree_Item. Each item can have zero or more children. When an item has children, close() and open() can be used to hide or show them. Items have their own attributes; font size, face, color. Items maintain their own hierarchy of children. When you make changes to items, you'll need to tell the tree to redraw() for the changes to show up.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fltk.delete_Fl_Tree_Item
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item
        __init__(Fl_Tree_Item self, Fl_Tree_Item o) -> Fl_Tree_Item
        """
        this = _fltk.new_Fl_Tree_Item(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def x(self, *args):
        """x(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_x(self, *args)


    def y(self, *args):
        """y(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_y(self, *args)


    def w(self, *args):
        """w(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_w(self, *args)


    def h(self, *args):
        """h(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_h(self, *args)


    def label_x(self, *args):
        """label_x(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_label_x(self, *args)


    def label_y(self, *args):
        """label_y(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_label_y(self, *args)


    def label_w(self, *args):
        """label_w(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_label_w(self, *args)


    def label_h(self, *args):
        """label_h(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_label_h(self, *args)


    def draw(self, *args):
        """draw(Fl_Tree_Item self, int X, int W, Fl_Widget tree, Fl_Tree_Item itemfocus, Fl_Tree_Prefs prefs, int lastchild=1)"""
        return _fltk.Fl_Tree_Item_draw(self, *args)


    def show_self(self, *args):
        """show_self(Fl_Tree_Item self, char const * indent)"""
        return _fltk.Fl_Tree_Item_show_self(self, *args)


    def label(self, *args):
        """
        label(Fl_Tree_Item self, char const * val)
        label(Fl_Tree_Item self) -> char const *
        """
        return _fltk.Fl_Tree_Item_label(self, *args)


    def user_data(self, *args):
        """
        user_data(Fl_Tree_Item self, void * data)
        user_data(Fl_Tree_Item self) -> void *
        """
        return _fltk.Fl_Tree_Item_user_data(self, *args)


    def labelfont(self, *args):
        """
        labelfont(Fl_Tree_Item self, Fl_Font val)
        labelfont(Fl_Tree_Item self) -> Fl_Font
        """
        return _fltk.Fl_Tree_Item_labelfont(self, *args)


    def labelsize(self, *args):
        """
        labelsize(Fl_Tree_Item self, Fl_Fontsize val)
        labelsize(Fl_Tree_Item self) -> Fl_Fontsize
        """
        return _fltk.Fl_Tree_Item_labelsize(self, *args)


    def labelfgcolor(self, *args):
        """
        labelfgcolor(Fl_Tree_Item self, Fl_Color val)
        labelfgcolor(Fl_Tree_Item self) -> Fl_Color
        """
        return _fltk.Fl_Tree_Item_labelfgcolor(self, *args)


    def labelcolor(self, *args):
        """
        labelcolor(Fl_Tree_Item self, Fl_Color val)
        labelcolor(Fl_Tree_Item self) -> Fl_Color
        """
        return _fltk.Fl_Tree_Item_labelcolor(self, *args)


    def labelbgcolor(self, *args):
        """
        labelbgcolor(Fl_Tree_Item self, Fl_Color val)
        labelbgcolor(Fl_Tree_Item self) -> Fl_Color
        """
        return _fltk.Fl_Tree_Item_labelbgcolor(self, *args)


    def widget(self, *args):
        """
        widget(Fl_Tree_Item self, Fl_Widget val)
        widget(Fl_Tree_Item self) -> Fl_Widget
        """
        return _fltk.Fl_Tree_Item_widget(self, *args)


    def children(self, *args):
        """children(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_children(self, *args)


    def child(self, *args):
        """
        child(Fl_Tree_Item self, int index) -> Fl_Tree_Item
        child(Fl_Tree_Item self, int t) -> Fl_Tree_Item
        """
        return _fltk.Fl_Tree_Item_child(self, *args)


    def has_children(self, *args):
        """has_children(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_has_children(self, *args)


    def find_child(self, *args):
        """
        find_child(Fl_Tree_Item self, char const * name) -> int
        find_child(Fl_Tree_Item self, Fl_Tree_Item item) -> int
        """
        return _fltk.Fl_Tree_Item_find_child(self, *args)


    def remove_child(self, *args):
        """
        remove_child(Fl_Tree_Item self, Fl_Tree_Item item) -> int
        remove_child(Fl_Tree_Item self, char const * new_label) -> int
        """
        return _fltk.Fl_Tree_Item_remove_child(self, *args)


    def clear_children(self, *args):
        """clear_children(Fl_Tree_Item self)"""
        return _fltk.Fl_Tree_Item_clear_children(self, *args)


    def swap_children(self, *args):
        """
        swap_children(Fl_Tree_Item self, int ax, int bx)
        swap_children(Fl_Tree_Item self, Fl_Tree_Item a, Fl_Tree_Item b) -> int
        """
        return _fltk.Fl_Tree_Item_swap_children(self, *args)


    def find_child_item(self, *args):
        """
        find_child_item(Fl_Tree_Item self, char const * name) -> Fl_Tree_Item
        find_child_item(Fl_Tree_Item self, char const * name) -> Fl_Tree_Item
        find_child_item(Fl_Tree_Item self, char ** arr) -> Fl_Tree_Item
        find_child_item(Fl_Tree_Item self, char ** arr) -> Fl_Tree_Item
        """
        return _fltk.Fl_Tree_Item_find_child_item(self, *args)


    def find_item(self, *args):
        """
        find_item(Fl_Tree_Item self, char ** arr) -> Fl_Tree_Item
        find_item(Fl_Tree_Item self, char ** arr) -> Fl_Tree_Item
        """
        return _fltk.Fl_Tree_Item_find_item(self, *args)


    def add(self, *args):
        """
        add(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char const * new_label, Fl_Tree_Item newitem) -> Fl_Tree_Item
        add(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char const * new_label) -> Fl_Tree_Item
        add(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char ** arr, Fl_Tree_Item newitem) -> Fl_Tree_Item
        add(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char ** arr) -> Fl_Tree_Item
        """
        return _fltk.Fl_Tree_Item_add(self, *args)


    def insert(self, *args):
        """insert(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char const * new_label, int pos=0) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_insert(self, *args)


    def insert_above(self, *args):
        """insert_above(Fl_Tree_Item self, Fl_Tree_Prefs prefs, char const * new_label) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_insert_above(self, *args)


    def deparent(self, *args):
        """deparent(Fl_Tree_Item self, int index) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_deparent(self, *args)


    def reparent(self, *args):
        """reparent(Fl_Tree_Item self, Fl_Tree_Item newchild, int index) -> int"""
        return _fltk.Fl_Tree_Item_reparent(self, *args)


    def move(self, *args):
        """
        move(Fl_Tree_Item self, int to, int arg3) -> int
        move(Fl_Tree_Item self, Fl_Tree_Item item, int op=0, int pos=0) -> int
        """
        return _fltk.Fl_Tree_Item_move(self, *args)


    def move_above(self, *args):
        """move_above(Fl_Tree_Item self, Fl_Tree_Item item) -> int"""
        return _fltk.Fl_Tree_Item_move_above(self, *args)


    def move_below(self, *args):
        """move_below(Fl_Tree_Item self, Fl_Tree_Item item) -> int"""
        return _fltk.Fl_Tree_Item_move_below(self, *args)


    def move_into(self, *args):
        """move_into(Fl_Tree_Item self, Fl_Tree_Item item, int pos=0) -> int"""
        return _fltk.Fl_Tree_Item_move_into(self, *args)


    def depth(self, *args):
        """depth(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_depth(self, *args)


    def prev(self, *args):
        """prev(Fl_Tree_Item self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_prev(self, *args)


    def next(self, *args):
        """next(Fl_Tree_Item self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_next(self, *args)


    def next_sibling(self, *args):
        """next_sibling(Fl_Tree_Item self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_next_sibling(self, *args)


    def prev_sibling(self, *args):
        """prev_sibling(Fl_Tree_Item self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_prev_sibling(self, *args)


    def update_prev_next(self, *args):
        """update_prev_next(Fl_Tree_Item self, int index)"""
        return _fltk.Fl_Tree_Item_update_prev_next(self, *args)


    def next_displayed(self, *args):
        """next_displayed(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_next_displayed(self, *args)


    def prev_displayed(self, *args):
        """prev_displayed(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_prev_displayed(self, *args)


    def next_visible(self, *args):
        """next_visible(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_next_visible(self, *args)


    def prev_visible(self, *args):
        """prev_visible(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_Item_prev_visible(self, *args)


    def parent(self, *args):
        """
        parent(Fl_Tree_Item self) -> Fl_Tree_Item
        parent(Fl_Tree_Item self) -> Fl_Tree_Item
        parent(Fl_Tree_Item self, Fl_Tree_Item val)
        """
        return _fltk.Fl_Tree_Item_parent(self, *args)


    def open(self, *args):
        """open(Fl_Tree_Item self)"""
        return _fltk.Fl_Tree_Item_open(self, *args)


    def close(self, *args):
        """close(Fl_Tree_Item self)"""
        return _fltk.Fl_Tree_Item_close(self, *args)


    def is_open(self, *args):
        """is_open(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_is_open(self, *args)


    def is_close(self, *args):
        """is_close(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_is_close(self, *args)


    def open_toggle(self, *args):
        """open_toggle(Fl_Tree_Item self)"""
        return _fltk.Fl_Tree_Item_open_toggle(self, *args)


    def select(self, *args):
        """select(Fl_Tree_Item self, int val=1)"""
        return _fltk.Fl_Tree_Item_select(self, *args)


    def select_toggle(self, *args):
        """select_toggle(Fl_Tree_Item self)"""
        return _fltk.Fl_Tree_Item_select_toggle(self, *args)


    def select_all(self, *args):
        """select_all(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_select_all(self, *args)


    def deselect(self, *args):
        """deselect(Fl_Tree_Item self)"""
        return _fltk.Fl_Tree_Item_deselect(self, *args)


    def deselect_all(self, *args):
        """deselect_all(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_deselect_all(self, *args)


    def is_selected(self, *args):
        """is_selected(Fl_Tree_Item self) -> char"""
        return _fltk.Fl_Tree_Item_is_selected(self, *args)


    def activate(self, *args):
        """activate(Fl_Tree_Item self, int val=1)"""
        return _fltk.Fl_Tree_Item_activate(self, *args)


    def deactivate(self, *args):
        """deactivate(Fl_Tree_Item self)"""
        return _fltk.Fl_Tree_Item_deactivate(self, *args)


    def is_activated(self, *args):
        """is_activated(Fl_Tree_Item self) -> char"""
        return _fltk.Fl_Tree_Item_is_activated(self, *args)


    def is_active(self, *args):
        """is_active(Fl_Tree_Item self) -> char"""
        return _fltk.Fl_Tree_Item_is_active(self, *args)


    def visible(self, *args):
        """visible(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_visible(self, *args)


    def is_visible(self, *args):
        """is_visible(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_is_visible(self, *args)


    def visible_r(self, *args):
        """visible_r(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_visible_r(self, *args)


    def usericon(self, *args):
        """
        usericon(Fl_Tree_Item self, Fl_Image val)
        usericon(Fl_Tree_Item self) -> Fl_Image
        """
        return _fltk.Fl_Tree_Item_usericon(self, *args)


    def find_clicked(self, *args):
        """
        find_clicked(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item
        find_clicked(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> Fl_Tree_Item
        """
        return _fltk.Fl_Tree_Item_find_clicked(self, *args)


    def event_on_collapse_icon(self, *args):
        """event_on_collapse_icon(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> int"""
        return _fltk.Fl_Tree_Item_event_on_collapse_icon(self, *args)


    def event_on_label(self, *args):
        """event_on_label(Fl_Tree_Item self, Fl_Tree_Prefs prefs) -> int"""
        return _fltk.Fl_Tree_Item_event_on_label(self, *args)


    def is_root(self, *args):
        """is_root(Fl_Tree_Item self) -> int"""
        return _fltk.Fl_Tree_Item_is_root(self, *args)

Fl_Tree_Item_swigregister = _fltk.Fl_Tree_Item_swigregister
Fl_Tree_Item_swigregister(Fl_Tree_Item)


_fltk.FL_TREE_REASON_NONE_swigconstant(_fltk)
FL_TREE_REASON_NONE = _fltk.FL_TREE_REASON_NONE

_fltk.FL_TREE_REASON_SELECTED_swigconstant(_fltk)
FL_TREE_REASON_SELECTED = _fltk.FL_TREE_REASON_SELECTED

_fltk.FL_TREE_REASON_DESELECTED_swigconstant(_fltk)
FL_TREE_REASON_DESELECTED = _fltk.FL_TREE_REASON_DESELECTED

_fltk.FL_TREE_REASON_OPENED_swigconstant(_fltk)
FL_TREE_REASON_OPENED = _fltk.FL_TREE_REASON_OPENED

_fltk.FL_TREE_REASON_CLOSED_swigconstant(_fltk)
FL_TREE_REASON_CLOSED = _fltk.FL_TREE_REASON_CLOSED

_fltk.FL_TREE_REASON_DRAGGED_swigconstant(_fltk)
FL_TREE_REASON_DRAGGED = _fltk.FL_TREE_REASON_DRAGGED
class Fl_Tree(Fl_Group):
    """

    An expandable tree widget. Similar to Fl_Browser, Fl_Tree is browser of Fl_Tree_Item's, which can be in a parented hierarchy. Subtrees can be expanded or closed. Items can be added, deleted, inserted, sorted and re-ordered. The tree items may also contain other FLTK widgets, like buttons, input fields, or even 'custom' widgets.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(Fl_Tree self, int X, int Y, int W, int H, char const * L=None) -> Fl_Tree"""
        if self.__class__ == Fl_Tree:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Tree(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Tree
    __del__ = lambda self: None

    def handle(self, *args):
        """handle(Fl_Tree self, int e) -> int"""
        return _fltk.Fl_Tree_handle(self, *args)


    def draw(self, *args):
        """draw(Fl_Tree self)"""
        return _fltk.Fl_Tree_draw(self, *args)


    def show_self(self, *args):
        """show_self(Fl_Tree self)"""
        return _fltk.Fl_Tree_show_self(self, *args)


    def resize(self, *args):
        """resize(Fl_Tree self, int arg0, int arg1, int arg2, int arg3)"""
        return _fltk.Fl_Tree_resize(self, *args)


    def root_label(self, *args):
        """root_label(Fl_Tree self, char const * new_label)"""
        return _fltk.Fl_Tree_root_label(self, *args)


    def root(self, *args):
        """
        root(Fl_Tree self) -> Fl_Tree_Item
        root(Fl_Tree self, Fl_Tree_Item newitem)
        """
        return _fltk.Fl_Tree_root(self, *args)


    def prefs(self, *args):
        """prefs(Fl_Tree self) -> Fl_Tree_Prefs"""
        return _fltk.Fl_Tree_prefs(self, *args)


    def add(self, *args):
        """
        add(Fl_Tree self, char const * path) -> Fl_Tree_Item
        add(Fl_Tree self, char const * path, Fl_Tree_Item newitem) -> Fl_Tree_Item
        add(Fl_Tree self, Fl_Tree_Item parent_item, char const * name) -> Fl_Tree_Item
        """
        val = _fltk.Fl_Tree_add(self, *args)

        #self = args[0]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()
        else:                       
        #give ownership back to Python
            self.this.own() 


        return val


    def insert_above(self, *args):
        """insert_above(Fl_Tree self, Fl_Tree_Item above, char const * name) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_insert_above(self, *args)


    def insert(self, *args):
        """insert(Fl_Tree self, Fl_Tree_Item item, char const * name, int pos) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_insert(self, *args)


    def remove(self, *args):
        """remove(Fl_Tree self, Fl_Tree_Item item) -> int"""
        val = _fltk.Fl_Tree_remove(self, *args)

        #self = args[0]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()
        else:                       
        #give ownership back to Python
            self.this.own() 


        return val


    def clear(self, *args):
        """clear(Fl_Tree self)"""
        return _fltk.Fl_Tree_clear(self, *args)


    def clear_children(self, *args):
        """clear_children(Fl_Tree self, Fl_Tree_Item item)"""
        return _fltk.Fl_Tree_clear_children(self, *args)


    def find_item(self, *args):
        """
        find_item(Fl_Tree self, char const * path) -> Fl_Tree_Item
        find_item(Fl_Tree self, char const * path) -> Fl_Tree_Item
        """
        return _fltk.Fl_Tree_find_item(self, *args)


    def item_pathname(self, *args):
        """item_pathname(Fl_Tree self, char * pathname, int pathnamelen, Fl_Tree_Item item) -> int"""
        return _fltk.Fl_Tree_item_pathname(self, *args)


    def find_clicked(self, *args):
        """
        find_clicked(Fl_Tree self) -> Fl_Tree_Item
        find_clicked(Fl_Tree self) -> Fl_Tree_Item
        """
        return _fltk.Fl_Tree_find_clicked(self, *args)


    def item_clicked(self, *args):
        """item_clicked(Fl_Tree self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_item_clicked(self, *args)


    def first(self, *args):
        """first(Fl_Tree self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_first(self, *args)


    def first_visible(self, *args):
        """first_visible(Fl_Tree self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_first_visible(self, *args)


    def first_visible_item(self, *args):
        """first_visible_item(Fl_Tree self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_first_visible_item(self, *args)


    def next(self, *args):
        """next(Fl_Tree self, Fl_Tree_Item item=None) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_next(self, *args)


    def prev(self, *args):
        """prev(Fl_Tree self, Fl_Tree_Item item=None) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_prev(self, *args)


    def last(self, *args):
        """last(Fl_Tree self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_last(self, *args)


    def last_visible(self, *args):
        """last_visible(Fl_Tree self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_last_visible(self, *args)


    def last_visible_item(self, *args):
        """last_visible_item(Fl_Tree self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_last_visible_item(self, *args)


    def first_selected_item(self, *args):
        """first_selected_item(Fl_Tree self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_first_selected_item(self, *args)


    def last_selected_item(self, *args):
        """last_selected_item(Fl_Tree self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_last_selected_item(self, *args)


    def next_item(self, *args):
        """next_item(Fl_Tree self, Fl_Tree_Item item, int dir=0xff54, bool visible=False) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_next_item(self, *args)


    def next_selected_item(self, *args):
        """
        next_selected_item(Fl_Tree self, Fl_Tree_Item item=None) -> Fl_Tree_Item
        next_selected_item(Fl_Tree self, Fl_Tree_Item item, int dir) -> Fl_Tree_Item
        """
        return _fltk.Fl_Tree_next_selected_item(self, *args)


    def open(self, *args):
        """
        open(Fl_Tree self, Fl_Tree_Item item, int docallback=1) -> int
        open(Fl_Tree self, char const * path, int docallback=1) -> int
        """
        return _fltk.Fl_Tree_open(self, *args)


    def open_toggle(self, *args):
        """open_toggle(Fl_Tree self, Fl_Tree_Item item, int docallback=1)"""
        return _fltk.Fl_Tree_open_toggle(self, *args)


    def close(self, *args):
        """
        close(Fl_Tree self, Fl_Tree_Item item, int docallback=1) -> int
        close(Fl_Tree self, char const * path, int docallback=1) -> int
        """
        return _fltk.Fl_Tree_close(self, *args)


    def is_open(self, *args):
        """
        is_open(Fl_Tree self, Fl_Tree_Item item) -> int
        is_open(Fl_Tree self, char const * path) -> int
        """
        return _fltk.Fl_Tree_is_open(self, *args)


    def is_close(self, *args):
        """
        is_close(Fl_Tree self, Fl_Tree_Item item) -> int
        is_close(Fl_Tree self, char const * path) -> int
        """
        return _fltk.Fl_Tree_is_close(self, *args)


    def select(self, *args):
        """
        select(Fl_Tree self, Fl_Tree_Item item, int docallback=1) -> int
        select(Fl_Tree self, char const * path, int docallback=1) -> int
        """
        return _fltk.Fl_Tree_select(self, *args)


    def select_toggle(self, *args):
        """select_toggle(Fl_Tree self, Fl_Tree_Item item, int docallback=1)"""
        return _fltk.Fl_Tree_select_toggle(self, *args)


    def deselect(self, *args):
        """
        deselect(Fl_Tree self, Fl_Tree_Item item, int docallback=1) -> int
        deselect(Fl_Tree self, char const * path, int docallback=1) -> int
        """
        return _fltk.Fl_Tree_deselect(self, *args)


    def deselect_all(self, *args):
        """deselect_all(Fl_Tree self, Fl_Tree_Item item=None, int docallback=1) -> int"""
        return _fltk.Fl_Tree_deselect_all(self, *args)


    def select_only(self, *args):
        """select_only(Fl_Tree self, Fl_Tree_Item selitem, int docallback=1) -> int"""
        return _fltk.Fl_Tree_select_only(self, *args)


    def select_all(self, *args):
        """select_all(Fl_Tree self, Fl_Tree_Item item=None, int docallback=1) -> int"""
        return _fltk.Fl_Tree_select_all(self, *args)


    def extend_selection_dir(self, *args):
        """extend_selection_dir(Fl_Tree self, Fl_Tree_Item arg2, Fl_Tree_Item to, int dir, int val, bool visible) -> int"""
        return _fltk.Fl_Tree_extend_selection_dir(self, *args)


    def set_item_focus(self, *args):
        """set_item_focus(Fl_Tree self, Fl_Tree_Item item)"""
        return _fltk.Fl_Tree_set_item_focus(self, *args)


    def get_item_focus(self, *args):
        """get_item_focus(Fl_Tree self) -> Fl_Tree_Item"""
        return _fltk.Fl_Tree_get_item_focus(self, *args)


    def is_selected(self, *args):
        """
        is_selected(Fl_Tree self, Fl_Tree_Item item) -> int
        is_selected(Fl_Tree self, char const * path) -> int
        """
        return _fltk.Fl_Tree_is_selected(self, *args)


    def item_labelfont(self, *args):
        """
        item_labelfont(Fl_Tree self) -> Fl_Font
        item_labelfont(Fl_Tree self, Fl_Font val)
        """
        return _fltk.Fl_Tree_item_labelfont(self, *args)


    def item_labelsize(self, *args):
        """
        item_labelsize(Fl_Tree self) -> Fl_Fontsize
        item_labelsize(Fl_Tree self, Fl_Fontsize val)
        """
        return _fltk.Fl_Tree_item_labelsize(self, *args)


    def item_labelfgcolor(self, *args):
        """
        item_labelfgcolor(Fl_Tree self) -> Fl_Color
        item_labelfgcolor(Fl_Tree self, Fl_Color val)
        """
        return _fltk.Fl_Tree_item_labelfgcolor(self, *args)


    def item_labelbgcolor(self, *args):
        """
        item_labelbgcolor(Fl_Tree self) -> Fl_Color
        item_labelbgcolor(Fl_Tree self, Fl_Color val)
        """
        return _fltk.Fl_Tree_item_labelbgcolor(self, *args)


    def connectorcolor(self, *args):
        """
        connectorcolor(Fl_Tree self) -> Fl_Color
        connectorcolor(Fl_Tree self, Fl_Color val)
        """
        return _fltk.Fl_Tree_connectorcolor(self, *args)


    def marginleft(self, *args):
        """
        marginleft(Fl_Tree self) -> int
        marginleft(Fl_Tree self, int val)
        """
        return _fltk.Fl_Tree_marginleft(self, *args)


    def margintop(self, *args):
        """
        margintop(Fl_Tree self) -> int
        margintop(Fl_Tree self, int val)
        """
        return _fltk.Fl_Tree_margintop(self, *args)


    def linespacing(self, *args):
        """
        linespacing(Fl_Tree self) -> int
        linespacing(Fl_Tree self, int val)
        """
        return _fltk.Fl_Tree_linespacing(self, *args)


    def openchild_marginbottom(self, *args):
        """
        openchild_marginbottom(Fl_Tree self) -> int
        openchild_marginbottom(Fl_Tree self, int val)
        """
        return _fltk.Fl_Tree_openchild_marginbottom(self, *args)


    def usericonmarginleft(self, *args):
        """
        usericonmarginleft(Fl_Tree self) -> int
        usericonmarginleft(Fl_Tree self, int val)
        """
        return _fltk.Fl_Tree_usericonmarginleft(self, *args)


    def labelmarginleft(self, *args):
        """
        labelmarginleft(Fl_Tree self) -> int
        labelmarginleft(Fl_Tree self, int val)
        """
        return _fltk.Fl_Tree_labelmarginleft(self, *args)


    def connectorwidth(self, *args):
        """
        connectorwidth(Fl_Tree self) -> int
        connectorwidth(Fl_Tree self, int val)
        """
        return _fltk.Fl_Tree_connectorwidth(self, *args)


    def usericon(self, *args):
        """
        usericon(Fl_Tree self) -> Fl_Image
        usericon(Fl_Tree self, Fl_Image val)
        """
        return _fltk.Fl_Tree_usericon(self, *args)


    def openicon(self, *args):
        """
        openicon(Fl_Tree self) -> Fl_Image
        openicon(Fl_Tree self, Fl_Image val)
        """
        return _fltk.Fl_Tree_openicon(self, *args)


    def closeicon(self, *args):
        """
        closeicon(Fl_Tree self) -> Fl_Image
        closeicon(Fl_Tree self, Fl_Image val)
        """
        return _fltk.Fl_Tree_closeicon(self, *args)


    def showcollapse(self, *args):
        """
        showcollapse(Fl_Tree self) -> int
        showcollapse(Fl_Tree self, int val)
        """
        return _fltk.Fl_Tree_showcollapse(self, *args)


    def showroot(self, *args):
        """
        showroot(Fl_Tree self) -> int
        showroot(Fl_Tree self, int val)
        """
        return _fltk.Fl_Tree_showroot(self, *args)


    def connectorstyle(self, *args):
        """
        connectorstyle(Fl_Tree self) -> Fl_Tree_Connector
        connectorstyle(Fl_Tree self, Fl_Tree_Connector val)
        """
        return _fltk.Fl_Tree_connectorstyle(self, *args)


    def sortorder(self, *args):
        """
        sortorder(Fl_Tree self) -> Fl_Tree_Sort
        sortorder(Fl_Tree self, Fl_Tree_Sort val)
        """
        return _fltk.Fl_Tree_sortorder(self, *args)


    def selectbox(self, *args):
        """
        selectbox(Fl_Tree self) -> Fl_Boxtype
        selectbox(Fl_Tree self, Fl_Boxtype val)
        """
        return _fltk.Fl_Tree_selectbox(self, *args)


    def selectmode(self, *args):
        """
        selectmode(Fl_Tree self) -> Fl_Tree_Select
        selectmode(Fl_Tree self, Fl_Tree_Select val)
        """
        return _fltk.Fl_Tree_selectmode(self, *args)


    def recalc_tree(self, *args):
        """recalc_tree(Fl_Tree self)"""
        return _fltk.Fl_Tree_recalc_tree(self, *args)


    def displayed(self, *args):
        """displayed(Fl_Tree self, Fl_Tree_Item item) -> int"""
        return _fltk.Fl_Tree_displayed(self, *args)


    def show_item(self, *args):
        """
        show_item(Fl_Tree self, Fl_Tree_Item item, int yoff)
        show_item(Fl_Tree self, Fl_Tree_Item item)
        """
        return _fltk.Fl_Tree_show_item(self, *args)


    def show_item_top(self, *args):
        """show_item_top(Fl_Tree self, Fl_Tree_Item item)"""
        return _fltk.Fl_Tree_show_item_top(self, *args)


    def show_item_middle(self, *args):
        """show_item_middle(Fl_Tree self, Fl_Tree_Item item)"""
        return _fltk.Fl_Tree_show_item_middle(self, *args)


    def show_item_bottom(self, *args):
        """show_item_bottom(Fl_Tree self, Fl_Tree_Item item)"""
        return _fltk.Fl_Tree_show_item_bottom(self, *args)


    def display(self, *args):
        """display(Fl_Tree self, Fl_Tree_Item item)"""
        return _fltk.Fl_Tree_display(self, *args)


    def vposition(self, *args):
        """
        vposition(Fl_Tree self) -> int
        vposition(Fl_Tree self, int pos)
        """
        return _fltk.Fl_Tree_vposition(self, *args)


    def hposition(self, *args):
        """
        hposition(Fl_Tree self) -> int
        hposition(Fl_Tree self, int pos)
        """
        return _fltk.Fl_Tree_hposition(self, *args)


    def is_scrollbar(self, *args):
        """is_scrollbar(Fl_Tree self, Fl_Widget w) -> int"""
        return _fltk.Fl_Tree_is_scrollbar(self, *args)


    def scrollbar_size(self, *args):
        """
        scrollbar_size(Fl_Tree self) -> int
        scrollbar_size(Fl_Tree self, int size)
        """
        return _fltk.Fl_Tree_scrollbar_size(self, *args)


    def is_vscroll_visible(self, *args):
        """is_vscroll_visible(Fl_Tree self) -> int"""
        return _fltk.Fl_Tree_is_vscroll_visible(self, *args)


    def is_hscroll_visible(self, *args):
        """is_hscroll_visible(Fl_Tree self) -> int"""
        return _fltk.Fl_Tree_is_hscroll_visible(self, *args)


    def callback_item(self, *args):
        """
        callback_item(Fl_Tree self, Fl_Tree_Item item)
        callback_item(Fl_Tree self) -> Fl_Tree_Item
        """
        return _fltk.Fl_Tree_callback_item(self, *args)


    def callback_reason(self, *args):
        """
        callback_reason(Fl_Tree self, Fl_Tree_Reason reason)
        callback_reason(Fl_Tree self) -> Fl_Tree_Reason
        """
        return _fltk.Fl_Tree_callback_reason(self, *args)


    def load(self, *args):
        """load(Fl_Tree self, Fl_Preferences arg2)"""
        return _fltk.Fl_Tree_load(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Tree(self)
        return weakref_proxy(self)
Fl_Tree_swigregister = _fltk.Fl_Tree_swigregister
Fl_Tree_swigregister(Fl_Tree)


_fltk.NO_PAGE_FORMATS_swigconstant(_fltk)
NO_PAGE_FORMATS = _fltk.NO_PAGE_FORMATS
class Fl_Paged_Device(object):
    """

    Represents page-structured drawing surfaces.

    This class has no public constructor: don't instantiate it; use Fl_Printer 
    or Fl_PostScript_File_Device instead.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    A0 = _fltk.Fl_Paged_Device_A0
    A1 = _fltk.Fl_Paged_Device_A1
    A2 = _fltk.Fl_Paged_Device_A2
    A3 = _fltk.Fl_Paged_Device_A3
    A4 = _fltk.Fl_Paged_Device_A4
    A5 = _fltk.Fl_Paged_Device_A5
    A6 = _fltk.Fl_Paged_Device_A6
    A7 = _fltk.Fl_Paged_Device_A7
    A8 = _fltk.Fl_Paged_Device_A8
    A9 = _fltk.Fl_Paged_Device_A9
    B0 = _fltk.Fl_Paged_Device_B0
    B1 = _fltk.Fl_Paged_Device_B1
    B2 = _fltk.Fl_Paged_Device_B2
    B3 = _fltk.Fl_Paged_Device_B3
    B4 = _fltk.Fl_Paged_Device_B4
    B5 = _fltk.Fl_Paged_Device_B5
    B6 = _fltk.Fl_Paged_Device_B6
    B7 = _fltk.Fl_Paged_Device_B7
    B8 = _fltk.Fl_Paged_Device_B8
    B9 = _fltk.Fl_Paged_Device_B9
    B10 = _fltk.Fl_Paged_Device_B10
    C5E = _fltk.Fl_Paged_Device_C5E
    DLE = _fltk.Fl_Paged_Device_DLE
    EXECUTIVE = _fltk.Fl_Paged_Device_EXECUTIVE
    FOLIO = _fltk.Fl_Paged_Device_FOLIO
    LEDGER = _fltk.Fl_Paged_Device_LEDGER
    LEGAL = _fltk.Fl_Paged_Device_LEGAL
    LETTER = _fltk.Fl_Paged_Device_LETTER
    TABLOID = _fltk.Fl_Paged_Device_TABLOID
    ENVELOPE = _fltk.Fl_Paged_Device_ENVELOPE
    MEDIA = _fltk.Fl_Paged_Device_MEDIA
    PORTRAIT = _fltk.Fl_Paged_Device_PORTRAIT
    LANDSCAPE = _fltk.Fl_Paged_Device_LANDSCAPE
    REVERSED = _fltk.Fl_Paged_Device_REVERSED
    ORIENTATION = _fltk.Fl_Paged_Device_ORIENTATION

    def __init__(self, *args):
        """__init__(Fl_Paged_Device self) -> Fl_Paged_Device"""
        if self.__class__ == Fl_Paged_Device:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Paged_Device(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def class_name(self, *args):
        """class_name(Fl_Paged_Device self) -> char const *"""
        return _fltk.Fl_Paged_Device_class_name(self, *args)


    def start_job(self, *args):
        """start_job(Fl_Paged_Device self, int pagecount, int * frompage=None, int * topage=None) -> int"""
        return _fltk.Fl_Paged_Device_start_job(self, *args)


    def start_page(self, *args):
        """start_page(Fl_Paged_Device self) -> int"""
        return _fltk.Fl_Paged_Device_start_page(self, *args)


    def printable_rect(self, *args):
        """printable_rect(Fl_Paged_Device self, int * w, int * h) -> int"""
        return _fltk.Fl_Paged_Device_printable_rect(self, *args)


    def margins(self, *args):
        """margins(Fl_Paged_Device self, int * left, int * top, int * right, int * bottom)"""
        return _fltk.Fl_Paged_Device_margins(self, *args)


    def origin(self, *args):
        """
        origin(Fl_Paged_Device self, int x, int y)
        origin(Fl_Paged_Device self, int * x, int * y)
        """
        return _fltk.Fl_Paged_Device_origin(self, *args)


    def scale(self, *args):
        """scale(Fl_Paged_Device self, float scale_x, float scale_y=0.)"""
        return _fltk.Fl_Paged_Device_scale(self, *args)


    def rotate(self, *args):
        """rotate(Fl_Paged_Device self, float angle)"""
        return _fltk.Fl_Paged_Device_rotate(self, *args)


    def translate(self, *args):
        """translate(Fl_Paged_Device self, int x, int y)"""
        return _fltk.Fl_Paged_Device_translate(self, *args)


    def untranslate(self, *args):
        """untranslate(Fl_Paged_Device self)"""
        return _fltk.Fl_Paged_Device_untranslate(self, *args)


    def print_widget(self, *args):
        """print_widget(Fl_Paged_Device self, Fl_Widget widget, int delta_x=0, int delta_y=0)"""
        return _fltk.Fl_Paged_Device_print_widget(self, *args)


    def print_window(self, *args):
        """print_window(Fl_Paged_Device self, Fl_Window win, int x_offset=0, int y_offset=0)"""
        return _fltk.Fl_Paged_Device_print_window(self, *args)


    def print_window_part(self, *args):
        """print_window_part(Fl_Paged_Device self, Fl_Window win, int x, int y, int w, int h, int delta_x=0, int delta_y=0)"""
        return _fltk.Fl_Paged_Device_print_window_part(self, *args)


    def end_page(self, *args):
        """end_page(Fl_Paged_Device self) -> int"""
        return _fltk.Fl_Paged_Device_end_page(self, *args)


    def end_job(self, *args):
        """end_job(Fl_Paged_Device self)"""
        return _fltk.Fl_Paged_Device_end_job(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Paged_Device(self)
        return weakref_proxy(self)
Fl_Paged_Device_swigregister = _fltk.Fl_Paged_Device_swigregister
Fl_Paged_Device_swigregister(Fl_Paged_Device)

class Fl_Printer(Fl_Paged_Device):
    """

    Declaration of classes Fl_Printer, Fl_System_Printer and Fl_PostScript_Printer.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def class_name(self, *args):
        """class_name(Fl_Printer self) -> char const *"""
        return _fltk.Fl_Printer_class_name(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Printer self) -> Fl_Printer"""
        if self.__class__ == Fl_Printer:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Printer(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def start_job(self, *args):
        """start_job(Fl_Printer self, int pagecount, int * frompage=None, int * topage=None) -> int"""
        return _fltk.Fl_Printer_start_job(self, *args)


    def start_page(self, *args):
        """start_page(Fl_Printer self) -> int"""
        return _fltk.Fl_Printer_start_page(self, *args)


    def printable_rect(self, *args):
        """printable_rect(Fl_Printer self, int * w, int * h) -> int"""
        return _fltk.Fl_Printer_printable_rect(self, *args)


    def margins(self, *args):
        """margins(Fl_Printer self, int * left, int * top, int * right, int * bottom)"""
        return _fltk.Fl_Printer_margins(self, *args)


    def origin(self, *args):
        """
        origin(Fl_Printer self, int * x, int * y)
        origin(Fl_Printer self, int x, int y)
        """
        return _fltk.Fl_Printer_origin(self, *args)


    def scale(self, *args):
        """scale(Fl_Printer self, float scale_x, float scale_y=0.)"""
        return _fltk.Fl_Printer_scale(self, *args)


    def rotate(self, *args):
        """rotate(Fl_Printer self, float angle)"""
        return _fltk.Fl_Printer_rotate(self, *args)


    def translate(self, *args):
        """translate(Fl_Printer self, int x, int y)"""
        return _fltk.Fl_Printer_translate(self, *args)


    def untranslate(self, *args):
        """untranslate(Fl_Printer self)"""
        return _fltk.Fl_Printer_untranslate(self, *args)


    def end_page(self, *args):
        """end_page(Fl_Printer self) -> int"""
        return _fltk.Fl_Printer_end_page(self, *args)


    def end_job(self, *args):
        """end_job(Fl_Printer self)"""
        return _fltk.Fl_Printer_end_job(self, *args)


    def print_widget(self, *args):
        """print_widget(Fl_Printer self, Fl_Widget widget, int delta_x=0, int delta_y=0)"""
        return _fltk.Fl_Printer_print_widget(self, *args)


    def print_window_part(self, *args):
        """print_window_part(Fl_Printer self, Fl_Window win, int x, int y, int w, int h, int delta_x=0, int delta_y=0)"""
        return _fltk.Fl_Printer_print_window_part(self, *args)


    def set_current(self, *args):
        """set_current(Fl_Printer self)"""
        return _fltk.Fl_Printer_set_current(self, *args)


    def driver(self, *args):
        """driver(Fl_Printer self) -> Fl_Graphics_Driver *"""
        return _fltk.Fl_Printer_driver(self, *args)

    __swig_destroy__ = _fltk.delete_Fl_Printer
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Printer(self)
        return weakref_proxy(self)
Fl_Printer_swigregister = _fltk.Fl_Printer_swigregister
Fl_Printer_swigregister(Fl_Printer)


def fl_utf8bytes(*args):
    """fl_utf8bytes(unsigned int ucs) -> int"""
    return _fltk.fl_utf8bytes(*args)

def fl_utf8len(*args):
    """fl_utf8len(char c) -> int"""
    return _fltk.fl_utf8len(*args)

def fl_utf_nb_char(*args):
    """fl_utf_nb_char(unsigned char const * buf, int len) -> int"""
    return _fltk.fl_utf_nb_char(*args)

def fl_utf8decode(*args):
    """fl_utf8decode(char const * p, char const * end, int * len) -> unsigned int"""
    return _fltk.fl_utf8decode(*args)

def fl_utf8encode(*args):
    """fl_utf8encode(unsigned int ucs) -> int"""
    return _fltk.fl_utf8encode(*args)

def fl_utf8fwd(*args):
    """fl_utf8fwd(char const * p, char const * start, char const * end) -> char const *"""
    return _fltk.fl_utf8fwd(*args)

def fl_utf8back(*args):
    """fl_utf8back(char const * p, char const * start, char const * end) -> char const *"""
    return _fltk.fl_utf8back(*args)

def fl_utf8toUtf16(*args):
    """fl_utf8toUtf16(char const * src, unsigned int srclen, unsigned int dstlen) -> unsigned int"""
    return _fltk.fl_utf8toUtf16(*args)

def fl_utf8toa(*args):
    """fl_utf8toa(char const * src, unsigned int srclen, unsigned int arg4) -> unsigned int"""
    return _fltk.fl_utf8toa(*args)

def fl_utf8froma(*args):
    """fl_utf8froma(char * dst, unsigned int dstlen, char const * src, unsigned int srclen) -> unsigned int"""
    return _fltk.fl_utf8froma(*args)

def fl_utf8locale(*args):
    """fl_utf8locale() -> int"""
    return _fltk.fl_utf8locale(*args)

def fl_utf8test(*args):
    """fl_utf8test(char const * src, unsigned int len) -> int"""
    return _fltk.fl_utf8test(*args)

def fl_nonspacing(*args):
    """fl_nonspacing(unsigned int ucs) -> unsigned int"""
    return _fltk.fl_nonspacing(*args)

def fl_utf8to_mb(*args):
    """fl_utf8to_mb(char const * src, unsigned int srclen, char * dst, unsigned int dstlen) -> unsigned int"""
    return _fltk.fl_utf8to_mb(*args)

def fl_utf2mbcs(*args):
    """fl_utf2mbcs(char const * src) -> char *"""
    return _fltk.fl_utf2mbcs(*args)

def fl_utf8from_mb(*args):
    """fl_utf8from_mb(char * dst, unsigned int dstlen, char const * src, unsigned int srclen) -> unsigned int"""
    return _fltk.fl_utf8from_mb(*args)

def fl_utf_strncasecmp(*args):
    """fl_utf_strncasecmp(char const * s1, char const * s2, int n) -> int"""
    return _fltk.fl_utf_strncasecmp(*args)

def fl_utf_strcasecmp(*args):
    """fl_utf_strcasecmp(char const * s1, char const * s2) -> int"""
    return _fltk.fl_utf_strcasecmp(*args)

def fl_tolower(*args):
    """fl_tolower(unsigned int ucs) -> int"""
    return _fltk.fl_tolower(*args)

def fl_toupper(*args):
    """fl_toupper(unsigned int ucs) -> int"""
    return _fltk.fl_toupper(*args)

def fl_utf_tolower(*args):
    """fl_utf_tolower(unsigned char const * str, int len) -> int"""
    return _fltk.fl_utf_tolower(*args)

def fl_utf_toupper(*args):
    """fl_utf_toupper(unsigned char const * str, int len, char * buf) -> int"""
    return _fltk.fl_utf_toupper(*args)

def fl_chmod(*args):
    """fl_chmod(char const * f, int mode) -> int"""
    return _fltk.fl_chmod(*args)

def fl_access(*args):
    """fl_access(char const * f, int mode) -> int"""
    return _fltk.fl_access(*args)

def fl_getcwd(*args):
    """fl_getcwd(char * buf, int maxlen) -> char *"""
    return _fltk.fl_getcwd(*args)

def fl_fopen(*args):
    """fl_fopen(char const * f, char const * mode) -> FILE *"""
    return _fltk.fl_fopen(*args)

def fl_system(*args):
    """fl_system(char const * f) -> int"""
    return _fltk.fl_system(*args)

def fl_execvp(*args):
    """fl_execvp(char const * file, char *const * argv) -> int"""
    return _fltk.fl_execvp(*args)

def fl_open(*args):
    """fl_open(char const * f, int o) -> int"""
    return _fltk.fl_open(*args)

def fl_unlink(*args):
    """fl_unlink(char const * f) -> int"""
    return _fltk.fl_unlink(*args)

def fl_rmdir(*args):
    """fl_rmdir(char const * f) -> int"""
    return _fltk.fl_rmdir(*args)

def fl_getenv(*args):
    """fl_getenv(char const * name) -> char *"""
    return _fltk.fl_getenv(*args)

def fl_mkdir(*args):
    """fl_mkdir(char const * f, int mode) -> int"""
    return _fltk.fl_mkdir(*args)

def fl_rename(*args):
    """fl_rename(char const * f, char const * t) -> int"""
    return _fltk.fl_rename(*args)

def fl_make_path_for_file(*args):
    """fl_make_path_for_file(char const * path)"""
    return _fltk.fl_make_path_for_file(*args)

def fl_make_path(*args):
    """fl_make_path(char const * path) -> char"""
    return _fltk.fl_make_path(*args)

def upCB(*args):
    """upCB(Fl_Widget v, void * arg2)"""
    return _fltk.upCB(*args)

def downCB(*args):
    """downCB(Fl_Widget v, void * arg2)"""
    return _fltk.downCB(*args)

def toggleCB(*args):
    """toggleCB(Fl_Widget v, void * arg2)"""
    return _fltk.toggleCB(*args)
class ListSelect(Fl_Group):
    """Proxy of C++ ListSelect class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """__init__(ListSelect self, int x, int y, int w, int h, char * topLabel=None, char * bottomLabel=None) -> ListSelect"""
        if self.__class__ == ListSelect:
            _self = None
        else:
            _self = self
        this = _fltk.new_ListSelect(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()




    def getTopBrowser(self, *args):
        """getTopBrowser(ListSelect self) -> Fl_Multi_Browser"""
        return _fltk.ListSelect_getTopBrowser(self, *args)


    def getBottomBrowser(self, *args):
        """getBottomBrowser(ListSelect self) -> Fl_Multi_Browser"""
        return _fltk.ListSelect_getBottomBrowser(self, *args)


    def resize(self, *args):
        """resize(ListSelect self, int x, int y, int w, int h)"""
        return _fltk.ListSelect_resize(self, *args)

    __swig_destroy__ = _fltk.delete_ListSelect
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _fltk.disown_ListSelect(self)
        return weakref_proxy(self)

    def draw(self, *args):
        """draw(ListSelect self)"""
        return _fltk.ListSelect_draw(self, *args)

ListSelect_swigregister = _fltk.ListSelect_swigregister
ListSelect_swigregister(ListSelect)

class Fl_Table(Fl_Group):
    """

    This is the base class for table widgets. (eg. Fl_Table_Row). To be useful it must be subclassed and several virtual functions defined. Normally applications use widgets derived from this widget, and do not use this widget directly; this widget is usually too low level to be used directly by applications.

    This widget does not handle the data in the table. The draw_cell() method must be overridden by a subclass to manage drawing the contents of the cells.

    This widget can be used in several ways:

        * As a custom widget; see testtablerow.cxx. Very optimal for even extremely large tables.

        * As a table made up of a single FLTK widget instanced all over the table; see singleinput.cxx. Very optimal for even extremely large tables;

        * As a regular container of FLTK widgets, one widget per cell. See widgettable.cxx. Not recommended for large tables.

    When acting as part of a custom widget, events on the cells and/or headings generate callbacks when they are clicked by the user. You control when events are generated based on the setting for Fl_Table::when().

    When acting as a container for FLTK widgets, the FLTK widgets maintain themselves. Although the draw_cell() method must be overridden, its contents can be very simple. See the draw_cell() code in widgettable.cxx. 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    CONTEXT_NONE = _fltk.Fl_Table_CONTEXT_NONE
    CONTEXT_STARTPAGE = _fltk.Fl_Table_CONTEXT_STARTPAGE
    CONTEXT_ENDPAGE = _fltk.Fl_Table_CONTEXT_ENDPAGE
    CONTEXT_ROW_HEADER = _fltk.Fl_Table_CONTEXT_ROW_HEADER
    CONTEXT_COL_HEADER = _fltk.Fl_Table_CONTEXT_COL_HEADER
    CONTEXT_CELL = _fltk.Fl_Table_CONTEXT_CELL
    CONTEXT_TABLE = _fltk.Fl_Table_CONTEXT_TABLE
    CONTEXT_RC_RESIZE = _fltk.Fl_Table_CONTEXT_RC_RESIZE

    def handle(self, *args):
        """handle(Fl_Table self, int e) -> int"""
        return _fltk.Fl_Table_handle(self, *args)


    def draw_cell(self, *args):
        """draw_cell(Fl_Table self, Fl_Table::TableContext context, int R=0, int C=0, int X=0, int Y=0, int W=0, int H=0)"""
        return _fltk.Fl_Table_draw_cell(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Table self, int X, int Y, int W, int H, char const * l=None) -> Fl_Table"""
        if self.__class__ == Fl_Table:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Table(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Table
    __del__ = lambda self: None

    def clear(self, *args):
        """clear(Fl_Table self)"""
        return _fltk.Fl_Table_clear(self, *args)


    def table_box(self, *args):
        """
        table_box(Fl_Table self, Fl_Boxtype val)
        table_box(Fl_Table self) -> Fl_Boxtype
        """
        return _fltk.Fl_Table_table_box(self, *args)


    def rows(self, *args):
        """
        rows(Fl_Table self, int val)
        rows(Fl_Table self) -> int
        """
        return _fltk.Fl_Table_rows(self, *args)


    def cols(self, *args):
        """
        cols(Fl_Table self, int val)
        cols(Fl_Table self) -> int
        """
        return _fltk.Fl_Table_cols(self, *args)


    def visible_cells(self, *args):
        """visible_cells(Fl_Table self)"""
        return _fltk.Fl_Table_visible_cells(self, *args)


    def is_interactive_resize(self, *args):
        """is_interactive_resize(Fl_Table self) -> int"""
        return _fltk.Fl_Table_is_interactive_resize(self, *args)


    def row_resize(self, *args):
        """
        row_resize(Fl_Table self) -> int
        row_resize(Fl_Table self, int flag)
        """
        return _fltk.Fl_Table_row_resize(self, *args)


    def col_resize(self, *args):
        """
        col_resize(Fl_Table self) -> int
        col_resize(Fl_Table self, int flag)
        """
        return _fltk.Fl_Table_col_resize(self, *args)


    def col_resize_min(self, *args):
        """
        col_resize_min(Fl_Table self) -> int
        col_resize_min(Fl_Table self, int val)
        """
        return _fltk.Fl_Table_col_resize_min(self, *args)


    def row_resize_min(self, *args):
        """
        row_resize_min(Fl_Table self) -> int
        row_resize_min(Fl_Table self, int val)
        """
        return _fltk.Fl_Table_row_resize_min(self, *args)


    def row_header(self, *args):
        """
        row_header(Fl_Table self) -> int
        row_header(Fl_Table self, int flag)
        """
        return _fltk.Fl_Table_row_header(self, *args)


    def col_header(self, *args):
        """
        col_header(Fl_Table self) -> int
        col_header(Fl_Table self, int flag)
        """
        return _fltk.Fl_Table_col_header(self, *args)


    def col_header_height(self, *args):
        """
        col_header_height(Fl_Table self, int height)
        col_header_height(Fl_Table self) -> int
        """
        return _fltk.Fl_Table_col_header_height(self, *args)


    def row_header_width(self, *args):
        """
        row_header_width(Fl_Table self, int width)
        row_header_width(Fl_Table self) -> int
        """
        return _fltk.Fl_Table_row_header_width(self, *args)


    def row_header_color(self, *args):
        """
        row_header_color(Fl_Table self, Fl_Color val)
        row_header_color(Fl_Table self) -> Fl_Color
        """
        return _fltk.Fl_Table_row_header_color(self, *args)


    def col_header_color(self, *args):
        """
        col_header_color(Fl_Table self, Fl_Color val)
        col_header_color(Fl_Table self) -> Fl_Color
        """
        return _fltk.Fl_Table_col_header_color(self, *args)


    def row_height(self, *args):
        """
        row_height(Fl_Table self, int row, int height)
        row_height(Fl_Table self, int row) -> int
        """
        return _fltk.Fl_Table_row_height(self, *args)


    def col_width(self, *args):
        """
        col_width(Fl_Table self, int col, int width)
        col_width(Fl_Table self, int col) -> int
        """
        return _fltk.Fl_Table_col_width(self, *args)


    def row_height_all(self, *args):
        """row_height_all(Fl_Table self, int height)"""
        return _fltk.Fl_Table_row_height_all(self, *args)


    def col_width_all(self, *args):
        """col_width_all(Fl_Table self, int width)"""
        return _fltk.Fl_Table_col_width_all(self, *args)


    def row_position(self, *args):
        """
        row_position(Fl_Table self, int row)
        row_position(Fl_Table self) -> int
        """
        return _fltk.Fl_Table_row_position(self, *args)


    def col_position(self, *args):
        """
        col_position(Fl_Table self, int col)
        col_position(Fl_Table self) -> int
        """
        return _fltk.Fl_Table_col_position(self, *args)


    def top_row(self, *args):
        """
        top_row(Fl_Table self, int row)
        top_row(Fl_Table self) -> int
        """
        return _fltk.Fl_Table_top_row(self, *args)


    def is_selected(self, *args):
        """is_selected(Fl_Table self, int r, int c) -> int"""
        return _fltk.Fl_Table_is_selected(self, *args)


    def get_selection(self, *args):
        """get_selection(Fl_Table self)"""
        return _fltk.Fl_Table_get_selection(self, *args)


    def set_selection(self, *args):
        """set_selection(Fl_Table self, int row_top, int col_left, int row_bot, int col_right)"""
        return _fltk.Fl_Table_set_selection(self, *args)


    def move_cursor(self, *args):
        """
        move_cursor(Fl_Table self, int R, int C, int shiftselect) -> int
        move_cursor(Fl_Table self, int R, int C) -> int
        """
        return _fltk.Fl_Table_move_cursor(self, *args)


    def resize(self, *args):
        """resize(Fl_Table self, int X, int Y, int W, int H)"""
        return _fltk.Fl_Table_resize(self, *args)


    def draw(self, *args):
        """draw(Fl_Table self)"""
        return _fltk.Fl_Table_draw(self, *args)


    def init_sizes(self, *args):
        """init_sizes(Fl_Table self)"""
        return _fltk.Fl_Table_init_sizes(self, *args)


    def add(self, *args):
        """add(Fl_Table self, Fl_Widget wgt)"""
        val = _fltk.Fl_Table_add(self, *args)

        #self = args[0]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()
        else:                       
        #give ownership back to Python
            self.this.own() 


        return val


    def insert(self, *args):
        """insert(Fl_Table self, Fl_Widget wgt, int n)"""
        return _fltk.Fl_Table_insert(self, *args)


    def insert_before(self, *args):
        """insert_before(Fl_Table self, Fl_Widget wgt, Fl_Widget w2)"""
        return _fltk.Fl_Table_insert_before(self, *args)


    def begin(self, *args):
        """begin(Fl_Table self)"""
        return _fltk.Fl_Table_begin(self, *args)


    def end(self, *args):
        """end(Fl_Table self)"""
        return _fltk.Fl_Table_end(self, *args)


    def child(self, *args):
        """child(Fl_Table self, int n) -> Fl_Widget"""
        return _fltk.Fl_Table_child(self, *args)


    def children(self, *args):
        """children(Fl_Table self) -> int"""
        return _fltk.Fl_Table_children(self, *args)


    def find(self, *args):
        """find(Fl_Table self, Fl_Widget wgt) -> int"""
        return _fltk.Fl_Table_find(self, *args)


    def callback_row(self, *args):
        """callback_row(Fl_Table self) -> int"""
        return _fltk.Fl_Table_callback_row(self, *args)


    def callback_col(self, *args):
        """callback_col(Fl_Table self) -> int"""
        return _fltk.Fl_Table_callback_col(self, *args)


    def callback_context(self, *args):
        """callback_context(Fl_Table self) -> Fl_Table::TableContext"""
        return _fltk.Fl_Table_callback_context(self, *args)


    def do_callback(self, *args):
        """do_callback(Fl_Table self, Fl_Table::TableContext context, int row, int col)"""
        return _fltk.Fl_Table_do_callback(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Table(self)
        return weakref_proxy(self)
Fl_Table_swigregister = _fltk.Fl_Table_swigregister
Fl_Table_swigregister(Fl_Table)

class Fl_Table_Row(Fl_Table):
    """

    This class implements a simple table of rows and columns that specializes in the selection of rows. This widget is similar in behavior to a 'mail subject browser', similar to that found in mozilla, netscape and outlook mail browsers.

    Most methods of importance will be found in the Fl_Table widget, such as rows() and cols().

    To be useful it must be subclassed and at minimum the draw_cell() method must be overridden to provide the content of the cells. This widget does not manage the cell's data content; it is up to the parent class's draw_cell() method override to provide this.

    Events on the cells and/or headings generate callbacks when they are clicked by the user. You control when events are generated based on the values you supply for when(). 

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    SELECT_NONE = _fltk.Fl_Table_Row_SELECT_NONE
    SELECT_SINGLE = _fltk.Fl_Table_Row_SELECT_SINGLE
    SELECT_MULTI = _fltk.Fl_Table_Row_SELECT_MULTI

    def handle(self, *args):
        """handle(Fl_Table_Row self, int event) -> int"""
        return _fltk.Fl_Table_Row_handle(self, *args)


    def __init__(self, *args):
        """__init__(Fl_Table_Row self, int X, int Y, int W, int H, char const * l=None) -> Fl_Table_Row"""
        if self.__class__ == Fl_Table_Row:
            _self = None
        else:
            _self = self
        this = _fltk.new_Fl_Table_Row(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if len(args) == 6:          
        #retain reference to label
            self.my_label = args[5]
        if self.parent() != None:   
        #delegate ownership to C++
            self.this.disown()



    __swig_destroy__ = _fltk.delete_Fl_Table_Row
    __del__ = lambda self: None

    def rows(self, *args):
        """
        rows(Fl_Table_Row self, int val)
        rows(Fl_Table_Row self) -> int
        """
        return _fltk.Fl_Table_Row_rows(self, *args)


    def type(self, *args):
        """
        type(Fl_Table_Row self, Fl_Table_Row::TableRowSelectMode val)
        type(Fl_Table_Row self) -> Fl_Table_Row::TableRowSelectMode
        """
        return _fltk.Fl_Table_Row_type(self, *args)


    def row_selected(self, *args):
        """row_selected(Fl_Table_Row self, int row) -> int"""
        return _fltk.Fl_Table_Row_row_selected(self, *args)


    def select_row(self, *args):
        """select_row(Fl_Table_Row self, int row, int flag=1) -> int"""
        return _fltk.Fl_Table_Row_select_row(self, *args)


    def select_all_rows(self, *args):
        """select_all_rows(Fl_Table_Row self, int flag=1)"""
        return _fltk.Fl_Table_Row_select_all_rows(self, *args)


    def clear(self, *args):
        """clear(Fl_Table_Row self)"""
        return _fltk.Fl_Table_Row_clear(self, *args)

    def __disown__(self):
        self.this.disown()
        _fltk.disown_Fl_Table_Row(self)
        return weakref_proxy(self)

    def draw_cell(self, *args):
        """draw_cell(Fl_Table_Row self, Fl_Table::TableContext context, int R=0, int C=0, int X=0, int Y=0, int W=0, int H=0)"""
        return _fltk.Fl_Table_Row_draw_cell(self, *args)

Fl_Table_Row_swigregister = _fltk.Fl_Table_Row_swigregister
Fl_Table_Row_swigregister(Fl_Table_Row)


def glLoadIdentity(*args):
    """glLoadIdentity()"""
    return _fltk.glLoadIdentity(*args)

def glViewport(*args):
    """glViewport(int x, int y, int width, int height)"""
    return _fltk.glViewport(*args)

def glClear(*args):
    """glClear(int mask)"""
    return _fltk.glClear(*args)

def glColor3f(*args):
    """glColor3f(float red, float green, float blue)"""
    return _fltk.glColor3f(*args)

def glBegin(*args):
    """glBegin(int mode)"""
    return _fltk.glBegin(*args)

def glEnd(*args):
    """glEnd()"""
    return _fltk.glEnd(*args)

def glVertex3f(*args):
    """glVertex3f(float x, float y, float z)"""
    return _fltk.glVertex3f(*args)

_fltk.M_PI_swigconstant(_fltk)
M_PI = _fltk.M_PI

_fltk.M_PI_2_swigconstant(_fltk)
M_PI_2 = _fltk.M_PI_2

_fltk.M_PI_4_swigconstant(_fltk)
M_PI_4 = _fltk.M_PI_4

_fltk.M_1_PI_swigconstant(_fltk)
M_1_PI = _fltk.M_1_PI

_fltk.M_2_PI_swigconstant(_fltk)
M_2_PI = _fltk.M_2_PI

_fltk.M_SQRT2_swigconstant(_fltk)
M_SQRT2 = _fltk.M_SQRT2

_fltk.M_SQRT1_2_swigconstant(_fltk)
M_SQRT1_2 = _fltk.M_SQRT1_2

__idleCallbacks = []
def Fl_add_idle( func, data=None):
    __idleCallbacks.append( (func, data) )
    if len(__idleCallbacks) == 1:
        pyFLTK_controlIdleCallbacks(1)

def Fl_remove_idle( func, data=None):
    for cb in __idleCallbacks:
        if cb == ( func, data ):
            __idleCallbacks.remove(cb)
            break

def pyFLTK_doIdleCallbacks():
    for cb in __idleCallbacks:
        cb[0](cb[1])

pyFLTK_registerDoIdle(pyFLTK_doIdleCallbacks)


Fl.add_idle = staticmethod(Fl_add_idle)
Fl.remove_idle = staticmethod(Fl_remove_idle)




def __Fl_WidgetCallback(self,*args):
        if len(args) == 1:
            new_args = (self, args[0], self)
        else:
            new_args = (self, args[0], self, args[1])
        return _fltk.Fl_Widget_callback(*new_args)

Fl_Widget.callback = __Fl_WidgetCallback


def __Fl_Text_BufferAddModifyCallback(self,*args):
        if len(args) == 1:
            new_args = (self, args[0])
        else:
            new_args = (self, args[0], args[1])
        return _fltk.Fl_Text_Buffer_add_modify_callback(*new_args)

Fl_Text_Buffer.add_modify_callback = __Fl_Text_BufferAddModifyCallback


def __Fl_Text_BufferRemoveModifyCallback(self,*args):
        if len(args) == 1:
            new_args = (self, args[0], self)
        else:
            new_args = (self, args[0], self, args[1])
        return _fltk.Fl_Text_Buffer_remove_modify_callback(*new_args)

Fl_Text_Buffer.remove_modify_callback = __Fl_Text_BufferRemoveModifyCallback


def __Fl_File_ChooserCallback(self,*args):
        if len(args) == 1:
            new_args = (self, args[0], self)
        else:
            new_args = (self, args[0], self, args[1])
        return _fltk.Fl_File_Chooser_callback(*new_args)

Fl_File_Chooser.callback = __Fl_File_ChooserCallback


def __Fl_Help_ViewLink(self,*args):
        if len(args) == 1:
            new_args = (self, args[0], self)
        else:
            new_args = (self, args[0], self, args[1])
        return _fltk.Fl_Help_View_link(*new_args)

Fl_Help_View.link = __Fl_Help_ViewLink


Fl.add_timeout = staticmethod(Fl_add_timeout)
Fl.repeat_timeout = staticmethod(Fl_repeat_timeout)
Fl.remove_timeout = staticmethod(Fl_remove_timeout)
Fl.add_check = staticmethod(Fl_add_check)
Fl.remove_check = staticmethod(Fl_remove_check)
Fl.add_handler = staticmethod(Fl_add_handler)
Fl.remove_handler = staticmethod(Fl_remove_handler)
Fl.add_fd = staticmethod(Fl_add_fd)
Fl.remove_fd = staticmethod(Fl_remove_fd)
Fl.get_font_sizes = staticmethod(Fl_get_font_sizes_tmp)


setMenu = _fltk.setMenu

