my %settings = (
    'Playing'               => FALSE,
    'PlayerPID'             => FALSE,
    'CurrentTrack'          => 0,
    'Naptime'               => FALSE,
    'PreviewDefault'        => TRUE,
    'PlayListView'          => Gtk2::SimpleList->new( '' => 'text' ),
    'PlayList'              => [],
    'PlayedTracks'          => [],
    'PlaylistBoxFullWindow' => Gtk2::VBox->new( FALSE, 10 ),
    'MainTooltips'          => Gtk2::Tooltips->new,
    'TotalTime'             => 0,
    'PlayPause'             => Gtk2::ToggleButton->new('play'),
    'Shuffle'               => Gtk2::ToggleButton->new('shuffle'),
    'Repeat'                => Gtk2::ToggleButton->new('repeat'),
    'PlaylistControls'      => Gtk2::Alignment->new( 0.5, 0.5, 0, 0 ),
    'FullControlWindow'     => Gtk2::Window->new(GTK_WINDOW_TOPLEVEL),
    'MiniControlWindow'     => Gtk2::Window->new(GTK_WINDOW_TOPLEVEL),
);

Then, later in the setup, we have:

my $openFileButton = Gtk2::Button->new_from_stock('gtk-open');
$openFileButton->signal_connect( 'clicked' => \&openFile,    \%settings );

sub editPlaylist {
    my ( $widget, $programSettings ) = @_;
        # hash to be passed to gtk event handlers inside the dialog
        my %editSettings = (
            'ProgramSettings' => $programSettings,
            'Window'          => Gtk2::Dialog->new(
                'Playlist editor', ${$programSettings->{'ControlWindow'} },
                'modal', 'gtk-ok' => TRUE,
                'gtk-cancel' => FALSE
            ),
            'CurrentSelection' => [],
            'View'             => Gtk2::SimpleList->new(
                textSeconds( $programSettings->{'TotalTime'} ) => 'text' ),
            'NewList'   => [ @{ $programSettings->{'PlayList'} } ],
            'TotalTime' => $programSettings->{'TotalTime'},
            'ViewData'  => [ @{ $programSettings->{'PlayListViewData'} } ],
        );

Then, later in the routine, we have:

        my $addFilesButton = Gtk2::Button->new('_Add Files');
        $addFilesButton->signal_connect(
            'clicked' => \&editAddFiles,
            \%editSettings
        );

    my %requesterSettings = (
        'Window' => Gtk2::FileChooserDialog->new(
            $message, $parentWindow, 'open', 'gtk-ok' => GTK_RESPONSE_OK,
            'gtk-cancel' => GTK_RESPONSE_CANCEL
        ),
    my $taskbarHBox = Gtk2::HBox->new;
    my $selectAll   = Gtk2::Button->new('Select _All');
    $taskbarHBox->pack_start( $selectAll, FALSE, FALSE, 0 );
    my $previewToggle = Gtk2::ToggleButton->new('File Information');
    $taskbarHBox->pack_start( $previewToggle, FALSE, FALSE, 0 );
    my $renameFiles = Gtk2::Button->new('_Rename');
    $taskbarHBox->pack_start( $renameFiles, FALSE, FALSE, 0 );
    my $deleteFiles = Gtk2::Button->new_from_stock('gtk-delete');
    $taskbarHBox->pack_start( $deleteFiles, FALSE, FALSE, 0 );
    $taskbarHBox->show_all;
    $requesterSettings{'Window'}->set_extra_widget($taskbarHBox);

sub renameFiles {
    my ( $widget, $dialogSettings ) = @_;
    my $renamed = FALSE;
    my $renameDialog = Gtk2::Dialog->new(
        '',
        $dialogSettings->{'Window'}, 'modal', 'gtk-ok' => TRUE,
        'gtk-cancel' => FALSE
    );
    my $nameEntry = Gtk2::Entry->new;
    $nameEntry->set_activates_default(TRUE);
    $renameDialog->vbox->add($nameEntry);
    $renameDialog->set_default_response(TRUE);

    foreach ( $dialogSettings->{'Window'}->get_filenames ) {
        my ( $name, $path, $suffix ) = fileparse( $_, '.mp3', '.pls', '.m3u' );
        $nameEntry->set_text($name);
        $renameDialog->set_title( 'Rename '
            . ( $suffix eq '.mp3' ? "$name.mp3" : "playlist $name" ) );
        $renameDialog->show_all;
        if ( $renameDialog->run ) {
            my $newname =
              File::Spec->catfile( $path, $nameEntry->get_text . $suffix );
            ( move( $_, $newname )
              ? $renamed = TRUE
              : warn "Couldn't rename $_ to $newname: $!\n" )
              if ( $_ ne $newname );
        }
        $renameDialog->hide;
    }

    # force a refresh after a successful rename
    if ($renamed) {
        $dialogSettings->{'Window'}->set_current_folder(
            $dialogSettings->{'Window'}->get_current_folder );
        $dialogSettings->{'Window'}->show_all;
    }
    $renameDialog->destroy;
}

And, in the FileChooser routine, we have:

    my %requesterSettings = (
        'Window' => Gtk2::FileChooserDialog->new(
            $message, $parentWindow, 'open', 'gtk-ok' => GTK_RESPONSE_OK,
            'gtk-cancel' => GTK_RESPONSE_CANCEL
        ),
    my $renameFiles = Gtk2::Button->new('_Rename');
    $renameFiles->signal_connect(
        'clicked' => \&renameFiles,
        \%requesterSettings
    );

sub deleteFiles {
    my ( $widget, $dialogSettings ) = @_;
    my $deleted = FALSE;
    my $confirmDialog = Gtk2::Dialog->new(
        'Confirm delete',
        $dialogSettings->{'Window'}, 'modal', 'gtk-ok' => TRUE,
        'gtk-cancel' => FALSE
    );
    my $filename = Gtk2::Label->new;
    $confirmDialog->vbox->add($filename);
    $confirmDialog->set_default_response(FALSE);
    foreach ( $dialogSettings->{'Window'}->get_filenames ) {
        my ( $name, $path, $suffix ) = fileparse( $_, '.mp3', '.pls', '.m3u' );
        $filename->set_text("$name$suffix");
        $confirmDialog->show_all;
        unlink($_) ? $deleted = TRUE : warn "Couldn't delete $_: $!\n"
          if ( $confirmDialog->run );
        $confirmDialog->hide;
    }

    # force a refresh after a successful delete
    if ($deleted) {
        $dialogSettings->{'Window'}->set_current_folder(
            $dialogSettings->{'Window'}->get_current_folder );
        $dialogSettings->{'Window'}->show_all;
    }
    $confirmDialog->destroy;
}

And, in the FileChooser routine, we have:

    my $deleteFiles = Gtk2::Button->new_from_stock('gtk-delete');
    $deleteFiles->signal_connect(
        'clicked' => \&deleteFiles,
        \%requesterSettings
    );

sub playPause {
    my ( $widget, $programSettings ) = @_;
    if ( $widget->get_active ) {
            $widget->set_label("pause");
            $widget->set_use_stock(TRUE);
        }
    else {
        $widget->set_label("play");
        $widget->set_use_stock(TRUE);
    }

    # update the button
    $widget->show;
}

my $iconFactory = Gtk2::IconFactory->new;
my @playIconXPM = (
    '48 48 2 1',
    '     c None',
    '.    c black',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                .                               ',
    '                ..                              ',
    '                ...                             ',
    '                ....                            ',
    '                .....                           ',
    '                ......                          ',
    '                .......                         ',
    '                ........                        ',
    '                .........                       ',
    '                ..........                      ',
    '                ...........                     ',
    '                ............                    ',
    '                .............                   ',
    '                ..............                  ',
    '                ...............                 ',
    '                ................                ',
    '                ................                ',
    '                ...............                 ',
    '                ..............                  ',
    '                .............                   ',
    '                ............                    ',
    '                ...........                     ',
    '                ..........                      ',
    '                .........                       ',
    '                ........                        ',
    '                .......                         ',
    '                ......                          ',
    '                .....                           ',
    '                ...                             ',
    '                ..                              ',
    '                .                               ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                '
);

Gtk2::Stock->add(
    {
        stock_id => 'play',
        label    => '',
    }
);

my $playPixbuf  = Gtk2::Gdk::Pixbuf->new_from_xpm_data(@playIconXPM);
my $playIconSet = Gtk2::IconSet->new_from_pixbuf($playPixbuf);
$iconFactory->add( 'play', $playIconSet );

my @pauseIconXPM = (
    '48 48 2 1',
    '     c None',
    '.    c black',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '        ...........         ...........         ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                ',
    '                                                '
);

Gtk2::Stock->add(
    {
        stock_id => 'pause',
        label    => '',
    }
);

my $pausePixbuf  = Gtk2::Gdk::Pixbuf->new_from_xpm_data(@pauseIconXPM);
my $pauseIconSet = Gtk2::IconSet->new_from_pixbuf($pausePixbuf);
$iconFactory->add( 'pause', $pauseIconSet );

# make iconFactory searchable by gtk
$iconFactory->add_default;

1. Get your button images into XPM files (I usually either use pixmap to draw them or netpbm to convert them, if I want something prettier than what I can draw in pixmap).
2. Add the XPM code to your Perl directly.
3. Remove the C comments from the XPM (i.e., text within /* and */).
4. Change the double quotes into single quotes.
5. Assign the whole thing into an array (put round brackets around it).
6. Add the stock ID you want to use using Gtk2::Stock->add.
7. Convert the XPM into a pixbuf, and then the pixbuf into an icon set, and then add the icon set to your icon factory (with the same stock ID that you added earlier).
8. When you're done, add the icon factory to the default list of icons. That makes all your stock_id values usable.

#!/usr/bin/perl

use strict;
use warnings;

use Gtk2 -init;
use Data::Dumper;

foreach (Gtk2::Stock->list_ids) {
    print $_, "\n", Dumper (Gtk2::Stock->lookup ($_)), "\n";
}

gtk-zoom-out
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-zoom-out',
  'keyval' => 0,
  'label' => 'Zoom _Out',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-zoom-in
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-zoom-in',
  'keyval' => 0,
  'label' => 'Zoom _In',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-zoom-fit
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-zoom-fit',
  'keyval' => 0,
  'label' => 'Best _Fit',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-zoom-100
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-zoom-100',
  'keyval' => 0,
  'label' => '_Normal Size',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-yes
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-yes',
  'keyval' => 0,
  'label' => '_Yes',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-unindent
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-unindent',
  'keyval' => 0,
  'label' => 'Decrease Indent',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-undo
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-undo',
  'keyval' => 0,
  'label' => '_Undo',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-underline
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-underline',
  'keyval' => 0,
  'label' => '_Underline',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-undelete
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-undelete',
  'keyval' => 0,
  'label' => '_Undelete',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-strikethrough
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-strikethrough',
  'keyval' => 0,
  'label' => '_Strikethrough',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-stop
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-stop',
  'keyval' => 0,
  'label' => '_Stop',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-spell-check
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-spell-check',
  'keyval' => 0,
  'label' => '_Spell Check',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-sort-descending
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-sort-descending',
  'keyval' => 0,
  'label' => '_Descending',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-sort-ascending
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-sort-ascending',
  'keyval' => 0,
  'label' => '_Ascending',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-select-font
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-select-font',
  'keyval' => 0,
  'label' => '_Font',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-select-color
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-select-color',
  'keyval' => 0,
  'label' => '_Color',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-save-as
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-save-as',
  'keyval' => 0,
  'label' => 'Save _As',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-save
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-save',
  'keyval' => 115,
  'label' => '_Save',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-revert-to-saved
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-revert-to-saved',
  'keyval' => 0,
  'label' => '_Revert',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-remove
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-remove',
  'keyval' => 0,
  'label' => '_Remove',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-refresh
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-refresh',
  'keyval' => 0,
  'label' => '_Refresh',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-redo
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-redo',
  'keyval' => 0,
  'label' => '_Redo',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-quit
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-quit',
  'keyval' => 113,
  'label' => '_Quit',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-properties
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-properties',
  'keyval' => 0,
  'label' => '_Properties',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-print-preview
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-print-preview',
  'keyval' => 0,
  'label' => 'Print Pre_view',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-print
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-print',
  'keyval' => 0,
  'label' => '_Print',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-preferences
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-preferences',
  'keyval' => 0,
  'label' => '_Preferences',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-paste
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-paste',
  'keyval' => 118,
  'label' => '_Paste',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-open
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-open',
  'keyval' => 111,
  'label' => '_Open',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-ok
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-ok',
  'keyval' => 0,
  'label' => '_OK',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-no
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-no',
  'keyval' => 0,
  'label' => '_No',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-new
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-new',
  'keyval' => 110,
  'label' => '_New',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-network
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-network',
  'keyval' => 0,
  'label' => '_Network',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-missing-image
$VAR1 = undef;

gtk-justify-right
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-justify-right',
  'keyval' => 0,
  'label' => '_Right',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-justify-left
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-justify-left',
  'keyval' => 0,
  'label' => '_Left',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-justify-fill
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-justify-fill',
  'keyval' => 0,
  'label' => '_Fill',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-justify-center
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-justify-center',
  'keyval' => 0,
  'label' => '_Center',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-jump-to
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-jump-to',
  'keyval' => 0,
  'label' => '_Jump to',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-italic
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-italic',
  'keyval' => 0,
  'label' => '_Italic',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-index
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-index',
  'keyval' => 0,
  'label' => '_Index',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-indent
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-indent',
  'keyval' => 0,
  'label' => 'Increase Indent',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-home
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-home',
  'keyval' => 0,
  'label' => '_Home',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-help
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-help',
  'keyval' => 104,
  'label' => '_Help',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-harddisk
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-harddisk',
  'keyval' => 0,
  'label' => '_Harddisk',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-goto-top
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-goto-top',
  'keyval' => 0,
  'label' => '_Top',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-goto-last
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-goto-last',
  'keyval' => 0,
  'label' => '_Last',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-goto-first
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-goto-first',
  'keyval' => 0,
  'label' => '_First',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-goto-bottom
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-goto-bottom',
  'keyval' => 0,
  'label' => '_Bottom',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-go-up
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-go-up',
  'keyval' => 0,
  'label' => '_Up',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-go-forward
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-go-forward',
  'keyval' => 0,
  'label' => '_Forward',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-go-down
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-go-down',
  'keyval' => 0,
  'label' => '_Down',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-go-back
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-go-back',
  'keyval' => 0,
  'label' => '_Back',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-floppy
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-floppy',
  'keyval' => 0,
  'label' => '_Floppy',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-find-and-replace
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-find-and-replace',
  'keyval' => 114,
  'label' => 'Find and _Replace',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-find
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-find',
  'keyval' => 102,
  'label' => '_Find',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-execute
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-execute',
  'keyval' => 0,
  'label' => '_Execute',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-dnd-multiple
$VAR1 = undef;

gtk-dnd
$VAR1 = undef;

gtk-dialog-warning
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-dialog-warning',
  'keyval' => 0,
  'label' => 'Warning',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-dialog-question
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-dialog-question',
  'keyval' => 0,
  'label' => 'Question',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-dialog-info
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-dialog-info',
  'keyval' => 0,
  'label' => 'Information',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-dialog-error
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-dialog-error',
  'keyval' => 0,
  'label' => 'Error',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-dialog-authentication
$VAR1 = undef;

gtk-delete
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-delete',
  'keyval' => 0,
  'label' => '_Delete',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-cut
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-cut',
  'keyval' => 120,
  'label' => 'Cu_t',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-copy
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-copy',
  'keyval' => 99,
  'label' => '_Copy',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-convert
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-convert',
  'keyval' => 0,
  'label' => '_Convert',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-color-picker
$VAR1 = undef;

gtk-close
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-close',
  'keyval' => 119,
  'label' => '_Close',
  'modifier' => bless( do{\(my $o = 4)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-clear
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-clear',
  'keyval' => 0,
  'label' => '_Clear',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-cdrom
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-cdrom',
  'keyval' => 0,
  'label' => '_CD-Rom',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-cancel
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-cancel',
  'keyval' => 0,
  'label' => '_Cancel',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-bold
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-bold',
  'keyval' => 0,
  'label' => '_Bold',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-apply
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-apply',
  'keyval' => 0,
  'label' => '_Apply',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

gtk-add
$VAR1 = {
  'translation_domain' => 'gtk20',
  'stock_id' => 'gtk-add',
  'keyval' => 0,
  'label' => '_Add',
  'modifier' => bless( do{\(my $o = 0)}, 'Gtk2::Gdk::ModifierType' )
  };

#!/usr/bin/perl

print "#!/usr/bin/perl\n\n";
while (<>) {
    if ( /Gtk2::/ && /=head2/ ) {
        s/^.*( Gtk2::.*)/\1/;
        print "#$_";
    }
    elsif ( /G.K_/ || /PANGO_/ ) {
        s/^.*(G.K_.*)\'.*$/\1/;
        s/^.*(PANGO_.*)\'.*$/\1/;
        chop;
        print "use constant $_ => '$_';\n";
    }
}

#!/usr/bin/perl

# Gtk2::Gdk::AxisUse
use constant GDK_AXIS_IGNORE => 'GDK_AXIS_IGNORE';
use constant GDK_AXIS_X => 'GDK_AXIS_X';
use constant GDK_AXIS_Y => 'GDK_AXIS_Y';
use constant GDK_AXIS_PRESSURE => 'GDK_AXIS_PRESSURE';
use constant GDK_AXIS_XTILT => 'GDK_AXIS_XTILT';
use constant GDK_AXIS_YTILT => 'GDK_AXIS_YTILT';
use constant GDK_AXIS_WHEEL => 'GDK_AXIS_WHEEL';
use constant GDK_AXIS_LAST => 'GDK_AXIS_LAST';
# Gtk2::Gdk::ByteOrder
use constant GDK_LSB_FIRST => 'GDK_LSB_FIRST';
use constant GDK_MSB_FIRST => 'GDK_MSB_FIRST';
# Gtk2::Gdk::CapStyle
use constant GDK_CAP_NOT_LAST => 'GDK_CAP_NOT_LAST';
use constant GDK_CAP_BUTT => 'GDK_CAP_BUTT';
use constant GDK_CAP_ROUND => 'GDK_CAP_ROUND';
use constant GDK_CAP_PROJECTING => 'GDK_CAP_PROJECTING';
# Gtk2::Gdk::Colorspace
use constant GDK_COLORSPACE_RGB => 'GDK_COLORSPACE_RGB';
# Gtk2::Gdk::CrossingMode
use constant GDK_CROSSING_NORMAL => 'GDK_CROSSING_NORMAL';
use constant GDK_CROSSING_GRAB => 'GDK_CROSSING_GRAB';
use constant GDK_CROSSING_UNGRAB => 'GDK_CROSSING_UNGRAB';
# Gtk2::Gdk::CursorType
use constant GDK_X_CURSOR => 'GDK_X_CURSOR';
use constant GDK_ARROW => 'GDK_ARROW';
use constant GDK_BASED_ARROW_DOWN => 'GDK_BASED_ARROW_DOWN';
use constant GDK_BASED_ARROW_UP => 'GDK_BASED_ARROW_UP';
use constant GDK_BOAT => 'GDK_BOAT';
use constant GDK_BOGOSITY => 'GDK_BOGOSITY';
use constant GDK_BOTTOM_LEFT_CORNER => 'GDK_BOTTOM_LEFT_CORNER';
use constant GDK_BOTTOM_RIGHT_CORNER => 'GDK_BOTTOM_RIGHT_CORNER';
use constant GDK_BOTTOM_SIDE => 'GDK_BOTTOM_SIDE';
use constant GDK_BOTTOM_TEE => 'GDK_BOTTOM_TEE';
use constant GDK_BOX_SPIRAL => 'GDK_BOX_SPIRAL';
use constant GDK_CENTER_PTR => 'GDK_CENTER_PTR';
use constant GDK_CIRCLE => 'GDK_CIRCLE';
use constant GDK_CLOCK => 'GDK_CLOCK';
use constant GDK_COFFEE_MUG => 'GDK_COFFEE_MUG';
use constant GDK_CROSS => 'GDK_CROSS';
use constant GDK_CROSS_REVERSE => 'GDK_CROSS_REVERSE';
use constant GDK_CROSSHAIR => 'GDK_CROSSHAIR';
use constant GDK_DIAMOND_CROSS => 'GDK_DIAMOND_CROSS';
use constant GDK_DOT => 'GDK_DOT';
use constant GDK_DOTBOX => 'GDK_DOTBOX';
use constant GDK_DOUBLE_ARROW => 'GDK_DOUBLE_ARROW';
use constant GDK_DRAFT_LARGE => 'GDK_DRAFT_LARGE';
use constant GDK_DRAFT_SMALL => 'GDK_DRAFT_SMALL';
use constant GDK_DRAPED_BOX => 'GDK_DRAPED_BOX';
use constant GDK_EXCHANGE => 'GDK_EXCHANGE';
use constant GDK_FLEUR => 'GDK_FLEUR';
use constant GDK_GOBBLER => 'GDK_GOBBLER';
use constant GDK_GUMBY => 'GDK_GUMBY';
use constant GDK_HAND1 => 'GDK_HAND1';
use constant GDK_HAND2 => 'GDK_HAND2';
use constant GDK_HEART => 'GDK_HEART';
use constant GDK_ICON => 'GDK_ICON';
use constant GDK_IRON_CROSS => 'GDK_IRON_CROSS';
use constant GDK_LEFT_PTR => 'GDK_LEFT_PTR';
use constant GDK_LEFT_SIDE => 'GDK_LEFT_SIDE';
use constant GDK_LEFT_TEE => 'GDK_LEFT_TEE';
use constant GDK_LEFTBUTTON => 'GDK_LEFTBUTTON';
use constant GDK_LL_ANGLE => 'GDK_LL_ANGLE';
use constant GDK_LR_ANGLE => 'GDK_LR_ANGLE';
use constant GDK_MAN => 'GDK_MAN';
use constant GDK_MIDDLEBUTTON => 'GDK_MIDDLEBUTTON';
use constant GDK_MOUSE => 'GDK_MOUSE';
use constant GDK_PENCIL => 'GDK_PENCIL';
use constant GDK_PIRATE => 'GDK_PIRATE';
use constant GDK_PLUS => 'GDK_PLUS';
use constant GDK_QUESTION_ARROW => 'GDK_QUESTION_ARROW';
use constant GDK_RIGHT_PTR => 'GDK_RIGHT_PTR';
use constant GDK_RIGHT_SIDE => 'GDK_RIGHT_SIDE';
use constant GDK_RIGHT_TEE => 'GDK_RIGHT_TEE';
use constant GDK_RIGHTBUTTON => 'GDK_RIGHTBUTTON';
use constant GDK_RTL_LOGO => 'GDK_RTL_LOGO';
use constant GDK_SAILBOAT => 'GDK_SAILBOAT';
use constant GDK_SB_DOWN_ARROW => 'GDK_SB_DOWN_ARROW';
use constant GDK_SB_H_DOUBLE_ARROW => 'GDK_SB_H_DOUBLE_ARROW';
use constant GDK_SB_LEFT_ARROW => 'GDK_SB_LEFT_ARROW';
use constant GDK_SB_RIGHT_ARROW => 'GDK_SB_RIGHT_ARROW';
use constant GDK_SB_UP_ARROW => 'GDK_SB_UP_ARROW';
use constant GDK_SB_V_DOUBLE_ARROW => 'GDK_SB_V_DOUBLE_ARROW';
use constant GDK_SHUTTLE => 'GDK_SHUTTLE';
use constant GDK_SIZING => 'GDK_SIZING';
use constant GDK_SPIDER => 'GDK_SPIDER';
use constant GDK_SPRAYCAN => 'GDK_SPRAYCAN';
use constant GDK_STAR => 'GDK_STAR';
use constant GDK_TARGET => 'GDK_TARGET';
use constant GDK_TCROSS => 'GDK_TCROSS';
use constant GDK_TOP_LEFT_ARROW => 'GDK_TOP_LEFT_ARROW';
use constant GDK_TOP_LEFT_CORNER => 'GDK_TOP_LEFT_CORNER';
use constant GDK_TOP_RIGHT_CORNER => 'GDK_TOP_RIGHT_CORNER';
use constant GDK_TOP_SIDE => 'GDK_TOP_SIDE';
use constant GDK_TOP_TEE => 'GDK_TOP_TEE';
use constant GDK_TREK => 'GDK_TREK';
use constant GDK_UL_ANGLE => 'GDK_UL_ANGLE';
use constant GDK_UMBRELLA => 'GDK_UMBRELLA';
use constant GDK_UR_ANGLE => 'GDK_UR_ANGLE';
use constant GDK_WATCH => 'GDK_WATCH';
use constant GDK_XTERM => 'GDK_XTERM';
use constant GDK_LAST_CURSOR => 'GDK_LAST_CURSOR';
use constant GDK_CURSOR_IS_PIXMAP => 'GDK_CURSOR_IS_PIXMAP';
# Gtk2::Gdk::DragAction
use constant GDK_ACTION_DEFAULT => 'GDK_ACTION_DEFAULT';
use constant GDK_ACTION_COPY => 'GDK_ACTION_COPY';
use constant GDK_ACTION_MOVE => 'GDK_ACTION_MOVE';
use constant GDK_ACTION_LINK => 'GDK_ACTION_LINK';
use constant GDK_ACTION_PRIVATE => 'GDK_ACTION_PRIVATE';
use constant GDK_ACTION_ASK => 'GDK_ACTION_ASK';
# Gtk2::Gdk::DragProtocol
use constant GDK_DRAG_PROTO_MOTIF => 'GDK_DRAG_PROTO_MOTIF';
use constant GDK_DRAG_PROTO_XDND => 'GDK_DRAG_PROTO_XDND';
use constant GDK_DRAG_PROTO_ROOTWIN => 'GDK_DRAG_PROTO_ROOTWIN';
use constant GDK_DRAG_PROTO_NONE => 'GDK_DRAG_PROTO_NONE';
use constant GDK_DRAG_PROTO_WIN32_DROPFILES => 'GDK_DRAG_PROTO_WIN32_DROPFILES';
use constant GDK_DRAG_PROTO_OLE2 => 'GDK_DRAG_PROTO_OLE2';
use constant GDK_DRAG_PROTO_LOCAL => 'GDK_DRAG_PROTO_LOCAL';
# Gtk2::Gdk::EventMask
use constant GDK_EXPOSURE_MASK => 'GDK_EXPOSURE_MASK';
use constant GDK_POINTER_MOTION_MASK => 'GDK_POINTER_MOTION_MASK';
use constant GDK_POINTER_MOTION_HINT_MASK => 'GDK_POINTER_MOTION_HINT_MASK';
use constant GDK_BUTTON_MOTION_MASK => 'GDK_BUTTON_MOTION_MASK';
use constant GDK_BUTTON1_MOTION_MASK => 'GDK_BUTTON1_MOTION_MASK';
use constant GDK_BUTTON2_MOTION_MASK => 'GDK_BUTTON2_MOTION_MASK';
use constant GDK_BUTTON3_MOTION_MASK => 'GDK_BUTTON3_MOTION_MASK';
use constant GDK_BUTTON_PRESS_MASK => 'GDK_BUTTON_PRESS_MASK';
use constant GDK_BUTTON_RELEASE_MASK => 'GDK_BUTTON_RELEASE_MASK';
use constant GDK_KEY_PRESS_MASK => 'GDK_KEY_PRESS_MASK';
use constant GDK_KEY_RELEASE_MASK => 'GDK_KEY_RELEASE_MASK';
use constant GDK_ENTER_NOTIFY_MASK => 'GDK_ENTER_NOTIFY_MASK';
use constant GDK_LEAVE_NOTIFY_MASK => 'GDK_LEAVE_NOTIFY_MASK';
use constant GDK_FOCUS_CHANGE_MASK => 'GDK_FOCUS_CHANGE_MASK';
use constant GDK_STRUCTURE_MASK => 'GDK_STRUCTURE_MASK';
use constant GDK_PROPERTY_CHANGE_MASK => 'GDK_PROPERTY_CHANGE_MASK';
use constant GDK_VISIBILITY_NOTIFY_MASK => 'GDK_VISIBILITY_NOTIFY_MASK';
use constant GDK_PROXIMITY_IN_MASK => 'GDK_PROXIMITY_IN_MASK';
use constant GDK_PROXIMITY_OUT_MASK => 'GDK_PROXIMITY_OUT_MASK';
use constant GDK_SUBSTRUCTURE_MASK => 'GDK_SUBSTRUCTURE_MASK';
use constant GDK_SCROLL_MASK => 'GDK_SCROLL_MASK';
use constant GDK_ALL_EVENTS_MASK => 'GDK_ALL_EVENTS_MASK';
# Gtk2::Gdk::EventType
use constant GDK_NOTHING => 'GDK_NOTHING';
use constant GDK_DELETE => 'GDK_DELETE';
use constant GDK_DESTROY => 'GDK_DESTROY';
use constant GDK_EXPOSE => 'GDK_EXPOSE';
use constant GDK_MOTION_NOTIFY => 'GDK_MOTION_NOTIFY';
use constant GDK_BUTTON_PRESS => 'GDK_BUTTON_PRESS';
use constant GDK_2BUTTON_PRESS => 'GDK_2BUTTON_PRESS';
use constant GDK_3BUTTON_PRESS => 'GDK_3BUTTON_PRESS';
use constant GDK_BUTTON_RELEASE => 'GDK_BUTTON_RELEASE';
use constant GDK_KEY_PRESS => 'GDK_KEY_PRESS';
use constant GDK_KEY_RELEASE => 'GDK_KEY_RELEASE';
use constant GDK_ENTER_NOTIFY => 'GDK_ENTER_NOTIFY';
use constant GDK_LEAVE_NOTIFY => 'GDK_LEAVE_NOTIFY';
use constant GDK_FOCUS_CHANGE => 'GDK_FOCUS_CHANGE';
use constant GDK_CONFIGURE => 'GDK_CONFIGURE';
use constant GDK_MAP => 'GDK_MAP';
use constant GDK_UNMAP => 'GDK_UNMAP';
use constant GDK_PROPERTY_NOTIFY => 'GDK_PROPERTY_NOTIFY';
use constant GDK_SELECTION_CLEAR => 'GDK_SELECTION_CLEAR';
use constant GDK_SELECTION_REQUEST => 'GDK_SELECTION_REQUEST';
use constant GDK_SELECTION_NOTIFY => 'GDK_SELECTION_NOTIFY';
use constant GDK_PROXIMITY_IN => 'GDK_PROXIMITY_IN';
use constant GDK_PROXIMITY_OUT => 'GDK_PROXIMITY_OUT';
use constant GDK_DRAG_ENTER => 'GDK_DRAG_ENTER';
use constant GDK_DRAG_LEAVE => 'GDK_DRAG_LEAVE';
use constant GDK_DRAG_MOTION => 'GDK_DRAG_MOTION';
use constant GDK_DRAG_STATUS => 'GDK_DRAG_STATUS';
use constant GDK_DROP_START => 'GDK_DROP_START';
use constant GDK_DROP_FINISHED => 'GDK_DROP_FINISHED';
use constant GDK_CLIENT_EVENT => 'GDK_CLIENT_EVENT';
use constant GDK_VISIBILITY_NOTIFY => 'GDK_VISIBILITY_NOTIFY';
use constant GDK_NO_EXPOSE => 'GDK_NO_EXPOSE';
use constant GDK_SCROLL => 'GDK_SCROLL';
use constant GDK_WINDOW_STATE => 'GDK_WINDOW_STATE';
use constant GDK_SETTING => 'GDK_SETTING';
# Gtk2::Gdk::ExtensionMode
use constant GDK_EXTENSION_EVENTS_NONE => 'GDK_EXTENSION_EVENTS_NONE';
use constant GDK_EXTENSION_EVENTS_ALL => 'GDK_EXTENSION_EVENTS_ALL';
use constant GDK_EXTENSION_EVENTS_CURSOR => 'GDK_EXTENSION_EVENTS_CURSOR';
# Gtk2::Gdk::Fill
use constant GDK_SOLID => 'GDK_SOLID';
use constant GDK_TILED => 'GDK_TILED';
use constant GDK_STIPPLED => 'GDK_STIPPLED';
use constant GDK_OPAQUE_STIPPLED => 'GDK_OPAQUE_STIPPLED';
# Gtk2::Gdk::FillRule
use constant GDK_EVEN_ODD_RULE => 'GDK_EVEN_ODD_RULE';
use constant GDK_WINDING_RULE => 'GDK_WINDING_RULE';
# Gtk2::Gdk::FilterReturn
use constant GDK_FILTER_CONTINUE => 'GDK_FILTER_CONTINUE';
use constant GDK_FILTER_TRANSLATE => 'GDK_FILTER_TRANSLATE';
use constant GDK_FILTER_REMOVE => 'GDK_FILTER_REMOVE';
# Gtk2::Gdk::FontType
use constant GDK_FONT_FONT => 'GDK_FONT_FONT';
use constant GDK_FONT_FONTSET => 'GDK_FONT_FONTSET';
# Gtk2::Gdk::Function
use constant GDK_COPY => 'GDK_COPY';
use constant GDK_INVERT => 'GDK_INVERT';
use constant GDK_XOR => 'GDK_XOR';
use constant GDK_CLEAR => 'GDK_CLEAR';
use constant GDK_AND => 'GDK_AND';
use constant GDK_AND_REVERSE => 'GDK_AND_REVERSE';
use constant GDK_AND_INVERT => 'GDK_AND_INVERT';
use constant GDK_NOOP => 'GDK_NOOP';
use constant GDK_OR => 'GDK_OR';
use constant GDK_EQUIV => 'GDK_EQUIV';
use constant GDK_OR_REVERSE => 'GDK_OR_REVERSE';
use constant GDK_COPY_INVERT => 'GDK_COPY_INVERT';
use constant GDK_OR_INVERT => 'GDK_OR_INVERT';
use constant GDK_NAND => 'GDK_NAND';
use constant GDK_NOR => 'GDK_NOR';
use constant GDK_SET => 'GDK_SET';
# Gtk2::Gdk::GCValuesMask
use constant GDK_GC_FOREGROUND => 'GDK_GC_FOREGROUND';
use constant GDK_GC_BACKGROUND => 'GDK_GC_BACKGROUND';
use constant GDK_GC_FONT => 'GDK_GC_FONT';
use constant GDK_GC_FUNCTION => 'GDK_GC_FUNCTION';
use constant GDK_GC_FILL => 'GDK_GC_FILL';
use constant GDK_GC_TILE => 'GDK_GC_TILE';
use constant GDK_GC_STIPPLE => 'GDK_GC_STIPPLE';
use constant GDK_GC_CLIP_MASK => 'GDK_GC_CLIP_MASK';
use constant GDK_GC_SUBWINDOW => 'GDK_GC_SUBWINDOW';
use constant GDK_GC_TS_X_ORIGIN => 'GDK_GC_TS_X_ORIGIN';
use constant GDK_GC_TS_Y_ORIGIN => 'GDK_GC_TS_Y_ORIGIN';
use constant GDK_GC_CLIP_X_ORIGIN => 'GDK_GC_CLIP_X_ORIGIN';
use constant GDK_GC_CLIP_Y_ORIGIN => 'GDK_GC_CLIP_Y_ORIGIN';
use constant GDK_GC_EXPOSURES => 'GDK_GC_EXPOSURES';
use constant GDK_GC_LINE_WIDTH => 'GDK_GC_LINE_WIDTH';
use constant GDK_GC_LINE_STYLE => 'GDK_GC_LINE_STYLE';
use constant GDK_GC_CAP_STYLE => 'GDK_GC_CAP_STYLE';
use constant GDK_GC_JOIN_STYLE => 'GDK_GC_JOIN_STYLE';
# Gtk2::Gdk::GrabStatus
use constant GDK_GRAB_SUCCESS => 'GDK_GRAB_SUCCESS';
use constant GDK_GRAB_ALREADY_GRABBED => 'GDK_GRAB_ALREADY_GRABBED';
use constant GDK_GRAB_INVALID_TIME => 'GDK_GRAB_INVALID_TIME';
use constant GDK_GRAB_NOT_VIEWABLE => 'GDK_GRAB_NOT_VIEWABLE';
use constant GDK_GRAB_FROZEN => 'GDK_GRAB_FROZEN';
# Gtk2::Gdk::Gravity
use constant GDK_GRAVITY_NORTH_WEST => 'GDK_GRAVITY_NORTH_WEST';
use constant GDK_GRAVITY_NORTH => 'GDK_GRAVITY_NORTH';
use constant GDK_GRAVITY_NORTH_EAST => 'GDK_GRAVITY_NORTH_EAST';
use constant GDK_GRAVITY_WEST => 'GDK_GRAVITY_WEST';
use constant GDK_GRAVITY_CENTER => 'GDK_GRAVITY_CENTER';
use constant GDK_GRAVITY_EAST => 'GDK_GRAVITY_EAST';
use constant GDK_GRAVITY_SOUTH_WEST => 'GDK_GRAVITY_SOUTH_WEST';
use constant GDK_GRAVITY_SOUTH => 'GDK_GRAVITY_SOUTH';
use constant GDK_GRAVITY_SOUTH_EAST => 'GDK_GRAVITY_SOUTH_EAST';
use constant GDK_GRAVITY_STATIC => 'GDK_GRAVITY_STATIC';
# Gtk2::Gdk::ImageType
use constant GDK_IMAGE_NORMAL => 'GDK_IMAGE_NORMAL';
use constant GDK_IMAGE_SHARED => 'GDK_IMAGE_SHARED';
use constant GDK_IMAGE_FASTEST => 'GDK_IMAGE_FASTEST';
# Gtk2::Gdk::InputCondition
use constant GDK_INPUT_READ => 'GDK_INPUT_READ';
use constant GDK_INPUT_WRITE => 'GDK_INPUT_WRITE';
use constant GDK_INPUT_EXCEPTION => 'GDK_INPUT_EXCEPTION';
# Gtk2::Gdk::InputMode
use constant GDK_MODE_DISABLED => 'GDK_MODE_DISABLED';
use constant GDK_MODE_SCREEN => 'GDK_MODE_SCREEN';
use constant GDK_MODE_WINDOW => 'GDK_MODE_WINDOW';
# Gtk2::Gdk::InputSource
use constant GDK_SOURCE_MOUSE => 'GDK_SOURCE_MOUSE';
use constant GDK_SOURCE_PEN => 'GDK_SOURCE_PEN';
use constant GDK_SOURCE_ERASER => 'GDK_SOURCE_ERASER';
use constant GDK_SOURCE_CURSOR => 'GDK_SOURCE_CURSOR';
# Gtk2::Gdk::InterpType
use constant GDK_INTERP_NEAREST => 'GDK_INTERP_NEAREST';
use constant GDK_INTERP_TILES => 'GDK_INTERP_TILES';
use constant GDK_INTERP_BILINEAR => 'GDK_INTERP_BILINEAR';
use constant GDK_INTERP_HYPER => 'GDK_INTERP_HYPER';
# Gtk2::Gdk::JoinStyle
use constant GDK_JOIN_MITER => 'GDK_JOIN_MITER';
use constant GDK_JOIN_ROUND => 'GDK_JOIN_ROUND';
use constant GDK_JOIN_BEVEL => 'GDK_JOIN_BEVEL';
# Gtk2::Gdk::LineStyle
use constant GDK_LINE_SOLID => 'GDK_LINE_SOLID';
use constant GDK_LINE_ON_OFF_DASH => 'GDK_LINE_ON_OFF_DASH';
use constant GDK_LINE_DOUBLE_DASH => 'GDK_LINE_DOUBLE_DASH';
# Gtk2::Gdk::ModifierType
use constant GDK_SHIFT_MASK => 'GDK_SHIFT_MASK';
use constant GDK_LOCK_MASK => 'GDK_LOCK_MASK';
use constant GDK_CONTROL_MASK => 'GDK_CONTROL_MASK';
use constant GDK_MOD1_MASK => 'GDK_MOD1_MASK';
use constant GDK_MOD2_MASK => 'GDK_MOD2_MASK';
use constant GDK_MOD3_MASK => 'GDK_MOD3_MASK';
use constant GDK_MOD4_MASK => 'GDK_MOD4_MASK';
use constant GDK_MOD5_MASK => 'GDK_MOD5_MASK';
use constant GDK_BUTTON1_MASK => 'GDK_BUTTON1_MASK';
use constant GDK_BUTTON2_MASK => 'GDK_BUTTON2_MASK';
use constant GDK_BUTTON3_MASK => 'GDK_BUTTON3_MASK';
use constant GDK_BUTTON4_MASK => 'GDK_BUTTON4_MASK';
use constant GDK_BUTTON5_MASK => 'GDK_BUTTON5_MASK';
use constant GDK_RELEASE_MASK => 'GDK_RELEASE_MASK';
use constant GDK_MODIFIER_MASK => 'GDK_MODIFIER_MASK';
# Gtk2::Gdk::NotifyType
use constant GDK_NOTIFY_ANCESTOR => 'GDK_NOTIFY_ANCESTOR';
use constant GDK_NOTIFY_VIRTUAL => 'GDK_NOTIFY_VIRTUAL';
use constant GDK_NOTIFY_INFERIOR => 'GDK_NOTIFY_INFERIOR';
use constant GDK_NOTIFY_NONLINEAR => 'GDK_NOTIFY_NONLINEAR';
use constant GDK_NOTIFY_NONLINEAR_VIRTUAL => 'GDK_NOTIFY_NONLINEAR_VIRTUAL';
use constant GDK_NOTIFY_UNKNOWN => 'GDK_NOTIFY_UNKNOWN';
# Gtk2::Gdk::OverlapType
use constant GDK_OVERLAP_RECTANGLE_IN => 'GDK_OVERLAP_RECTANGLE_IN';
use constant GDK_OVERLAP_RECTANGLE_OUT => 'GDK_OVERLAP_RECTANGLE_OUT';
use constant GDK_OVERLAP_RECTANGLE_PART => 'GDK_OVERLAP_RECTANGLE_PART';
# Gtk2::Gdk::PixbufAlphaMode
use constant GDK_PIXBUF_ALPHA_BILEVEL => 'GDK_PIXBUF_ALPHA_BILEVEL';
use constant GDK_PIXBUF_ALPHA_FULL => 'GDK_PIXBUF_ALPHA_FULL';
# Gtk2::Gdk::PixbufError
use constant GDK_PIXBUF_ERROR_CORRUPT_IMAGE => 'GDK_PIXBUF_ERROR_CORRUPT_IMAGE';
use constant GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY => 'GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY';
use constant GDK_PIXBUF_ERROR_BAD_OPTION => 'GDK_PIXBUF_ERROR_BAD_OPTION';
use constant GDK_PIXBUF_ERROR_UNKNOWN_TYPE => 'GDK_PIXBUF_ERROR_UNKNOWN_TYPE';
use constant GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION => 'GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION';
use constant GDK_PIXBUF_ERROR_FAILED => 'GDK_PIXBUF_ERROR_FAILED';
# Gtk2::Gdk::PropertyState
use constant GDK_PROPERTY_NEW_VALUE => 'GDK_PROPERTY_NEW_VALUE';
use constant GDK_PROPERTY_DELETE => 'GDK_PROPERTY_DELETE';
# Gtk2::Gdk::PropMode
use constant GDK_PROP_MODE_REPLACE => 'GDK_PROP_MODE_REPLACE';
use constant GDK_PROP_MODE_PREPEND => 'GDK_PROP_MODE_PREPEND';
use constant GDK_PROP_MODE_APPEND => 'GDK_PROP_MODE_APPEND';
# Gtk2::Gdk::RgbDither
use constant GDK_RGB_DITHER_NONE => 'GDK_RGB_DITHER_NONE';
use constant GDK_RGB_DITHER_NORMAL => 'GDK_RGB_DITHER_NORMAL';
use constant GDK_RGB_DITHER_MAX => 'GDK_RGB_DITHER_MAX';
# Gtk2::Gdk::ScrollDirection
use constant GDK_SCROLL_UP => 'GDK_SCROLL_UP';
use constant GDK_SCROLL_DOWN => 'GDK_SCROLL_DOWN';
use constant GDK_SCROLL_LEFT => 'GDK_SCROLL_LEFT';
use constant GDK_SCROLL_RIGHT => 'GDK_SCROLL_RIGHT';
# Gtk2::Gdk::SettingAction
use constant GDK_SETTING_ACTION_NEW => 'GDK_SETTING_ACTION_NEW';
use constant GDK_SETTING_ACTION_CHANGED => 'GDK_SETTING_ACTION_CHANGED';
use constant GDK_SETTING_ACTION_DELETED => 'GDK_SETTING_ACTION_DELETED';
# Gtk2::Gdk::Status
use constant GDK_OK => 'GDK_OK';
use constant GDK_ERROR => 'GDK_ERROR';
use constant GDK_ERROR_PARAM => 'GDK_ERROR_PARAM';
use constant GDK_ERROR_FILE => 'GDK_ERROR_FILE';
use constant GDK_ERROR_MEM => 'GDK_ERROR_MEM';
# Gtk2::Gdk::SubwindowMode
use constant GDK_CLIP_BY_CHILDREN => 'GDK_CLIP_BY_CHILDREN';
use constant GDK_INCLUDE_INFERIORS => 'GDK_INCLUDE_INFERIORS';
# Gtk2::Gdk::VisibilityState
use constant GDK_VISIBILITY_UNOBSCURED => 'GDK_VISIBILITY_UNOBSCURED';
use constant GDK_VISIBILITY_PARTIAL => 'GDK_VISIBILITY_PARTIAL';
use constant GDK_VISIBILITY_FULLY_OBSCURED => 'GDK_VISIBILITY_FULLY_OBSCURED';
# Gtk2::Gdk::VisualType
use constant GDK_VISUAL_STATIC_GRAY => 'GDK_VISUAL_STATIC_GRAY';
use constant GDK_VISUAL_GRAYSCALE => 'GDK_VISUAL_GRAYSCALE';
use constant GDK_VISUAL_STATIC_COLOR => 'GDK_VISUAL_STATIC_COLOR';
use constant GDK_VISUAL_PSEUDO_COLOR => 'GDK_VISUAL_PSEUDO_COLOR';
use constant GDK_VISUAL_TRUE_COLOR => 'GDK_VISUAL_TRUE_COLOR';
use constant GDK_VISUAL_DIRECT_COLOR => 'GDK_VISUAL_DIRECT_COLOR';
# Gtk2::Gdk::WindowAttributesType
use constant GDK_WA_TITLE => 'GDK_WA_TITLE';
use constant GDK_WA_X => 'GDK_WA_X';
use constant GDK_WA_Y => 'GDK_WA_Y';
use constant GDK_WA_CURSOR => 'GDK_WA_CURSOR';
use constant GDK_WA_COLORMAP => 'GDK_WA_COLORMAP';
use constant GDK_WA_VISUAL => 'GDK_WA_VISUAL';
use constant GDK_WA_WMCLASS => 'GDK_WA_WMCLASS';
use constant GDK_WA_NOREDIR => 'GDK_WA_NOREDIR';
# Gtk2::Gdk::WindowClass
use constant GDK_INPUT_OUTPUT => 'GDK_INPUT_OUTPUT';
use constant GDK_INPUT_ONLY => 'GDK_INPUT_ONLY';
# Gtk2::Gdk::WindowEdge
use constant GDK_WINDOW_EDGE_NORTH_WEST => 'GDK_WINDOW_EDGE_NORTH_WEST';
use constant GDK_WINDOW_EDGE_NORTH => 'GDK_WINDOW_EDGE_NORTH';
use constant GDK_WINDOW_EDGE_NORTH_EAST => 'GDK_WINDOW_EDGE_NORTH_EAST';
use constant GDK_WINDOW_EDGE_WEST => 'GDK_WINDOW_EDGE_WEST';
use constant GDK_WINDOW_EDGE_EAST => 'GDK_WINDOW_EDGE_EAST';
use constant GDK_WINDOW_EDGE_SOUTH_WEST => 'GDK_WINDOW_EDGE_SOUTH_WEST';
use constant GDK_WINDOW_EDGE_SOUTH => 'GDK_WINDOW_EDGE_SOUTH';
use constant GDK_WINDOW_EDGE_SOUTH_EAST => 'GDK_WINDOW_EDGE_SOUTH_EAST';
# Gtk2::Gdk::WindowHints
use constant GDK_HINT_POS => 'GDK_HINT_POS';
use constant GDK_HINT_MIN_SIZE => 'GDK_HINT_MIN_SIZE';
use constant GDK_HINT_MAX_SIZE => 'GDK_HINT_MAX_SIZE';
use constant GDK_HINT_BASE_SIZE => 'GDK_HINT_BASE_SIZE';
use constant GDK_HINT_ASPECT => 'GDK_HINT_ASPECT';
use constant GDK_HINT_RESIZE_INC => 'GDK_HINT_RESIZE_INC';
use constant GDK_HINT_WIN_GRAVITY => 'GDK_HINT_WIN_GRAVITY';
use constant GDK_HINT_USER_POS => 'GDK_HINT_USER_POS';
use constant GDK_HINT_USER_SIZE => 'GDK_HINT_USER_SIZE';
# Gtk2::Gdk::WindowState
use constant GDK_WINDOW_STATE_WITHDRAWN => 'GDK_WINDOW_STATE_WITHDRAWN';
use constant GDK_WINDOW_STATE_ICONIFIED => 'GDK_WINDOW_STATE_ICONIFIED';
use constant GDK_WINDOW_STATE_MAXIMIZED => 'GDK_WINDOW_STATE_MAXIMIZED';
use constant GDK_WINDOW_STATE_STICKY => 'GDK_WINDOW_STATE_STICKY';
use constant GDK_WINDOW_STATE_FULLSCREEN => 'GDK_WINDOW_STATE_FULLSCREEN';
use constant GDK_WINDOW_STATE_ABOVE => 'GDK_WINDOW_STATE_ABOVE';
use constant GDK_WINDOW_STATE_BELOW => 'GDK_WINDOW_STATE_BELOW';
# Gtk2::Gdk::WindowType
use constant GDK_WINDOW_ROOT => 'GDK_WINDOW_ROOT';
use constant GDK_WINDOW_TOPLEVEL => 'GDK_WINDOW_TOPLEVEL';
use constant GDK_WINDOW_CHILD => 'GDK_WINDOW_CHILD';
use constant GDK_WINDOW_DIALOG => 'GDK_WINDOW_DIALOG';
use constant GDK_WINDOW_TEMP => 'GDK_WINDOW_TEMP';
use constant GDK_WINDOW_FOREIGN => 'GDK_WINDOW_FOREIGN';
# Gtk2::Gdk::WindowTypeHint
use constant GDK_WINDOW_TYPE_HINT_NORMAL => 'GDK_WINDOW_TYPE_HINT_NORMAL';
use constant GDK_WINDOW_TYPE_HINT_DIALOG => 'GDK_WINDOW_TYPE_HINT_DIALOG';
use constant GDK_WINDOW_TYPE_HINT_MENU => 'GDK_WINDOW_TYPE_HINT_MENU';
use constant GDK_WINDOW_TYPE_HINT_TOOLBAR => 'GDK_WINDOW_TYPE_HINT_TOOLBAR';
use constant GDK_WINDOW_TYPE_HINT_SPLASHSCREEN => 'GDK_WINDOW_TYPE_HINT_SPLASHSCREEN';
use constant GDK_WINDOW_TYPE_HINT_UTILITY => 'GDK_WINDOW_TYPE_HINT_UTILITY';
use constant GDK_WINDOW_TYPE_HINT_DOCK => 'GDK_WINDOW_TYPE_HINT_DOCK';
use constant GDK_WINDOW_TYPE_HINT_DESKTOP => 'GDK_WINDOW_TYPE_HINT_DESKTOP';
# Gtk2::Gdk::WMDecoration
use constant GDK_DECOR_ALL => 'GDK_DECOR_ALL';
use constant GDK_DECOR_BORDER => 'GDK_DECOR_BORDER';
use constant GDK_DECOR_RESIZEH => 'GDK_DECOR_RESIZEH';
use constant GDK_DECOR_TITLE => 'GDK_DECOR_TITLE';
use constant GDK_DECOR_MENU => 'GDK_DECOR_MENU';
use constant GDK_DECOR_MINIMIZE => 'GDK_DECOR_MINIMIZE';
use constant GDK_DECOR_MAXIMIZE => 'GDK_DECOR_MAXIMIZE';
# Gtk2::Gdk::WMFunction
use constant GDK_FUNC_ALL => 'GDK_FUNC_ALL';
use constant GDK_FUNC_RESIZE => 'GDK_FUNC_RESIZE';
use constant GDK_FUNC_MOVE => 'GDK_FUNC_MOVE';
use constant GDK_FUNC_MINIMIZE => 'GDK_FUNC_MINIMIZE';
use constant GDK_FUNC_MAXIMIZE => 'GDK_FUNC_MAXIMIZE';
use constant GDK_FUNC_CLOSE => 'GDK_FUNC_CLOSE';
# Gtk2::AccelFlags
use constant GTK_ACCEL_VISIBLE => 'GTK_ACCEL_VISIBLE';
use constant GTK_ACCEL_LOCKED => 'GTK_ACCEL_LOCKED';
use constant GTK_ACCEL_MASK => 'GTK_ACCEL_MASK';
# Gtk2::AnchorType
use constant GTK_ANCHOR_CENTER => 'GTK_ANCHOR_CENTER';
use constant GTK_ANCHOR_NORTH => 'GTK_ANCHOR_NORTH';
use constant GTK_ANCHOR_NORTH_WEST => 'GTK_ANCHOR_NORTH_WEST';
use constant GTK_ANCHOR_NORTH_EAST => 'GTK_ANCHOR_NORTH_EAST';
use constant GTK_ANCHOR_SOUTH => 'GTK_ANCHOR_SOUTH';
use constant GTK_ANCHOR_SOUTH_WEST => 'GTK_ANCHOR_SOUTH_WEST';
use constant GTK_ANCHOR_SOUTH_EAST => 'GTK_ANCHOR_SOUTH_EAST';
use constant GTK_ANCHOR_WEST => 'GTK_ANCHOR_WEST';
use constant GTK_ANCHOR_EAST => 'GTK_ANCHOR_EAST';
use constant GTK_ANCHOR_N => 'GTK_ANCHOR_N';
use constant GTK_ANCHOR_NW => 'GTK_ANCHOR_NW';
use constant GTK_ANCHOR_NE => 'GTK_ANCHOR_NE';
use constant GTK_ANCHOR_S => 'GTK_ANCHOR_S';
use constant GTK_ANCHOR_SW => 'GTK_ANCHOR_SW';
use constant GTK_ANCHOR_SE => 'GTK_ANCHOR_SE';
use constant GTK_ANCHOR_W => 'GTK_ANCHOR_W';
use constant GTK_ANCHOR_E => 'GTK_ANCHOR_E';
# Gtk2::ArgFlags
use constant GTK_ARG_READABLE => 'GTK_ARG_READABLE';
use constant GTK_ARG_WRITABLE => 'GTK_ARG_WRITABLE';
use constant GTK_ARG_CONSTRUCT => 'GTK_ARG_CONSTRUCT';
use constant GTK_ARG_CONSTRUCT_ONLY => 'GTK_ARG_CONSTRUCT_ONLY';
use constant GTK_ARG_CHILD_ARG => 'GTK_ARG_CHILD_ARG';
# Gtk2::ArrowType
use constant GTK_ARROW_UP => 'GTK_ARROW_UP';
use constant GTK_ARROW_DOWN => 'GTK_ARROW_DOWN';
use constant GTK_ARROW_LEFT => 'GTK_ARROW_LEFT';
use constant GTK_ARROW_RIGHT => 'GTK_ARROW_RIGHT';
# Gtk2::AttachOptions
use constant GTK_EXPAND => 'GTK_EXPAND';
use constant GTK_SHRINK => 'GTK_SHRINK';
use constant GTK_FILL => 'GTK_FILL';
# Gtk2::ButtonBoxStyle
use constant GTK_BUTTONBOX_DEFAULT_STYLE => 'GTK_BUTTONBOX_DEFAULT_STYLE';
use constant GTK_BUTTONBOX_SPREAD => 'GTK_BUTTONBOX_SPREAD';
use constant GTK_BUTTONBOX_EDGE => 'GTK_BUTTONBOX_EDGE';
use constant GTK_BUTTONBOX_START => 'GTK_BUTTONBOX_START';
use constant GTK_BUTTONBOX_END => 'GTK_BUTTONBOX_END';
# Gtk2::ButtonsType
use constant GTK_BUTTONS_NONE => 'GTK_BUTTONS_NONE';
use constant GTK_BUTTONS_OK => 'GTK_BUTTONS_OK';
use constant GTK_BUTTONS_CLOSE => 'GTK_BUTTONS_CLOSE';
use constant GTK_BUTTONS_CANCEL => 'GTK_BUTTONS_CANCEL';
use constant GTK_BUTTONS_YES_NO => 'GTK_BUTTONS_YES_NO';
use constant GTK_BUTTONS_OK_CANCEL => 'GTK_BUTTONS_OK_CANCEL';
# Gtk2::CalendarDisplayOptions
use constant GTK_CALENDAR_SHOW_HEADING => 'GTK_CALENDAR_SHOW_HEADING';
use constant GTK_CALENDAR_SHOW_DAY_NAMES => 'GTK_CALENDAR_SHOW_DAY_NAMES';
use constant GTK_CALENDAR_NO_MONTH_CHANGE => 'GTK_CALENDAR_NO_MONTH_CHANGE';
use constant GTK_CALENDAR_SHOW_WEEK_NUMBERS => 'GTK_CALENDAR_SHOW_WEEK_NUMBERS';
use constant GTK_CALENDAR_WEEK_START_MONDAY => 'GTK_CALENDAR_WEEK_START_MONDAY';
# Gtk2::CellRendererMode
use constant GTK_CELL_RENDERER_MODE_INERT => 'GTK_CELL_RENDERER_MODE_INERT';
use constant GTK_CELL_RENDERER_MODE_ACTIVATABLE => 'GTK_CELL_RENDERER_MODE_ACTIVATABLE';
use constant GTK_CELL_RENDERER_MODE_EDITABLE => 'GTK_CELL_RENDERER_MODE_EDITABLE';
# Gtk2::CellRendererState
use constant GTK_CELL_RENDERER_SELECTED => 'GTK_CELL_RENDERER_SELECTED';
use constant GTK_CELL_RENDERER_PRELIT => 'GTK_CELL_RENDERER_PRELIT';
use constant GTK_CELL_RENDERER_INSENSITIVE => 'GTK_CELL_RENDERER_INSENSITIVE';
use constant GTK_CELL_RENDERER_SORTED => 'GTK_CELL_RENDERER_SORTED';
use constant GTK_CELL_RENDERER_FOCUSED => 'GTK_CELL_RENDERER_FOCUSED';
# Gtk2::CornerType
use constant GTK_CORNER_TOP_LEFT => 'GTK_CORNER_TOP_LEFT';
use constant GTK_CORNER_BOTTOM_LEFT => 'GTK_CORNER_BOTTOM_LEFT';
use constant GTK_CORNER_TOP_RIGHT => 'GTK_CORNER_TOP_RIGHT';
use constant GTK_CORNER_BOTTOM_RIGHT => 'GTK_CORNER_BOTTOM_RIGHT';
# Gtk2::CurveType
use constant GTK_CURVE_TYPE_LINEAR => 'GTK_CURVE_TYPE_LINEAR';
use constant GTK_CURVE_TYPE_SPLINE => 'GTK_CURVE_TYPE_SPLINE';
use constant GTK_CURVE_TYPE_FREE => 'GTK_CURVE_TYPE_FREE';
# Gtk2::DebugFlag
use constant GTK_DEBUG_MISC => 'GTK_DEBUG_MISC';
use constant GTK_DEBUG_PLUGSOCKET => 'GTK_DEBUG_PLUGSOCKET';
use constant GTK_DEBUG_TEXT => 'GTK_DEBUG_TEXT';
use constant GTK_DEBUG_TREE => 'GTK_DEBUG_TREE';
use constant GTK_DEBUG_UPDATES => 'GTK_DEBUG_UPDATES';
use constant GTK_DEBUG_KEYBINDINGS => 'GTK_DEBUG_KEYBINDINGS';
use constant GTK_DEBUG_MULTIHEAD => 'GTK_DEBUG_MULTIHEAD';
# Gtk2::DeleteType
use constant GTK_DELETE_CHARS => 'GTK_DELETE_CHARS';
use constant GTK_DELETE_WORD_ENDS => 'GTK_DELETE_WORD_ENDS';
use constant GTK_DELETE_WORDS => 'GTK_DELETE_WORDS';
use constant GTK_DELETE_DISPLAY_LINES => 'GTK_DELETE_DISPLAY_LINES';
use constant GTK_DELETE_DISPLAY_LINE_ENDS => 'GTK_DELETE_DISPLAY_LINE_ENDS';
use constant GTK_DELETE_PARAGRAPH_ENDS => 'GTK_DELETE_PARAGRAPH_ENDS';
use constant GTK_DELETE_PARAGRAPHS => 'GTK_DELETE_PARAGRAPHS';
use constant GTK_DELETE_WHITESPACE => 'GTK_DELETE_WHITESPACE';
# Gtk2::DestDefaults
use constant GTK_DEST_DEFAULT_MOTION => 'GTK_DEST_DEFAULT_MOTION';
use constant GTK_DEST_DEFAULT_HIGHLIGHT => 'GTK_DEST_DEFAULT_HIGHLIGHT';
use constant GTK_DEST_DEFAULT_DROP => 'GTK_DEST_DEFAULT_DROP';
use constant GTK_DEST_DEFAULT_ALL => 'GTK_DEST_DEFAULT_ALL';
# Gtk2::DialogFlags
use constant GTK_DIALOG_MODAL => 'GTK_DIALOG_MODAL';
use constant GTK_DIALOG_DESTROY_WITH_PARENT => 'GTK_DIALOG_DESTROY_WITH_PARENT';
use constant GTK_DIALOG_NO_SEPARATOR => 'GTK_DIALOG_NO_SEPARATOR';
# Gtk2::DirectionType
use constant GTK_DIR_TAB_FORWARD => 'GTK_DIR_TAB_FORWARD';
use constant GTK_DIR_TAB_BACKWARD => 'GTK_DIR_TAB_BACKWARD';
use constant GTK_DIR_UP => 'GTK_DIR_UP';
use constant GTK_DIR_DOWN => 'GTK_DIR_DOWN';
use constant GTK_DIR_LEFT => 'GTK_DIR_LEFT';
use constant GTK_DIR_RIGHT => 'GTK_DIR_RIGHT';
# Gtk2::ExpanderStyle
use constant GTK_EXPANDER_COLLAPSED => 'GTK_EXPANDER_COLLAPSED';
use constant GTK_EXPANDER_SEMI_COLLAPSED => 'GTK_EXPANDER_SEMI_COLLAPSED';
use constant GTK_EXPANDER_SEMI_EXPANDED => 'GTK_EXPANDER_SEMI_EXPANDED';
use constant GTK_EXPANDER_EXPANDED => 'GTK_EXPANDER_EXPANDED';
# Gtk2::IconSize
use constant GTK_ICON_SIZE_INVALID => 'GTK_ICON_SIZE_INVALID';
use constant GTK_ICON_SIZE_MENU => 'GTK_ICON_SIZE_MENU';
use constant GTK_ICON_SIZE_SMALL_TOOLBAR => 'GTK_ICON_SIZE_SMALL_TOOLBAR';
use constant GTK_ICON_SIZE_LARGE_TOOLBAR => 'GTK_ICON_SIZE_LARGE_TOOLBAR';
use constant GTK_ICON_SIZE_BUTTON => 'GTK_ICON_SIZE_BUTTON';
use constant GTK_ICON_SIZE_DND => 'GTK_ICON_SIZE_DND';
use constant GTK_ICON_SIZE_DIALOG => 'GTK_ICON_SIZE_DIALOG';
# Gtk2::ImageType
use constant GTK_IMAGE_EMPTY => 'GTK_IMAGE_EMPTY';
use constant GTK_IMAGE_PIXMAP => 'GTK_IMAGE_PIXMAP';
use constant GTK_IMAGE_IMAGE => 'GTK_IMAGE_IMAGE';
use constant GTK_IMAGE_PIXBUF => 'GTK_IMAGE_PIXBUF';
use constant GTK_IMAGE_STOCK => 'GTK_IMAGE_STOCK';
use constant GTK_IMAGE_ICON_SET => 'GTK_IMAGE_ICON_SET';
use constant GTK_IMAGE_ANIMATION => 'GTK_IMAGE_ANIMATION';
# Gtk2::IMPreeditStyle
use constant GTK_IM_PREEDIT_NOTHING => 'GTK_IM_PREEDIT_NOTHING';
use constant GTK_IM_PREEDIT_CALLBACK => 'GTK_IM_PREEDIT_CALLBACK';
use constant GTK_IM_PREEDIT_NONE => 'GTK_IM_PREEDIT_NONE';
# Gtk2::IMStatusStyle
use constant GTK_IM_STATUS_NOTHING => 'GTK_IM_STATUS_NOTHING';
use constant GTK_IM_STATUS_CALLBACK => 'GTK_IM_STATUS_CALLBACK';
use constant GTK_IM_STATUS_NONE => 'GTK_IM_STATUS_NONE';
# Gtk2::Justification
use constant GTK_JUSTIFY_LEFT => 'GTK_JUSTIFY_LEFT';
use constant GTK_JUSTIFY_RIGHT => 'GTK_JUSTIFY_RIGHT';
use constant GTK_JUSTIFY_CENTER => 'GTK_JUSTIFY_CENTER';
use constant GTK_JUSTIFY_FILL => 'GTK_JUSTIFY_FILL';
# Gtk2::MatchType
use constant GTK_MATCH_ALL => 'GTK_MATCH_ALL';
use constant GTK_MATCH_ALL_TAIL => 'GTK_MATCH_ALL_TAIL';
use constant GTK_MATCH_HEAD => 'GTK_MATCH_HEAD';
use constant GTK_MATCH_TAIL => 'GTK_MATCH_TAIL';
use constant GTK_MATCH_EXACT => 'GTK_MATCH_EXACT';
use constant GTK_MATCH_LAST => 'GTK_MATCH_LAST';
# Gtk2::MenuDirectionType
use constant GTK_MENU_DIR_PARENT => 'GTK_MENU_DIR_PARENT';
use constant GTK_MENU_DIR_CHILD => 'GTK_MENU_DIR_CHILD';
use constant GTK_MENU_DIR_NEXT => 'GTK_MENU_DIR_NEXT';
use constant GTK_MENU_DIR_PREV => 'GTK_MENU_DIR_PREV';
# Gtk2::MessageType
use constant GTK_MESSAGE_INFO => 'GTK_MESSAGE_INFO';
use constant GTK_MESSAGE_WARNING => 'GTK_MESSAGE_WARNING';
use constant GTK_MESSAGE_QUESTION => 'GTK_MESSAGE_QUESTION';
use constant GTK_MESSAGE_ERROR => 'GTK_MESSAGE_ERROR';
# Gtk2::MetricType
use constant GTK_PIXELS => 'GTK_PIXELS';
use constant GTK_INCHES => 'GTK_INCHES';
use constant GTK_CENTIMETERS => 'GTK_CENTIMETERS';
# Gtk2::MovementStep
use constant GTK_MOVEMENT_LOGICAL_POSITIONS => 'GTK_MOVEMENT_LOGICAL_POSITIONS';
use constant GTK_MOVEMENT_VISUAL_POSITIONS => 'GTK_MOVEMENT_VISUAL_POSITIONS';
use constant GTK_MOVEMENT_WORDS => 'GTK_MOVEMENT_WORDS';
use constant GTK_MOVEMENT_DISPLAY_LINES => 'GTK_MOVEMENT_DISPLAY_LINES';
use constant GTK_MOVEMENT_DISPLAY_LINE_ENDS => 'GTK_MOVEMENT_DISPLAY_LINE_ENDS';
use constant GTK_MOVEMENT_PARAGRAPHS => 'GTK_MOVEMENT_PARAGRAPHS';
use constant GTK_MOVEMENT_PARAGRAPH_ENDS => 'GTK_MOVEMENT_PARAGRAPH_ENDS';
use constant GTK_MOVEMENT_PAGES => 'GTK_MOVEMENT_PAGES';
use constant GTK_MOVEMENT_BUFFER_ENDS => 'GTK_MOVEMENT_BUFFER_ENDS';
use constant GTK_MOVEMENT_HORIZONTAL_PAGES => 'GTK_MOVEMENT_HORIZONTAL_PAGES';
# Gtk2::NotebookTab
use constant GTK_NOTEBOOK_TAB_FIRST => 'GTK_NOTEBOOK_TAB_FIRST';
use constant GTK_NOTEBOOK_TAB_LAST => 'GTK_NOTEBOOK_TAB_LAST';
# Gtk2::ObjectFlags
use constant GTK_IN_DESTRUCTION => 'GTK_IN_DESTRUCTION';
use constant GTK_FLOATING => 'GTK_FLOATING';
use constant GTK_RESERVED_1 => 'GTK_RESERVED_1';
use constant GTK_RESERVED_2 => 'GTK_RESERVED_2';
# Gtk2::Orientation
use constant GTK_ORIENTATION_HORIZONTAL => 'GTK_ORIENTATION_HORIZONTAL';
use constant GTK_ORIENTATION_VERTICAL => 'GTK_ORIENTATION_VERTICAL';
# Gtk2::PackType
use constant GTK_PACK_START => 'GTK_PACK_START';
use constant GTK_PACK_END => 'GTK_PACK_END';
# Gtk2::PathPriorityType
use constant GTK_PATH_PRIO_LOWEST => 'GTK_PATH_PRIO_LOWEST';
use constant GTK_PATH_PRIO_GTK => 'GTK_PATH_PRIO_GTK';
use constant GTK_PATH_PRIO_APPLICATION => 'GTK_PATH_PRIO_APPLICATION';
use constant GTK_PATH_PRIO_THEME => 'GTK_PATH_PRIO_THEME';
use constant GTK_PATH_PRIO_RC => 'GTK_PATH_PRIO_RC';
use constant GTK_PATH_PRIO_HIGHEST => 'GTK_PATH_PRIO_HIGHEST';
# Gtk2::PathType
use constant GTK_PATH_WIDGET => 'GTK_PATH_WIDGET';
use constant GTK_PATH_WIDGET_CLASS => 'GTK_PATH_WIDGET_CLASS';
use constant GTK_PATH_CLASS => 'GTK_PATH_CLASS';
# Gtk2::PolicyType
use constant GTK_POLICY_ALWAYS => 'GTK_POLICY_ALWAYS';
use constant GTK_POLICY_AUTOMATIC => 'GTK_POLICY_AUTOMATIC';
use constant GTK_POLICY_NEVER => 'GTK_POLICY_NEVER';
# Gtk2::PositionType
use constant GTK_POS_LEFT => 'GTK_POS_LEFT';
use constant GTK_POS_RIGHT => 'GTK_POS_RIGHT';
use constant GTK_POS_TOP => 'GTK_POS_TOP';
use constant GTK_POS_BOTTOM => 'GTK_POS_BOTTOM';
# Gtk2::PreviewType
use constant GTK_PREVIEW_COLOR => 'GTK_PREVIEW_COLOR';
use constant GTK_PREVIEW_GRAYSCALE => 'GTK_PREVIEW_GRAYSCALE';
# Gtk2::PrivateFlags
use constant GTK_USER_STYLE => 'GTK_USER_STYLE';
use constant GTK_RESIZE_PENDING => 'GTK_RESIZE_PENDING';
use constant GTK_LEAVE_PENDING => 'GTK_LEAVE_PENDING';
use constant GTK_HAS_SHAPE_MASK => 'GTK_HAS_SHAPE_MASK';
use constant GTK_IN_REPARENT => 'GTK_IN_REPARENT';
use constant GTK_DIRECTION_SET => 'GTK_DIRECTION_SET';
use constant GTK_DIRECTION_LTR => 'GTK_DIRECTION_LTR';
use constant GTK_ANCHORED => 'GTK_ANCHORED';
use constant GTK_CHILD_VISIBLE => 'GTK_CHILD_VISIBLE';
use constant GTK_REDRAW_ON_ALLOC => 'GTK_REDRAW_ON_ALLOC';
use constant GTK_ALLOC_NEEDED => 'GTK_ALLOC_NEEDED';
use constant GTK_REQUEST_NEEDED => 'GTK_REQUEST_NEEDED';
# Gtk2::ProgressBarOrientation
use constant GTK_PROGRESS_LEFT_TO_RIGHT => 'GTK_PROGRESS_LEFT_TO_RIGHT';
use constant GTK_PROGRESS_RIGHT_TO_LEFT => 'GTK_PROGRESS_RIGHT_TO_LEFT';
use constant GTK_PROGRESS_BOTTOM_TO_TOP => 'GTK_PROGRESS_BOTTOM_TO_TOP';
use constant GTK_PROGRESS_TOP_TO_BOTTOM => 'GTK_PROGRESS_TOP_TO_BOTTOM';
# Gtk2::ProgressBarStyle
use constant GTK_PROGRESS_CONTINUOUS => 'GTK_PROGRESS_CONTINUOUS';
use constant GTK_PROGRESS_DISCRETE => 'GTK_PROGRESS_DISCRETE';
# Gtk2::RcFlags
use constant GTK_RC_FG => 'GTK_RC_FG';
use constant GTK_RC_BG => 'GTK_RC_BG';
use constant GTK_RC_TEXT => 'GTK_RC_TEXT';
use constant GTK_RC_BASE => 'GTK_RC_BASE';
# Gtk2::RcTokenType
use constant GTK_RC_TOKEN_INVALID => 'GTK_RC_TOKEN_INVALID';
use constant GTK_RC_TOKEN_INCLUDE => 'GTK_RC_TOKEN_INCLUDE';
use constant GTK_RC_TOKEN_NORMAL => 'GTK_RC_TOKEN_NORMAL';
use constant GTK_RC_TOKEN_ACTIVE => 'GTK_RC_TOKEN_ACTIVE';
use constant GTK_RC_TOKEN_PRELIGHT => 'GTK_RC_TOKEN_PRELIGHT';
use constant GTK_RC_TOKEN_SELECTED => 'GTK_RC_TOKEN_SELECTED';
use constant GTK_RC_TOKEN_INSENSITIVE => 'GTK_RC_TOKEN_INSENSITIVE';
use constant GTK_RC_TOKEN_FG => 'GTK_RC_TOKEN_FG';
use constant GTK_RC_TOKEN_BG => 'GTK_RC_TOKEN_BG';
use constant GTK_RC_TOKEN_TEXT => 'GTK_RC_TOKEN_TEXT';
use constant GTK_RC_TOKEN_BASE => 'GTK_RC_TOKEN_BASE';
use constant GTK_RC_TOKEN_XTHICKNESS => 'GTK_RC_TOKEN_XTHICKNESS';
use constant GTK_RC_TOKEN_YTHICKNESS => 'GTK_RC_TOKEN_YTHICKNESS';
use constant GTK_RC_TOKEN_FONT => 'GTK_RC_TOKEN_FONT';
use constant GTK_RC_TOKEN_FONTSET => 'GTK_RC_TOKEN_FONTSET';
use constant GTK_RC_TOKEN_FONT_NAME => 'GTK_RC_TOKEN_FONT_NAME';
use constant GTK_RC_TOKEN_BG_PIXMAP => 'GTK_RC_TOKEN_BG_PIXMAP';
use constant GTK_RC_TOKEN_PIXMAP_PATH => 'GTK_RC_TOKEN_PIXMAP_PATH';
use constant GTK_RC_TOKEN_STYLE => 'GTK_RC_TOKEN_STYLE';
use constant GTK_RC_TOKEN_BINDING => 'GTK_RC_TOKEN_BINDING';
use constant GTK_RC_TOKEN_BIND => 'GTK_RC_TOKEN_BIND';
use constant GTK_RC_TOKEN_WIDGET => 'GTK_RC_TOKEN_WIDGET';
use constant GTK_RC_TOKEN_WIDGET_CLASS => 'GTK_RC_TOKEN_WIDGET_CLASS';
use constant GTK_RC_TOKEN_CLASS => 'GTK_RC_TOKEN_CLASS';
use constant GTK_RC_TOKEN_LOWEST => 'GTK_RC_TOKEN_LOWEST';
use constant GTK_RC_TOKEN_GTK => 'GTK_RC_TOKEN_GTK';
use constant GTK_RC_TOKEN_APPLICATION => 'GTK_RC_TOKEN_APPLICATION';
use constant GTK_RC_TOKEN_THEME => 'GTK_RC_TOKEN_THEME';
use constant GTK_RC_TOKEN_RC => 'GTK_RC_TOKEN_RC';
use constant GTK_RC_TOKEN_HIGHEST => 'GTK_RC_TOKEN_HIGHEST';
use constant GTK_RC_TOKEN_ENGINE => 'GTK_RC_TOKEN_ENGINE';
use constant GTK_RC_TOKEN_MODULE_PATH => 'GTK_RC_TOKEN_MODULE_PATH';
use constant GTK_RC_TOKEN_IM_MODULE_PATH => 'GTK_RC_TOKEN_IM_MODULE_PATH';
use constant GTK_RC_TOKEN_IM_MODULE_FILE => 'GTK_RC_TOKEN_IM_MODULE_FILE';
use constant GTK_RC_TOKEN_STOCK => 'GTK_RC_TOKEN_STOCK';
use constant GTK_RC_TOKEN_LTR => 'GTK_RC_TOKEN_LTR';
use constant GTK_RC_TOKEN_RTL => 'GTK_RC_TOKEN_RTL';
use constant GTK_RC_TOKEN_LAST => 'GTK_RC_TOKEN_LAST';
# Gtk2::ReliefStyle
use constant GTK_RELIEF_NORMAL => 'GTK_RELIEF_NORMAL';
use constant GTK_RELIEF_HALF => 'GTK_RELIEF_HALF';
use constant GTK_RELIEF_NONE => 'GTK_RELIEF_NONE';
# Gtk2::ResizeMode
use constant GTK_RESIZE_PARENT => 'GTK_RESIZE_PARENT';
use constant GTK_RESIZE_QUEUE => 'GTK_RESIZE_QUEUE';
use constant GTK_RESIZE_IMMEDIATE => 'GTK_RESIZE_IMMEDIATE';
# Gtk2::ResponseType
use constant GTK_RESPONSE_NONE => 'GTK_RESPONSE_NONE';
use constant GTK_RESPONSE_REJECT => 'GTK_RESPONSE_REJECT';
use constant GTK_RESPONSE_ACCEPT => 'GTK_RESPONSE_ACCEPT';
use constant GTK_RESPONSE_DELETE_EVENT => 'GTK_RESPONSE_DELETE_EVENT';
use constant GTK_RESPONSE_OK => 'GTK_RESPONSE_OK';
use constant GTK_RESPONSE_CANCEL => 'GTK_RESPONSE_CANCEL';
use constant GTK_RESPONSE_CLOSE => 'GTK_RESPONSE_CLOSE';
use constant GTK_RESPONSE_YES => 'GTK_RESPONSE_YES';
use constant GTK_RESPONSE_NO => 'GTK_RESPONSE_NO';
use constant GTK_RESPONSE_APPLY => 'GTK_RESPONSE_APPLY';
use constant GTK_RESPONSE_HELP => 'GTK_RESPONSE_HELP';
# Gtk2::ScrollType
use constant GTK_SCROLL_NONE => 'GTK_SCROLL_NONE';
use constant GTK_SCROLL_JUMP => 'GTK_SCROLL_JUMP';
use constant GTK_SCROLL_STEP_BACKWARD => 'GTK_SCROLL_STEP_BACKWARD';
use constant GTK_SCROLL_STEP_FORWARD => 'GTK_SCROLL_STEP_FORWARD';
use constant GTK_SCROLL_PAGE_BACKWARD => 'GTK_SCROLL_PAGE_BACKWARD';
use constant GTK_SCROLL_PAGE_FORWARD => 'GTK_SCROLL_PAGE_FORWARD';
use constant GTK_SCROLL_STEP_UP => 'GTK_SCROLL_STEP_UP';
use constant GTK_SCROLL_STEP_DOWN => 'GTK_SCROLL_STEP_DOWN';
use constant GTK_SCROLL_PAGE_UP => 'GTK_SCROLL_PAGE_UP';
use constant GTK_SCROLL_PAGE_DOWN => 'GTK_SCROLL_PAGE_DOWN';
use constant GTK_SCROLL_STEP_LEFT => 'GTK_SCROLL_STEP_LEFT';
use constant GTK_SCROLL_STEP_RIGHT => 'GTK_SCROLL_STEP_RIGHT';
use constant GTK_SCROLL_PAGE_LEFT => 'GTK_SCROLL_PAGE_LEFT';
use constant GTK_SCROLL_PAGE_RIGHT => 'GTK_SCROLL_PAGE_RIGHT';
use constant GTK_SCROLL_START => 'GTK_SCROLL_START';
use constant GTK_SCROLL_END => 'GTK_SCROLL_END';
# Gtk2::SelectionMode
use constant GTK_SELECTION_NONE => 'GTK_SELECTION_NONE';
use constant GTK_SELECTION_SINGLE => 'GTK_SELECTION_SINGLE';
use constant GTK_SELECTION_BROWSE => 'GTK_SELECTION_BROWSE';
use constant GTK_SELECTION_MULTIPLE => 'GTK_SELECTION_MULTIPLE';
use constant GTK_SELECTION_EXTENDED => 'GTK_SELECTION_EXTENDED';
# Gtk2::ShadowType
use constant GTK_SHADOW_NONE => 'GTK_SHADOW_NONE';
use constant GTK_SHADOW_IN => 'GTK_SHADOW_IN';
use constant GTK_SHADOW_OUT => 'GTK_SHADOW_OUT';
use constant GTK_SHADOW_ETCHED_IN => 'GTK_SHADOW_ETCHED_IN';
use constant GTK_SHADOW_ETCHED_OUT => 'GTK_SHADOW_ETCHED_OUT';
# Gtk2::SideType
use constant GTK_SIDE_TOP => 'GTK_SIDE_TOP';
use constant GTK_SIDE_BOTTOM => 'GTK_SIDE_BOTTOM';
use constant GTK_SIDE_LEFT => 'GTK_SIDE_LEFT';
use constant GTK_SIDE_RIGHT => 'GTK_SIDE_RIGHT';
# Gtk2::SignalRunType
use constant GTK_RUN_FIRST => 'GTK_RUN_FIRST';
use constant GTK_RUN_LAST => 'GTK_RUN_LAST';
use constant GTK_RUN_BOTH => 'GTK_RUN_BOTH';
use constant GTK_RUN_NO_RECURSE => 'GTK_RUN_NO_RECURSE';
use constant GTK_RUN_ACTION => 'GTK_RUN_ACTION';
use constant GTK_RUN_NO_HOOKS => 'GTK_RUN_NO_HOOKS';
# Gtk2::SizeGroupMode
use constant GTK_SIZE_GROUP_NONE => 'GTK_SIZE_GROUP_NONE';
use constant GTK_SIZE_GROUP_HORIZONTAL => 'GTK_SIZE_GROUP_HORIZONTAL';
use constant GTK_SIZE_GROUP_VERTICAL => 'GTK_SIZE_GROUP_VERTICAL';
use constant GTK_SIZE_GROUP_BOTH => 'GTK_SIZE_GROUP_BOTH';
# Gtk2::SortType
use constant GTK_SORT_ASCENDING => 'GTK_SORT_ASCENDING';
use constant GTK_SORT_DESCENDING => 'GTK_SORT_DESCENDING';
# Gtk2::SpinButtonUpdatePolicy
use constant GTK_UPDATE_ALWAYS => 'GTK_UPDATE_ALWAYS';
use constant GTK_UPDATE_IF_VALID => 'GTK_UPDATE_IF_VALID';
# Gtk2::SpinType
use constant GTK_SPIN_STEP_FORWARD => 'GTK_SPIN_STEP_FORWARD';
use constant GTK_SPIN_STEP_BACKWARD => 'GTK_SPIN_STEP_BACKWARD';
use constant GTK_SPIN_PAGE_FORWARD => 'GTK_SPIN_PAGE_FORWARD';
use constant GTK_SPIN_PAGE_BACKWARD => 'GTK_SPIN_PAGE_BACKWARD';
use constant GTK_SPIN_HOME => 'GTK_SPIN_HOME';
use constant GTK_SPIN_END => 'GTK_SPIN_END';
use constant GTK_SPIN_USER_DEFINED => 'GTK_SPIN_USER_DEFINED';
# Gtk2::StateType
use constant GTK_STATE_NORMAL => 'GTK_STATE_NORMAL';
use constant GTK_STATE_ACTIVE => 'GTK_STATE_ACTIVE';
use constant GTK_STATE_PRELIGHT => 'GTK_STATE_PRELIGHT';
use constant GTK_STATE_SELECTED => 'GTK_STATE_SELECTED';
use constant GTK_STATE_INSENSITIVE => 'GTK_STATE_INSENSITIVE';
# Gtk2::SubmenuDirection
use constant GTK_DIRECTION_LEFT => 'GTK_DIRECTION_LEFT';
use constant GTK_DIRECTION_RIGHT => 'GTK_DIRECTION_RIGHT';
# Gtk2::SubmenuPlacement
use constant GTK_TOP_BOTTOM => 'GTK_TOP_BOTTOM';
use constant GTK_LEFT_RIGHT => 'GTK_LEFT_RIGHT';
# Gtk2::TargetFlags
use constant GTK_TARGET_SAME_APP => 'GTK_TARGET_SAME_APP';
use constant GTK_TARGET_SAME_WIDGET => 'GTK_TARGET_SAME_WIDGET';
# Gtk2::TextDirection
use constant GTK_TEXT_DIR_NONE => 'GTK_TEXT_DIR_NONE';
use constant GTK_TEXT_DIR_LTR => 'GTK_TEXT_DIR_LTR';
use constant GTK_TEXT_DIR_RTL => 'GTK_TEXT_DIR_RTL';
# Gtk2::TextSearchFlags
use constant GTK_TEXT_SEARCH_VISIBLE_ONLY => 'GTK_TEXT_SEARCH_VISIBLE_ONLY';
use constant GTK_TEXT_SEARCH_TEXT_ONLY => 'GTK_TEXT_SEARCH_TEXT_ONLY';
# Gtk2::TextWindowType
use constant GTK_TEXT_WINDOW_PRIVATE => 'GTK_TEXT_WINDOW_PRIVATE';
use constant GTK_TEXT_WINDOW_WIDGET => 'GTK_TEXT_WINDOW_WIDGET';
use constant GTK_TEXT_WINDOW_TEXT => 'GTK_TEXT_WINDOW_TEXT';
use constant GTK_TEXT_WINDOW_LEFT => 'GTK_TEXT_WINDOW_LEFT';
use constant GTK_TEXT_WINDOW_RIGHT => 'GTK_TEXT_WINDOW_RIGHT';
use constant GTK_TEXT_WINDOW_TOP => 'GTK_TEXT_WINDOW_TOP';
use constant GTK_TEXT_WINDOW_BOTTOM => 'GTK_TEXT_WINDOW_BOTTOM';
# Gtk2::ToolbarChildType
use constant GTK_TOOLBAR_CHILD_SPACE => 'GTK_TOOLBAR_CHILD_SPACE';
use constant GTK_TOOLBAR_CHILD_BUTTON => 'GTK_TOOLBAR_CHILD_BUTTON';
use constant GTK_TOOLBAR_CHILD_TOGGLEBUTTON => 'GTK_TOOLBAR_CHILD_TOGGLEBUTTON';
use constant GTK_TOOLBAR_CHILD_RADIOBUTTON => 'GTK_TOOLBAR_CHILD_RADIOBUTTON';
use constant GTK_TOOLBAR_CHILD_WIDGET => 'GTK_TOOLBAR_CHILD_WIDGET';
# Gtk2::ToolbarSpaceStyle
use constant GTK_TOOLBAR_SPACE_EMPTY => 'GTK_TOOLBAR_SPACE_EMPTY';
use constant GTK_TOOLBAR_SPACE_LINE => 'GTK_TOOLBAR_SPACE_LINE';
# Gtk2::ToolbarStyle
use constant GTK_TOOLBAR_ICONS => 'GTK_TOOLBAR_ICONS';
use constant GTK_TOOLBAR_TEXT => 'GTK_TOOLBAR_TEXT';
use constant GTK_TOOLBAR_BOTH => 'GTK_TOOLBAR_BOTH';
use constant GTK_TOOLBAR_BOTH_HORIZ => 'GTK_TOOLBAR_BOTH_HORIZ';
# Gtk2::TreeModelFlags
use constant GTK_TREE_MODEL_ITERS_PERSIST => 'GTK_TREE_MODEL_ITERS_PERSIST';
use constant GTK_TREE_MODEL_LIST_ONLY => 'GTK_TREE_MODEL_LIST_ONLY';
# Gtk2::TreeViewColumnSizing
use constant GTK_TREE_VIEW_COLUMN_GROW_ONLY => 'GTK_TREE_VIEW_COLUMN_GROW_ONLY';
use constant GTK_TREE_VIEW_COLUMN_AUTOSIZE => 'GTK_TREE_VIEW_COLUMN_AUTOSIZE';
use constant GTK_TREE_VIEW_COLUMN_FIXED => 'GTK_TREE_VIEW_COLUMN_FIXED';
# Gtk2::TreeViewDropPosition
use constant GTK_TREE_VIEW_DROP_BEFORE => 'GTK_TREE_VIEW_DROP_BEFORE';
use constant GTK_TREE_VIEW_DROP_AFTER => 'GTK_TREE_VIEW_DROP_AFTER';
use constant GTK_TREE_VIEW_DROP_INTO_OR_BEFORE => 'GTK_TREE_VIEW_DROP_INTO_OR_BEFORE';
use constant GTK_TREE_VIEW_DROP_INTO_OR_AFTER => 'GTK_TREE_VIEW_DROP_INTO_OR_AFTER';
# Gtk2::TreeViewMode
use constant GTK_TREE_VIEW_LINE => 'GTK_TREE_VIEW_LINE';
use constant GTK_TREE_VIEW_ITEM => 'GTK_TREE_VIEW_ITEM';
# Gtk2::UpdateType
use constant GTK_UPDATE_CONTINUOUS => 'GTK_UPDATE_CONTINUOUS';
use constant GTK_UPDATE_DISCONTINUOUS => 'GTK_UPDATE_DISCONTINUOUS';
use constant GTK_UPDATE_DELAYED => 'GTK_UPDATE_DELAYED';
# Gtk2::Visibility
use constant GTK_VISIBILITY_NONE => 'GTK_VISIBILITY_NONE';
use constant GTK_VISIBILITY_PARTIAL => 'GTK_VISIBILITY_PARTIAL';
use constant GTK_VISIBILITY_FULL => 'GTK_VISIBILITY_FULL';
# Gtk2::WidgetFlags
use constant GTK_TOPLEVEL => 'GTK_TOPLEVEL';
use constant GTK_NO_WINDOW => 'GTK_NO_WINDOW';
use constant GTK_REALIZED => 'GTK_REALIZED';
use constant GTK_MAPPED => 'GTK_MAPPED';
use constant GTK_VISIBLE => 'GTK_VISIBLE';
use constant GTK_SENSITIVE => 'GTK_SENSITIVE';
use constant GTK_PARENT_SENSITIVE => 'GTK_PARENT_SENSITIVE';
use constant GTK_CAN_FOCUS => 'GTK_CAN_FOCUS';
use constant GTK_HAS_FOCUS => 'GTK_HAS_FOCUS';
use constant GTK_CAN_DEFAULT => 'GTK_CAN_DEFAULT';
use constant GTK_HAS_DEFAULT => 'GTK_HAS_DEFAULT';
use constant GTK_HAS_GRAB => 'GTK_HAS_GRAB';
use constant GTK_RC_STYLE => 'GTK_RC_STYLE';
use constant GTK_COMPOSITE_CHILD => 'GTK_COMPOSITE_CHILD';
use constant GTK_NO_REPARENT => 'GTK_NO_REPARENT';
use constant GTK_APP_PAINTABLE => 'GTK_APP_PAINTABLE';
use constant GTK_RECEIVES_DEFAULT => 'GTK_RECEIVES_DEFAULT';
use constant GTK_DOUBLE_BUFFERED => 'GTK_DOUBLE_BUFFERED';
use constant GTK_NO_SHOW_ALL => 'GTK_NO_SHOW_ALL';
# Gtk2::WidgetHelpType
use constant GTK_WIDGET_HELP_TOOLTIP => 'GTK_WIDGET_HELP_TOOLTIP';
use constant GTK_WIDGET_HELP_WHATS_THIS => 'GTK_WIDGET_HELP_WHATS_THIS';
# Gtk2::WindowPosition
use constant GTK_WIN_POS_NONE => 'GTK_WIN_POS_NONE';
use constant GTK_WIN_POS_CENTER => 'GTK_WIN_POS_CENTER';
use constant GTK_WIN_POS_MOUSE => 'GTK_WIN_POS_MOUSE';
use constant GTK_WIN_POS_CENTER_ALWAYS => 'GTK_WIN_POS_CENTER_ALWAYS';
use constant GTK_WIN_POS_CENTER_ON_PARENT => 'GTK_WIN_POS_CENTER_ON_PARENT';
# Gtk2::WindowType
use constant GTK_WINDOW_TOPLEVEL => 'GTK_WINDOW_TOPLEVEL';
use constant GTK_WINDOW_POPUP => 'GTK_WINDOW_POPUP';
# Gtk2::WrapMode
use constant GTK_WRAP_NONE => 'GTK_WRAP_NONE';
use constant GTK_WRAP_CHAR => 'GTK_WRAP_CHAR';
use constant GTK_WRAP_WORD => 'GTK_WRAP_WORD';
use constant GTK_WRAP_WORD_CHAR => 'GTK_WRAP_WORD_CHAR';
# Gtk2::Pango::Alignment
use constant PANGO_ALIGN_LEFT => 'PANGO_ALIGN_LEFT';
use constant PANGO_ALIGN_CENTER => 'PANGO_ALIGN_CENTER';
use constant PANGO_ALIGN_RIGHT => 'PANGO_ALIGN_RIGHT';
# Gtk2::Pango::AttrType
use constant PANGO_ATTR_INVALID => 'PANGO_ATTR_INVALID';
use constant PANGO_ATTR_LANGUAGE => 'PANGO_ATTR_LANGUAGE';
use constant PANGO_ATTR_FAMILY => 'PANGO_ATTR_FAMILY';
use constant PANGO_ATTR_STYLE => 'PANGO_ATTR_STYLE';
use constant PANGO_ATTR_WEIGHT => 'PANGO_ATTR_WEIGHT';
use constant PANGO_ATTR_VARIANT => 'PANGO_ATTR_VARIANT';
use constant PANGO_ATTR_STRETCH => 'PANGO_ATTR_STRETCH';
use constant PANGO_ATTR_SIZE => 'PANGO_ATTR_SIZE';
use constant PANGO_ATTR_FONT_DESC => 'PANGO_ATTR_FONT_DESC';
use constant PANGO_ATTR_FOREGROUND => 'PANGO_ATTR_FOREGROUND';
use constant PANGO_ATTR_BACKGROUND => 'PANGO_ATTR_BACKGROUND';
use constant PANGO_ATTR_UNDERLINE => 'PANGO_ATTR_UNDERLINE';
use constant PANGO_ATTR_STRIKETHROUGH => 'PANGO_ATTR_STRIKETHROUGH';
use constant PANGO_ATTR_RISE => 'PANGO_ATTR_RISE';
use constant PANGO_ATTR_SHAPE => 'PANGO_ATTR_SHAPE';
use constant PANGO_ATTR_SCALE => 'PANGO_ATTR_SCALE';
use constant PANGO_ATTR_FALLBACK => 'PANGO_ATTR_FALLBACK';
# Gtk2::Pango::CoverageLevel
use constant PANGO_COVERAGE_NONE => 'PANGO_COVERAGE_NONE';
use constant PANGO_COVERAGE_FALLBACK => 'PANGO_COVERAGE_FALLBACK';
use constant PANGO_COVERAGE_APPROXIMATE => 'PANGO_COVERAGE_APPROXIMATE';
use constant PANGO_COVERAGE_EXACT => 'PANGO_COVERAGE_EXACT';
# Gtk2::Pango::Direction
use constant PANGO_DIRECTION_LTR => 'PANGO_DIRECTION_LTR';
use constant PANGO_DIRECTION_RTL => 'PANGO_DIRECTION_RTL';
use constant PANGO_DIRECTION_TTB_LTR => 'PANGO_DIRECTION_TTB_LTR';
use constant PANGO_DIRECTION_TTB_RTL => 'PANGO_DIRECTION_TTB_RTL';
use constant PANGO_DIRECTION_WEAK_LTR => 'PANGO_DIRECTION_WEAK_LTR';
use constant PANGO_DIRECTION_WEAK_RTL => 'PANGO_DIRECTION_WEAK_RTL';
use constant PANGO_DIRECTION_NEUTRAL => 'PANGO_DIRECTION_NEUTRAL';
# Gtk2::Pango::FontMask
use constant PANGO_FONT_MASK_FAMILY => 'PANGO_FONT_MASK_FAMILY';
use constant PANGO_FONT_MASK_STYLE => 'PANGO_FONT_MASK_STYLE';
use constant PANGO_FONT_MASK_VARIANT => 'PANGO_FONT_MASK_VARIANT';
use constant PANGO_FONT_MASK_WEIGHT => 'PANGO_FONT_MASK_WEIGHT';
use constant PANGO_FONT_MASK_STRETCH => 'PANGO_FONT_MASK_STRETCH';
use constant PANGO_FONT_MASK_SIZE => 'PANGO_FONT_MASK_SIZE';
# Gtk2::Pango::Stretch
use constant PANGO_STRETCH_ULTRA_CONDENSED => 'PANGO_STRETCH_ULTRA_CONDENSED';
use constant PANGO_STRETCH_EXTRA_CONDENSED => 'PANGO_STRETCH_EXTRA_CONDENSED';
use constant PANGO_STRETCH_CONDENSED => 'PANGO_STRETCH_CONDENSED';
use constant PANGO_STRETCH_SEMI_CONDENSED => 'PANGO_STRETCH_SEMI_CONDENSED';
use constant PANGO_STRETCH_NORMAL => 'PANGO_STRETCH_NORMAL';
use constant PANGO_STRETCH_SEMI_EXPANDED => 'PANGO_STRETCH_SEMI_EXPANDED';
use constant PANGO_STRETCH_EXPANDED => 'PANGO_STRETCH_EXPANDED';
use constant PANGO_STRETCH_EXTRA_EXPANDED => 'PANGO_STRETCH_EXTRA_EXPANDED';
use constant PANGO_STRETCH_ULTRA_EXPANDED => 'PANGO_STRETCH_ULTRA_EXPANDED';
# Gtk2::Pango::Style
use constant PANGO_STYLE_NORMAL => 'PANGO_STYLE_NORMAL';
use constant PANGO_STYLE_OBLIQUE => 'PANGO_STYLE_OBLIQUE';
use constant PANGO_STYLE_ITALIC => 'PANGO_STYLE_ITALIC';
# Gtk2::Pango::TabAlign
use constant PANGO_TAB_LEFT => 'PANGO_TAB_LEFT';
# Gtk2::Pango::Underline
use constant PANGO_UNDERLINE_NONE => 'PANGO_UNDERLINE_NONE';
use constant PANGO_UNDERLINE_SINGLE => 'PANGO_UNDERLINE_SINGLE';
use constant PANGO_UNDERLINE_DOUBLE => 'PANGO_UNDERLINE_DOUBLE';
use constant PANGO_UNDERLINE_LOW => 'PANGO_UNDERLINE_LOW';
use constant PANGO_UNDERLINE_ERROR => 'PANGO_UNDERLINE_ERROR';
# Gtk2::Pango::Variant
use constant PANGO_VARIANT_NORMAL => 'PANGO_VARIANT_NORMAL';
use constant PANGO_VARIANT_SMALL_CAPS => 'PANGO_VARIANT_SMALL_CAPS';
# Gtk2::Pango::Weight
use constant PANGO_WEIGHT_ULTRALIGHT => 'PANGO_WEIGHT_ULTRALIGHT';
use constant PANGO_WEIGHT_LIGHT => 'PANGO_WEIGHT_LIGHT';
use constant PANGO_WEIGHT_NORMAL => 'PANGO_WEIGHT_NORMAL';
use constant PANGO_WEIGHT_BOLD => 'PANGO_WEIGHT_BOLD';
use constant PANGO_WEIGHT_ULTRABOLD => 'PANGO_WEIGHT_ULTRABOLD';
use constant PANGO_WEIGHT_HEAVY => 'PANGO_WEIGHT_HEAVY';
# Gtk2::Pango::WrapMode
use constant PANGO_WRAP_WORD => 'PANGO_WRAP_WORD';
use constant PANGO_WRAP_CHAR => 'PANGO_WRAP_CHAR';
use constant PANGO_WRAP_WORD_CHAR => 'PANGO_WRAP_WORD_CHAR';
# Gtk2::FileChooserAction
use constant GTK_FILE_CHOOSER_ACTION_OPEN => 'GTK_FILE_CHOOSER_ACTION_OPEN';
use constant GTK_FILE_CHOOSER_ACTION_SAVE => 'GTK_FILE_CHOOSER_ACTION_SAVE';
use constant GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER => 'GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER';
use constant GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER => 'GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER';
# Gtk2::FileChooserError
use constant GTK_FILE_CHOOSER_ERROR_NONEXISTENT => 'GTK_FILE_CHOOSER_ERROR_NONEXISTENT';
use constant GTK_FILE_CHOOSER_ERROR_BAD_FILENAME => 'GTK_FILE_CHOOSER_ERROR_BAD_FILENAME';
# Gtk2::FileFilterFlags
use constant GTK_FILE_FILTER_FILENAME => 'GTK_FILE_FILTER_FILENAME';
use constant GTK_FILE_FILTER_URI => 'GTK_FILE_FILTER_URI';
use constant GTK_FILE_FILTER_DISPLAY_NAME => 'GTK_FILE_FILTER_DISPLAY_NAME';
use constant GTK_FILE_FILTER_MIME_TYPE => 'GTK_FILE_FILTER_MIME_TYPE';
# Gtk2::IconThemeError
use constant GTK_ICON_THEME_NOT_FOUND => 'GTK_ICON_THEME_NOT_FOUND';
use constant GTK_ICON_THEME_FAILED => 'GTK_ICON_THEME_FAILED';
# Gtk2::IconLookupFlags
use constant GTK_ICON_LOOKUP_NO_SVG => 'GTK_ICON_LOOKUP_NO_SVG';
use constant GTK_ICON_LOOKUP_FORCE_SVG => 'GTK_ICON_LOOKUP_FORCE_SVG';
use constant GTK_ICON_LOOKUP_USE_BUILTIN => 'GTK_ICON_LOOKUP_USE_BUILTIN';
# Gtk2::UIManagerItemType
use constant GTK_UI_MANAGER_AUTO => 'GTK_UI_MANAGER_AUTO';
use constant GTK_UI_MANAGER_MENUBAR => 'GTK_UI_MANAGER_MENUBAR';
use constant GTK_UI_MANAGER_MENU => 'GTK_UI_MANAGER_MENU';
use constant GTK_UI_MANAGER_TOOLBAR => 'GTK_UI_MANAGER_TOOLBAR';
use constant GTK_UI_MANAGER_PLACEHOLDER => 'GTK_UI_MANAGER_PLACEHOLDER';
use constant GTK_UI_MANAGER_POPUP => 'GTK_UI_MANAGER_POPUP';
use constant GTK_UI_MANAGER_MENUITEM => 'GTK_UI_MANAGER_MENUITEM';
use constant GTK_UI_MANAGER_TOOLITEM => 'GTK_UI_MANAGER_TOOLITEM';
use constant GTK_UI_MANAGER_SEPARATOR => 'GTK_UI_MANAGER_SEPARATOR';
use constant GTK_UI_MANAGER_ACCELERATOR => 'GTK_UI_MANAGER_ACCELERATOR';