← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/gimp/oneiric-security

« back to all changes in this revision

Viewing changes to plug-ins/pygimp/gimpui.c

  • Committer: Package Import Robot
  • Author(s): Sebastien Bacher
  • Date: 2010-07-12 15:08:08 UTC
  • mfrom: (1.1.23) (0.4.6 sid)
  • Revision ID: package-import@ubuntu.com-20100712150808-db9xqgtxrvpyl3g2
Tags: 2.6.10-1ubuntu1
Resync on Debian, dropping changes which are in the new version

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/pygimp/gimpui.c
216
216
    static char *kwlist[] = { "widget", NULL };
217
217
    PyGObject *widget;
218
218
 
219
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:GimpBrowser.set_widget", kwlist, &PyGtkWidget_Type, &widget))
 
219
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.Browser.set_widget", kwlist, &PyGtkWidget_Type, &widget))
220
220
        return NULL;
221
221
    
222
222
    gimp_browser_set_widget(GIMP_BROWSER(self->obj), GTK_WIDGET(widget->obj));
231
231
    static char *kwlist[] = { "message", NULL };
232
232
    char *message;
233
233
 
234
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpBrowser.show_message", kwlist, &message))
 
234
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.Browser.show_message", kwlist, &message))
235
235
        return NULL;
236
236
    
237
237
    gimp_browser_show_message(GIMP_BROWSER(self->obj), message);
326
326
    PyObject *py_state = NULL;
327
327
    GdkModifierType state;
328
328
 
329
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpButton.extended_clicked", kwlist, &py_state))
 
329
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Button.extended_clicked", kwlist, &py_state))
330
330
        return NULL;
331
331
    if (pyg_flags_get_value(GDK_TYPE_MODIFIER_TYPE, py_state, (gpointer)&state))
332
332
        return NULL;
499
499
    PyObject *py_state = NULL;
500
500
    GdkModifierType state;
501
501
 
502
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO:GimpCellRendererToggle.clicked", kwlist, &path, &py_state))
 
502
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO:Gimp.CellRendererToggle.clicked", kwlist, &path, &py_state))
503
503
        return NULL;
504
504
    if (pyg_flags_get_value(GDK_TYPE_MODIFIER_TYPE, py_state, (gpointer)&state))
505
505
        return NULL;
601
601
    static char *kwlist[] = { "active", NULL };
602
602
    int active;
603
603
 
604
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpChainButton.set_active", kwlist, &active))
 
604
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ChainButton.set_active", kwlist, &active))
605
605
        return NULL;
606
606
    
607
607
    gimp_chain_button_set_active(GIMP_CHAIN_BUTTON(self->obj), active);
716
716
    PyObject *py_color;
717
717
    GimpRGB *color = NULL;
718
718
 
719
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpColorArea.set_color", kwlist, &py_color))
 
719
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorArea.set_color", kwlist, &py_color))
720
720
        return NULL;
721
721
    if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
722
722
        color = pyg_boxed_get(py_color, GimpRGB);
763
763
    PyObject *py_type = NULL;
764
764
    GimpColorAreaType type;
765
765
 
766
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpColorArea.set_type", kwlist, &py_type))
 
766
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorArea.set_type", kwlist, &py_type))
767
767
        return NULL;
768
768
    if (pyg_enum_get_value(GIMP_TYPE_COLOR_AREA_TYPE, py_type, (gpointer)&type))
769
769
        return NULL;
780
780
    static char *kwlist[] = { "draw_border", NULL };
781
781
    int draw_border;
782
782
 
783
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpColorArea.set_draw_border", kwlist, &draw_border))
 
783
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorArea.set_draw_border", kwlist, &draw_border))
784
784
        return NULL;
785
785
    
786
786
    gimp_color_area_set_draw_border(GIMP_COLOR_AREA(self->obj), draw_border);
908
908
    PyObject *py_color;
909
909
    GimpRGB *color = NULL;
910
910
 
911
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpColorButton.set_color", kwlist, &py_color))
 
911
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorButton.set_color", kwlist, &py_color))
912
912
        return NULL;
913
913
    if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
914
914
        color = pyg_boxed_get(py_color, GimpRGB);
955
955
    PyObject *py_type = NULL;
956
956
    GimpColorAreaType type;
957
957
 
958
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpColorButton.set_type", kwlist, &py_type))
 
958
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorButton.set_type", kwlist, &py_type))
959
959
        return NULL;
960
960
    if (pyg_enum_get_value(GIMP_TYPE_COLOR_AREA_TYPE, py_type, (gpointer)&type))
961
961
        return NULL;
984
984
    static char *kwlist[] = { "continuous", NULL };
985
985
    int continuous;
986
986
 
987
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpColorButton.set_update", kwlist, &continuous))
 
987
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorButton.set_update", kwlist, &continuous))
988
988
        return NULL;
989
989
    
990
990
    gimp_color_button_set_update(GIMP_COLOR_BUTTON(self->obj), continuous);
1077
1077
    int buf_len, width, height, bpp, bpl;
1078
1078
    guchar *buf;
1079
1079
 
1080
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#iiii:GimpColorDisplay.convert", kwlist, &buf, &buf_len, &width, &height, &bpp, &bpl))
 
1080
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#iiii:Gimp.ColorDisplay.convert", kwlist, &buf, &buf_len, &width, &height, &bpp, &bpl))
1081
1081
        return NULL;
1082
1082
    
1083
1083
    gimp_color_display_convert(GIMP_COLOR_DISPLAY(self->obj), buf, width, height, bpp, bpl);
1124
1124
    static char *kwlist[] = { "enabled", NULL };
1125
1125
    int enabled;
1126
1126
 
1127
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpColorDisplay.set_enabled", kwlist, &enabled))
 
1127
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorDisplay.set_enabled", kwlist, &enabled))
1128
1128
        return NULL;
1129
1129
    
1130
1130
    gimp_color_display_set_enabled(GIMP_COLOR_DISPLAY(self->obj), enabled);
1260
1260
    static char *kwlist[] = { "display", NULL };
1261
1261
    PyGObject *display;
1262
1262
 
1263
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:GimpColorDisplayStack.add", kwlist, &PyGimpColorDisplay_Type, &display))
 
1263
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.ColorDisplayStack.add", kwlist, &PyGimpColorDisplay_Type, &display))
1264
1264
        return NULL;
1265
1265
    
1266
1266
    gimp_color_display_stack_add(GIMP_COLOR_DISPLAY_STACK(self->obj), GIMP_COLOR_DISPLAY(display->obj));
1275
1275
    static char *kwlist[] = { "display", NULL };
1276
1276
    PyGObject *display;
1277
1277
 
1278
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:GimpColorDisplayStack.remove", kwlist, &PyGimpColorDisplay_Type, &display))
 
1278
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.ColorDisplayStack.remove", kwlist, &PyGimpColorDisplay_Type, &display))
1279
1279
        return NULL;
1280
1280
    
1281
1281
    gimp_color_display_stack_remove(GIMP_COLOR_DISPLAY_STACK(self->obj), GIMP_COLOR_DISPLAY(display->obj));
1290
1290
    static char *kwlist[] = { "display", NULL };
1291
1291
    PyGObject *display;
1292
1292
 
1293
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:GimpColorDisplayStack.reorder_up", kwlist, &PyGimpColorDisplay_Type, &display))
 
1293
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.ColorDisplayStack.reorder_up", kwlist, &PyGimpColorDisplay_Type, &display))
1294
1294
        return NULL;
1295
1295
    
1296
1296
    gimp_color_display_stack_reorder_up(GIMP_COLOR_DISPLAY_STACK(self->obj), GIMP_COLOR_DISPLAY(display->obj));
1305
1305
    static char *kwlist[] = { "display", NULL };
1306
1306
    PyGObject *display;
1307
1307
 
1308
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:GimpColorDisplayStack.reorder_down", kwlist, &PyGimpColorDisplay_Type, &display))
 
1308
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.ColorDisplayStack.reorder_down", kwlist, &PyGimpColorDisplay_Type, &display))
1309
1309
        return NULL;
1310
1310
    
1311
1311
    gimp_color_display_stack_reorder_down(GIMP_COLOR_DISPLAY_STACK(self->obj), GIMP_COLOR_DISPLAY(display->obj));
1321
1321
    int buf_len, width, height, bpp, bpl;
1322
1322
    guchar *buf;
1323
1323
 
1324
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#iiii:GimpColorDisplayStack.convert", kwlist, &buf, &buf_len, &width, &height, &bpp, &bpl))
 
1324
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#iiii:Gimp.ColorDisplayStack.convert", kwlist, &buf, &buf_len, &width, &height, &bpp, &bpl))
1325
1325
        return NULL;
1326
1326
    
1327
1327
    gimp_color_display_stack_convert(GIMP_COLOR_DISPLAY_STACK(self->obj), buf, width, height, bpp, bpl);
1424
1424
    PyObject *py_color;
1425
1425
    GimpRGB *color = NULL;
1426
1426
 
1427
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpColorHexEntry.set_color", kwlist, &py_color))
 
1427
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorHexEntry.set_color", kwlist, &py_color))
1428
1428
        return NULL;
1429
1429
    if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
1430
1430
        color = pyg_boxed_get(py_color, GimpRGB);
1545
1545
    static char *kwlist[] = { "filename", "label", NULL };
1546
1546
    char *filename, *label;
1547
1547
 
1548
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:GimpColorProfileComboBox.add", kwlist, &filename, &label))
 
1548
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:Gimp.ColorProfileComboBox.add", kwlist, &filename, &label))
1549
1549
        return NULL;
1550
1550
    
1551
1551
    gimp_color_profile_combo_box_add(GIMP_COLOR_PROFILE_COMBO_BOX(self->obj), filename, label);
1560
1560
    static char *kwlist[] = { "filename", "label", NULL };
1561
1561
    char *filename, *label;
1562
1562
 
1563
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:GimpColorProfileComboBox.set_active", kwlist, &filename, &label))
 
1563
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:Gimp.ColorProfileComboBox.set_active", kwlist, &filename, &label))
1564
1564
        return NULL;
1565
1565
    
1566
1566
    gimp_color_profile_combo_box_set_active(GIMP_COLOR_PROFILE_COMBO_BOX(self->obj), filename, label);
1681
1681
    static char *kwlist[] = { "filename", "label", NULL };
1682
1682
    char *filename, *label;
1683
1683
 
1684
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:GimpColorProfileStore.add", kwlist, &filename, &label))
 
1684
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ss:Gimp.ColorProfileStore.add", kwlist, &filename, &label))
1685
1685
        return NULL;
1686
1686
    
1687
1687
    gimp_color_profile_store_add(GIMP_COLOR_PROFILE_STORE(self->obj), filename, label);
1793
1793
    GimpColorSelectorChannel channel;
1794
1794
    PyObject *py_channel = NULL;
1795
1795
 
1796
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpColorScale.set_channel", kwlist, &py_channel))
 
1796
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorScale.set_channel", kwlist, &py_channel))
1797
1797
        return NULL;
1798
1798
    if (pyg_enum_get_value(GIMP_TYPE_COLOR_SELECTOR_CHANNEL, py_channel, (gpointer)&channel))
1799
1799
        return NULL;
1812
1812
    GimpHSV *hsv = NULL;
1813
1813
    GimpRGB *rgb = NULL;
1814
1814
 
1815
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:GimpColorScale.set_color", kwlist, &py_rgb, &py_hsv))
 
1815
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:Gimp.ColorScale.set_color", kwlist, &py_rgb, &py_hsv))
1816
1816
        return NULL;
1817
1817
    if (pyg_boxed_check(py_rgb, GIMP_TYPE_RGB))
1818
1818
        rgb = pyg_boxed_get(py_rgb, GimpRGB);
1900
1900
    GimpColorSelectorChannel channel;
1901
1901
    GimpRGB *rgb = NULL;
1902
1902
 
1903
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OOOO:GimpColorSelector.__init__", kwlist, &py_selector_type, &py_rgb, &py_hsv, &py_channel))
 
1903
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OOOO:Gimp.ColorSelector.__init__", kwlist, &py_selector_type, &py_rgb, &py_hsv, &py_channel))
1904
1904
        return -1;
1905
1905
    if ((selector_type = pyg_type_from_object(py_selector_type)) == 0)
1906
1906
        return -1;
1934
1934
    static char *kwlist[] = { "visible", NULL };
1935
1935
    int visible;
1936
1936
 
1937
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpColorSelector.set_toggles_visible", kwlist, &visible))
 
1937
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorSelector.set_toggles_visible", kwlist, &visible))
1938
1938
        return NULL;
1939
1939
    
1940
1940
    gimp_color_selector_set_toggles_visible(GIMP_COLOR_SELECTOR(self->obj), visible);
1949
1949
    static char *kwlist[] = { "sensitive", NULL };
1950
1950
    int sensitive;
1951
1951
 
1952
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpColorSelector.set_toggles_sensitive", kwlist, &sensitive))
 
1952
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorSelector.set_toggles_sensitive", kwlist, &sensitive))
1953
1953
        return NULL;
1954
1954
    
1955
1955
    gimp_color_selector_set_toggles_sensitive(GIMP_COLOR_SELECTOR(self->obj), sensitive);
1964
1964
    static char *kwlist[] = { "show_alpha", NULL };
1965
1965
    int show_alpha;
1966
1966
 
1967
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpColorSelector.set_show_alpha", kwlist, &show_alpha))
 
1967
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorSelector.set_show_alpha", kwlist, &show_alpha))
1968
1968
        return NULL;
1969
1969
    
1970
1970
    gimp_color_selector_set_show_alpha(GIMP_COLOR_SELECTOR(self->obj), show_alpha);
1981
1981
    GimpHSV *hsv = NULL;
1982
1982
    GimpRGB *rgb = NULL;
1983
1983
 
1984
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:GimpColorSelector.set_color", kwlist, &py_rgb, &py_hsv))
 
1984
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:Gimp.ColorSelector.set_color", kwlist, &py_rgb, &py_hsv))
1985
1985
        return NULL;
1986
1986
    if (pyg_boxed_check(py_rgb, GIMP_TYPE_RGB))
1987
1987
        rgb = pyg_boxed_get(py_rgb, GimpRGB);
2009
2009
    GimpColorSelectorChannel channel;
2010
2010
    PyObject *py_channel = NULL;
2011
2011
 
2012
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpColorSelector.set_channel", kwlist, &py_channel))
 
2012
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorSelector.set_channel", kwlist, &py_channel))
2013
2013
        return NULL;
2014
2014
    if (pyg_enum_get_value(GIMP_TYPE_COLOR_SELECTOR_CHANNEL, py_channel, (gpointer)&channel))
2015
2015
        return NULL;
2182
2182
    static char *kwlist[] = { "show_alpha", NULL };
2183
2183
    int show_alpha;
2184
2184
 
2185
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpColorSelection.set_show_alpha", kwlist, &show_alpha))
 
2185
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.ColorSelection.set_show_alpha", kwlist, &show_alpha))
2186
2186
        return NULL;
2187
2187
    
2188
2188
    gimp_color_selection_set_show_alpha(GIMP_COLOR_SELECTION(self->obj), show_alpha);
2210
2210
    PyObject *py_color;
2211
2211
    GimpRGB *color = NULL;
2212
2212
 
2213
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpColorSelection.set_color", kwlist, &py_color))
 
2213
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorSelection.set_color", kwlist, &py_color))
2214
2214
        return NULL;
2215
2215
    if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
2216
2216
        color = pyg_boxed_get(py_color, GimpRGB);
2245
2245
    PyObject *py_color;
2246
2246
    GimpRGB *color = NULL;
2247
2247
 
2248
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpColorSelection.set_old_color", kwlist, &py_color))
 
2248
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.ColorSelection.set_old_color", kwlist, &py_color))
2249
2249
        return NULL;
2250
2250
    if (pyg_boxed_check(py_color, GIMP_TYPE_RGB))
2251
2251
        color = pyg_boxed_get(py_color, GimpRGB);
2371
2371
    GType page_type;
2372
2372
    GtkWidget *ret;
2373
2373
 
2374
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Oi:GimpColorNotebook.set_has_page", kwlist, &py_page_type, &has_page))
 
2374
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Oi:Gimp.ColorNotebook.set_has_page", kwlist, &py_page_type, &has_page))
2375
2375
        return NULL;
2376
2376
    if ((page_type = pyg_type_from_object(py_page_type)) == 0)
2377
2377
        return NULL;
2618
2618
    int response_id;
2619
2619
    GtkWidget *ret;
2620
2620
 
2621
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:GimpDialog.add_button", kwlist, &button_text, &response_id))
 
2621
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:Gimp.Dialog.add_button", kwlist, &button_text, &response_id))
2622
2622
        return NULL;
2623
2623
    
2624
2624
    ret = gimp_dialog_add_button(GIMP_DIALOG(self->obj), button_text, response_id);
2748
2748
    static char *kwlist[] = { "value", NULL };
2749
2749
    int value;
2750
2750
 
2751
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpEnumLabel.set_value", kwlist, &value))
 
2751
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.EnumLabel.set_value", kwlist, &value))
2752
2752
        return NULL;
2753
2753
    
2754
2754
    gimp_enum_label_set_value(GIMP_ENUM_LABEL(self->obj), value);
3551
3551
    PyObject *py_enum_type = NULL;
3552
3552
    GType enum_type;
3553
3553
 
3554
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpEnumComboBox.__init__", kwlist, &py_enum_type))
 
3554
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.EnumComboBox.__init__", kwlist, &py_enum_type))
3555
3555
        return -1;
3556
3556
    if ((enum_type = pyg_type_from_object(py_enum_type)) == 0)
3557
3557
        return -1;
3571
3571
    static char *kwlist[] = { "stock_prefix", NULL };
3572
3572
    char *stock_prefix;
3573
3573
 
3574
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpEnumComboBox.set_stock_prefix", kwlist, &stock_prefix))
 
3574
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.EnumComboBox.set_stock_prefix", kwlist, &stock_prefix))
3575
3575
        return NULL;
3576
3576
    
3577
3577
    gimp_enum_combo_box_set_stock_prefix(GIMP_ENUM_COMBO_BOX(self->obj), stock_prefix);
4173
4173
    static char *kwlist[] = { "stock_prefix", NULL };
4174
4174
    char *stock_prefix;
4175
4175
 
4176
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpEnumStore.set_stock_prefix", kwlist, &stock_prefix))
 
4176
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.EnumStore.set_stock_prefix", kwlist, &stock_prefix))
4177
4177
        return NULL;
4178
4178
    
4179
4179
    gimp_enum_store_set_stock_prefix(GIMP_ENUM_STORE(self->obj), stock_prefix);
4580
4580
    static char *kwlist[] = { "left", "right", NULL };
4581
4581
    double left, right;
4582
4582
 
4583
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:GimpNumberPairEntry.set_default_values", kwlist, &left, &right))
 
4583
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Gimp.NumberPairEntry.set_default_values", kwlist, &left, &right))
4584
4584
        return NULL;
4585
4585
    
4586
4586
    gimp_number_pair_entry_set_default_values(GIMP_NUMBER_PAIR_ENTRY(self->obj), left, right);
4610
4610
    static char *kwlist[] = { "left", "right", NULL };
4611
4611
    double left, right;
4612
4612
 
4613
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:GimpNumberPairEntry.set_values", kwlist, &left, &right))
 
4613
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Gimp.NumberPairEntry.set_values", kwlist, &left, &right))
4614
4614
        return NULL;
4615
4615
    
4616
4616
    gimp_number_pair_entry_set_values(GIMP_NUMBER_PAIR_ENTRY(self->obj), left, right);
4639
4639
    static char *kwlist[] = { "string", NULL };
4640
4640
    char *string;
4641
4641
 
4642
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpNumberPairEntry.set_default_text", kwlist, &string))
 
4642
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.NumberPairEntry.set_default_text", kwlist, &string))
4643
4643
        return NULL;
4644
4644
    
4645
4645
    gimp_number_pair_entry_set_default_text(GIMP_NUMBER_PAIR_ENTRY(self->obj), string);
4668
4668
    static char *kwlist[] = { "ratio", NULL };
4669
4669
    double ratio;
4670
4670
 
4671
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"d:GimpNumberPairEntry.set_ratio", kwlist, &ratio))
 
4671
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"d:Gimp.NumberPairEntry.set_ratio", kwlist, &ratio))
4672
4672
        return NULL;
4673
4673
    
4674
4674
    gimp_number_pair_entry_set_ratio(GIMP_NUMBER_PAIR_ENTRY(self->obj), ratio);
4740
4740
    static char *kwlist[] = { "user_override", NULL };
4741
4741
    int user_override;
4742
4742
 
4743
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpNumberPairEntry.set_user_override", kwlist, &user_override))
 
4743
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.NumberPairEntry.set_user_override", kwlist, &user_override))
4744
4744
        return NULL;
4745
4745
    
4746
4746
    gimp_number_pair_entry_set_user_override(GIMP_NUMBER_PAIR_ENTRY(self->obj), user_override);
4844
4844
    static char *kwlist[] = { "orig_width", "orig_height", NULL };
4845
4845
    int orig_width, orig_height;
4846
4846
 
4847
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:GimpOffsetArea.__init__", kwlist, &orig_width, &orig_height))
 
4847
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.OffsetArea.__init__", kwlist, &orig_width, &orig_height))
4848
4848
        return -1;
4849
4849
    self->obj = (GObject *)gimp_offset_area_new(orig_width, orig_height);
4850
4850
 
4862
4862
    static char *kwlist[] = { "pixbuf", NULL };
4863
4863
    PyGObject *pixbuf;
4864
4864
 
4865
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:GimpOffsetArea.set_pixbuf", kwlist, &PyGdkPixbuf_Type, &pixbuf))
 
4865
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Gimp.OffsetArea.set_pixbuf", kwlist, &PyGdkPixbuf_Type, &pixbuf))
4866
4866
        return NULL;
4867
4867
    
4868
4868
    gimp_offset_area_set_pixbuf(GIMP_OFFSET_AREA(self->obj), GDK_PIXBUF(pixbuf->obj));
4877
4877
    static char *kwlist[] = { "width", "height", NULL };
4878
4878
    int width, height;
4879
4879
 
4880
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:GimpOffsetArea.set_size", kwlist, &width, &height))
 
4880
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.OffsetArea.set_size", kwlist, &width, &height))
4881
4881
        return NULL;
4882
4882
    
4883
4883
    gimp_offset_area_set_size(GIMP_OFFSET_AREA(self->obj), width, height);
4892
4892
    static char *kwlist[] = { "offset_x", "offset_y", NULL };
4893
4893
    int offset_x, offset_y;
4894
4894
 
4895
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:GimpOffsetArea.set_offsets", kwlist, &offset_x, &offset_y))
 
4895
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.OffsetArea.set_offsets", kwlist, &offset_x, &offset_y))
4896
4896
        return NULL;
4897
4897
    
4898
4898
    gimp_offset_area_set_offsets(GIMP_OFFSET_AREA(self->obj), offset_x, offset_y);
4986
4986
    static char *kwlist[] = { "n_pages", NULL };
4987
4987
    int n_pages;
4988
4988
 
4989
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpPageSelector.set_n_pages", kwlist, &n_pages))
 
4989
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.set_n_pages", kwlist, &n_pages))
4990
4990
        return NULL;
4991
4991
    
4992
4992
    gimp_page_selector_set_n_pages(GIMP_PAGE_SELECTOR(self->obj), n_pages);
5013
5013
    GimpPageSelectorTarget target;
5014
5014
    PyObject *py_target = NULL;
5015
5015
 
5016
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpPageSelector.set_target", kwlist, &py_target))
 
5016
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.PageSelector.set_target", kwlist, &py_target))
5017
5017
        return NULL;
5018
5018
    if (pyg_enum_get_value(GIMP_TYPE_PAGE_SELECTOR_TARGET, py_target, (gpointer)&target))
5019
5019
        return NULL;
5042
5042
    int page_no;
5043
5043
    PyGObject *thumbnail;
5044
5044
 
5045
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iO!:GimpPageSelector.set_page_thumbnail", kwlist, &page_no, &PyGdkPixbuf_Type, &thumbnail))
 
5045
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iO!:Gimp.PageSelector.set_page_thumbnail", kwlist, &page_no, &PyGdkPixbuf_Type, &thumbnail))
5046
5046
        return NULL;
5047
5047
    
5048
5048
    gimp_page_selector_set_page_thumbnail(GIMP_PAGE_SELECTOR(self->obj), page_no, GDK_PIXBUF(thumbnail->obj));
5058
5058
    int page_no;
5059
5059
    GdkPixbuf *ret;
5060
5060
 
5061
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpPageSelector.get_page_thumbnail", kwlist, &page_no))
 
5061
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.get_page_thumbnail", kwlist, &page_no))
5062
5062
        return NULL;
5063
5063
    
5064
5064
    ret = gimp_page_selector_get_page_thumbnail(GIMP_PAGE_SELECTOR(self->obj), page_no);
5074
5074
    int page_no;
5075
5075
    char *label;
5076
5076
 
5077
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"is:GimpPageSelector.set_page_label", kwlist, &page_no, &label))
 
5077
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"is:Gimp.PageSelector.set_page_label", kwlist, &page_no, &label))
5078
5078
        return NULL;
5079
5079
    
5080
5080
    gimp_page_selector_set_page_label(GIMP_PAGE_SELECTOR(self->obj), page_no, label);
5090
5090
    int page_no;
5091
5091
    gchar *ret;
5092
5092
 
5093
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpPageSelector.get_page_label", kwlist, &page_no))
 
5093
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.get_page_label", kwlist, &page_no))
5094
5094
        return NULL;
5095
5095
    
5096
5096
    ret = gimp_page_selector_get_page_label(GIMP_PAGE_SELECTOR(self->obj), page_no);
5130
5130
    static char *kwlist[] = { "page_no", NULL };
5131
5131
    int page_no;
5132
5132
 
5133
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpPageSelector.select_page", kwlist, &page_no))
 
5133
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.select_page", kwlist, &page_no))
5134
5134
        return NULL;
5135
5135
    
5136
5136
    gimp_page_selector_select_page(GIMP_PAGE_SELECTOR(self->obj), page_no);
5145
5145
    static char *kwlist[] = { "page_no", NULL };
5146
5146
    int page_no;
5147
5147
 
5148
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpPageSelector.unselect_page", kwlist, &page_no))
 
5148
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.unselect_page", kwlist, &page_no))
5149
5149
        return NULL;
5150
5150
    
5151
5151
    gimp_page_selector_unselect_page(GIMP_PAGE_SELECTOR(self->obj), page_no);
5160
5160
    static char *kwlist[] = { "page_no", NULL };
5161
5161
    int page_no, ret;
5162
5162
 
5163
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpPageSelector.page_is_selected", kwlist, &page_no))
 
5163
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.PageSelector.page_is_selected", kwlist, &page_no))
5164
5164
        return NULL;
5165
5165
    
5166
5166
    ret = gimp_page_selector_page_is_selected(GIMP_PAGE_SELECTOR(self->obj), page_no);
5200
5200
    static char *kwlist[] = { "range", NULL };
5201
5201
    char *range;
5202
5202
 
5203
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpPageSelector.select_range", kwlist, &range))
 
5203
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PageSelector.select_range", kwlist, &range))
5204
5204
        return NULL;
5205
5205
    
5206
5206
    gimp_page_selector_select_range(GIMP_PAGE_SELECTOR(self->obj), range);
5364
5364
    static char *kwlist[] = { "path", NULL };
5365
5365
    char *path;
5366
5366
 
5367
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpPathEditor.set_path", kwlist, &path))
 
5367
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PathEditor.set_path", kwlist, &path))
5368
5368
        return NULL;
5369
5369
    
5370
5370
    gimp_path_editor_set_path(GIMP_PATH_EDITOR(self->obj), path);
5396
5396
    static char *kwlist[] = { "path", NULL };
5397
5397
    char *path;
5398
5398
 
5399
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpPathEditor.set_writable_path", kwlist, &path))
 
5399
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PathEditor.set_writable_path", kwlist, &path))
5400
5400
        return NULL;
5401
5401
    
5402
5402
    gimp_path_editor_set_writable_path(GIMP_PATH_EDITOR(self->obj), path);
5412
5412
    char *directory;
5413
5413
    int ret;
5414
5414
 
5415
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpPathEditor.get_dir_writable", kwlist, &directory))
 
5415
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PathEditor.get_dir_writable", kwlist, &directory))
5416
5416
        return NULL;
5417
5417
    
5418
5418
    ret = gimp_path_editor_get_dir_writable(GIMP_PATH_EDITOR(self->obj), directory);
5428
5428
    char *directory;
5429
5429
    int writable;
5430
5430
 
5431
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:GimpPathEditor.set_dir_writable", kwlist, &directory, &writable))
 
5431
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"si:Gimp.PathEditor.set_dir_writable", kwlist, &directory, &writable))
5432
5432
        return NULL;
5433
5433
    
5434
5434
    gimp_path_editor_set_dir_writable(GIMP_PATH_EDITOR(self->obj), directory, writable);
5577
5577
    static char *kwlist[] = { "update", NULL };
5578
5578
    int update;
5579
5579
 
5580
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpPreview.set_update", kwlist, &update))
 
5580
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.Preview.set_update", kwlist, &update))
5581
5581
        return NULL;
5582
5582
    
5583
5583
    gimp_preview_set_update(GIMP_PREVIEW(self->obj), update);
5604
5604
    static char *kwlist[] = { "xmin", "ymin", "xmax", "ymax", NULL };
5605
5605
    int xmin, ymin, xmax, ymax;
5606
5606
 
5607
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iiii:GimpPreview.set_bounds", kwlist, &xmin, &ymin, &xmax, &ymax))
 
5607
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iiii:Gimp.Preview.set_bounds", kwlist, &xmin, &ymin, &xmax, &ymax))
5608
5608
        return NULL;
5609
5609
    
5610
5610
    gimp_preview_set_bounds(GIMP_PREVIEW(self->obj), xmin, ymin, xmax, ymax);
5718
5718
    int buffer_len, rowstride;
5719
5719
    guchar *buffer;
5720
5720
 
5721
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#i:GimpPreview.draw_buffer", kwlist, &buffer, &buffer_len, &rowstride))
 
5721
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#i:Gimp.Preview.draw_buffer", kwlist, &buffer, &buffer_len, &rowstride))
5722
5722
        return NULL;
5723
5723
    
5724
5724
    gimp_preview_draw_buffer(GIMP_PREVIEW(self->obj), buffer, rowstride);
5744
5744
    PyObject *py_cursor;
5745
5745
    GdkCursor *cursor = NULL;
5746
5746
 
5747
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpPreview.set_default_cursor", kwlist, &py_cursor))
 
5747
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.Preview.set_default_cursor", kwlist, &py_cursor))
5748
5748
        return NULL;
5749
5749
    if (pyg_boxed_check(py_cursor, GDK_TYPE_CURSOR))
5750
5750
        cursor = pyg_boxed_get(py_cursor, GdkCursor);
5953
5953
    int x, y, width, height;
5954
5954
    char red, green, blue;
5955
5955
 
5956
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iiiiccc:GimpPreviewArea.fill", kwlist, &x, &y, &width, &height, &red, &green, &blue))
 
5956
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iiiiccc:Gimp.PreviewArea.fill", kwlist, &x, &y, &width, &height, &red, &green, &blue))
5957
5957
        return NULL;
5958
5958
    
5959
5959
    gimp_preview_area_fill(GIMP_PREVIEW_AREA(self->obj), x, y, width, height, red, green, blue);
5968
5968
    static char *kwlist[] = { "x", "y", NULL };
5969
5969
    int x, y;
5970
5970
 
5971
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:GimpPreviewArea.set_offsets", kwlist, &x, &y))
 
5971
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.PreviewArea.set_offsets", kwlist, &x, &y))
5972
5972
        return NULL;
5973
5973
    
5974
5974
    gimp_preview_area_set_offsets(GIMP_PREVIEW_AREA(self->obj), x, y);
5984
5984
    int colormap_len, num_colors;
5985
5985
    guchar *colormap;
5986
5986
 
5987
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#i:GimpPreviewArea.set_colormap", kwlist, &colormap, &colormap_len, &num_colors))
 
5987
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s#i:Gimp.PreviewArea.set_colormap", kwlist, &colormap, &colormap_len, &num_colors))
5988
5988
        return NULL;
5989
5989
    
5990
5990
    gimp_preview_area_set_colormap(GIMP_PREVIEW_AREA(self->obj), colormap, num_colors);
5999
5999
    static char *kwlist[] = { "width", "height", NULL };
6000
6000
    int width, height;
6001
6001
 
6002
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:GimpPreviewArea.set_max_size", kwlist, &width, &height))
 
6002
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.PreviewArea.set_max_size", kwlist, &width, &height))
6003
6003
        return NULL;
6004
6004
    
6005
6005
    gimp_preview_area_set_max_size(GIMP_PREVIEW_AREA(self->obj), width, height);
6015
6015
    GdkEvent *event = NULL;
6016
6016
    PyObject *py_event;
6017
6017
 
6018
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:GimpPreviewArea.menu_popup", kwlist, &py_event))
 
6018
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Gimp.PreviewArea.menu_popup", kwlist, &py_event))
6019
6019
        return NULL;
6020
6020
    if (pyg_boxed_check(py_event, GDK_TYPE_EVENT))
6021
6021
        event = pyg_boxed_get(py_event, GdkEvent);
6347
6347
    static char *kwlist[] = { "x", "y", NULL };
6348
6348
    int x, y;
6349
6349
 
6350
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:GimpScrolledPreview.set_position", kwlist, &x, &y))
 
6350
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.ScrolledPreview.set_position", kwlist, &x, &y))
6351
6351
        return NULL;
6352
6352
    
6353
6353
    gimp_scrolled_preview_set_position(GIMP_SCROLLED_PREVIEW(self->obj), x, y);
6363
6363
    PyObject *py_hscrollbar_policy = NULL, *py_vscrollbar_policy = NULL;
6364
6364
    GtkPolicyType hscrollbar_policy, vscrollbar_policy;
6365
6365
 
6366
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:GimpScrolledPreview.set_policy", kwlist, &py_hscrollbar_policy, &py_vscrollbar_policy))
 
6366
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:Gimp.ScrolledPreview.set_policy", kwlist, &py_hscrollbar_policy, &py_vscrollbar_policy))
6367
6367
        return NULL;
6368
6368
    if (pyg_enum_get_value(GTK_TYPE_POLICY_TYPE, py_hscrollbar_policy, (gpointer)&hscrollbar_policy))
6369
6369
        return NULL;
6696
6696
    static char *kwlist[] = { "pattern_name", NULL };
6697
6697
    char *pattern_name;
6698
6698
 
6699
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpPatternSelectButton.set_pattern", kwlist, &pattern_name))
 
6699
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PatternSelectButton.set_pattern", kwlist, &pattern_name))
6700
6700
        return NULL;
6701
6701
    
6702
6702
    gimp_pattern_select_button_set_pattern(GIMP_PATTERN_SELECT_BUTTON(self->obj), pattern_name);
6812
6812
    static char *kwlist[] = { "palette_name", NULL };
6813
6813
    char *palette_name;
6814
6814
 
6815
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpPaletteSelectButton.set_palette", kwlist, &palette_name))
 
6815
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.PaletteSelectButton.set_palette", kwlist, &palette_name))
6816
6816
        return NULL;
6817
6817
    
6818
6818
    gimp_palette_select_button_set_palette(GIMP_PALETTE_SELECT_BUTTON(self->obj), palette_name);
6928
6928
    static char *kwlist[] = { "gradient_name", NULL };
6929
6929
    char *gradient_name;
6930
6930
 
6931
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpGradientSelectButton.set_gradient", kwlist, &gradient_name))
 
6931
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.GradientSelectButton.set_gradient", kwlist, &gradient_name))
6932
6932
        return NULL;
6933
6933
    
6934
6934
    gimp_gradient_select_button_set_gradient(GIMP_GRADIENT_SELECT_BUTTON(self->obj), gradient_name);
7044
7044
    static char *kwlist[] = { "font_name", NULL };
7045
7045
    char *font_name;
7046
7046
 
7047
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpFontSelectButton.set_font", kwlist, &font_name))
 
7047
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.FontSelectButton.set_font", kwlist, &font_name))
7048
7048
        return NULL;
7049
7049
    
7050
7050
    gimp_font_select_button_set_font(GIMP_FONT_SELECT_BUTTON(self->obj), font_name);
7170
7170
    PyObject *py_paint_mode = NULL;
7171
7171
    GimpLayerModeEffects paint_mode;
7172
7172
 
7173
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sdiO:GimpBrushSelectButton.set_brush", kwlist, &brush_name, &opacity, &spacing, &py_paint_mode))
 
7173
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sdiO:Gimp.BrushSelectButton.set_brush", kwlist, &brush_name, &opacity, &spacing, &py_paint_mode))
7174
7174
        return NULL;
7175
7175
    if (pyg_enum_get_value(GIMP_TYPE_LAYER_MODE_EFFECTS, py_paint_mode, (gpointer)&paint_mode))
7176
7176
        return NULL;
7274
7274
    static char *kwlist[] = { "position", NULL };
7275
7275
    double position;
7276
7276
 
7277
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"d:GimpRuler.set_position", kwlist, &position))
 
7277
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"d:Gimp.Ruler.set_position", kwlist, &position))
7278
7278
        return NULL;
7279
7279
    
7280
7280
    gimp_ruler_set_position(GIMP_RULER(self->obj), position);
7300
7300
    static char *kwlist[] = { "lower", "upper", "max_size", NULL };
7301
7301
    double lower, upper, max_size;
7302
7302
 
7303
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ddd:GimpRuler.set_range", kwlist, &lower, &upper, &max_size))
 
7303
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ddd:Gimp.Ruler.set_range", kwlist, &lower, &upper, &max_size))
7304
7304
        return NULL;
7305
7305
    
7306
7306
    gimp_ruler_set_range(GIMP_RULER(self->obj), lower, upper, max_size);
7399
7399
    static char *kwlist[] = { "value_spinbutton", "refval_spinbutton", NULL };
7400
7400
    PyGObject *value_spinbutton, *refval_spinbutton;
7401
7401
 
7402
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!O!:GimpSizeEntry.add_field", kwlist, &PyGtkSpinButton_Type, &value_spinbutton, &PyGtkSpinButton_Type, &refval_spinbutton))
 
7402
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!O!:Gimp.SizeEntry.add_field", kwlist, &PyGtkSpinButton_Type, &value_spinbutton, &PyGtkSpinButton_Type, &refval_spinbutton))
7403
7403
        return NULL;
7404
7404
    
7405
7405
    gimp_size_entry_add_field(GIMP_SIZE_ENTRY(self->obj), GTK_SPIN_BUTTON(value_spinbutton->obj), GTK_SPIN_BUTTON(refval_spinbutton->obj));
7417
7417
    GtkWidget *ret;
7418
7418
    double alignment;
7419
7419
 
7420
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"siid:GimpSizeEntry.attach_label", kwlist, &text, &row, &column, &alignment))
 
7420
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"siid:Gimp.SizeEntry.attach_label", kwlist, &text, &row, &column, &alignment))
7421
7421
        return NULL;
7422
7422
    
7423
7423
    ret = gimp_size_entry_attach_label(GIMP_SIZE_ENTRY(self->obj), text, row, column, alignment);
7433
7433
    int field, keep_size;
7434
7434
    double resolution;
7435
7435
 
7436
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idi:GimpSizeEntry.set_resolution", kwlist, &field, &resolution, &keep_size))
 
7436
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idi:Gimp.SizeEntry.set_resolution", kwlist, &field, &resolution, &keep_size))
7437
7437
        return NULL;
7438
7438
    
7439
7439
    gimp_size_entry_set_resolution(GIMP_SIZE_ENTRY(self->obj), field, resolution, keep_size);
7449
7449
    int field;
7450
7450
    double lower, upper;
7451
7451
 
7452
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idd:GimpSizeEntry.set_size", kwlist, &field, &lower, &upper))
 
7452
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idd:Gimp.SizeEntry.set_size", kwlist, &field, &lower, &upper))
7453
7453
        return NULL;
7454
7454
    
7455
7455
    gimp_size_entry_set_size(GIMP_SIZE_ENTRY(self->obj), field, lower, upper);
7465
7465
    int field;
7466
7466
    double lower, upper;
7467
7467
 
7468
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idd:GimpSizeEntry.set_value_boundaries", kwlist, &field, &lower, &upper))
 
7468
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idd:Gimp.SizeEntry.set_value_boundaries", kwlist, &field, &lower, &upper))
7469
7469
        return NULL;
7470
7470
    
7471
7471
    gimp_size_entry_set_value_boundaries(GIMP_SIZE_ENTRY(self->obj), field, lower, upper);
7481
7481
    int field;
7482
7482
    double ret;
7483
7483
 
7484
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpSizeEntry.get_value", kwlist, &field))
 
7484
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.get_value", kwlist, &field))
7485
7485
        return NULL;
7486
7486
    
7487
7487
    ret = gimp_size_entry_get_value(GIMP_SIZE_ENTRY(self->obj), field);
7496
7496
    int field;
7497
7497
    double value;
7498
7498
 
7499
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"id:GimpSizeEntry.set_value", kwlist, &field, &value))
 
7499
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"id:Gimp.SizeEntry.set_value", kwlist, &field, &value))
7500
7500
        return NULL;
7501
7501
    
7502
7502
    gimp_size_entry_set_value(GIMP_SIZE_ENTRY(self->obj), field, value);
7512
7512
    int field;
7513
7513
    double lower, upper;
7514
7514
 
7515
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idd:GimpSizeEntry.set_refval_boundaries", kwlist, &field, &lower, &upper))
 
7515
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idd:Gimp.SizeEntry.set_refval_boundaries", kwlist, &field, &lower, &upper))
7516
7516
        return NULL;
7517
7517
    
7518
7518
    gimp_size_entry_set_refval_boundaries(GIMP_SIZE_ENTRY(self->obj), field, lower, upper);
7527
7527
    static char *kwlist[] = { "field", "digits", NULL };
7528
7528
    int field, digits;
7529
7529
 
7530
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:GimpSizeEntry.set_refval_digits", kwlist, &field, &digits))
 
7530
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ii:Gimp.SizeEntry.set_refval_digits", kwlist, &field, &digits))
7531
7531
        return NULL;
7532
7532
    
7533
7533
    gimp_size_entry_set_refval_digits(GIMP_SIZE_ENTRY(self->obj), field, digits);
7543
7543
    int field;
7544
7544
    double ret;
7545
7545
 
7546
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpSizeEntry.get_refval", kwlist, &field))
 
7546
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.get_refval", kwlist, &field))
7547
7547
        return NULL;
7548
7548
    
7549
7549
    ret = gimp_size_entry_get_refval(GIMP_SIZE_ENTRY(self->obj), field);
7558
7558
    int field;
7559
7559
    double refval;
7560
7560
 
7561
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"id:GimpSizeEntry.set_refval", kwlist, &field, &refval))
 
7561
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"id:Gimp.SizeEntry.set_refval", kwlist, &field, &refval))
7562
7562
        return NULL;
7563
7563
    
7564
7564
    gimp_size_entry_set_refval(GIMP_SIZE_ENTRY(self->obj), field, refval);
7573
7573
    static char *kwlist[] = { "show", NULL };
7574
7574
    int show;
7575
7575
 
7576
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpSizeEntry.show_unit_menu", kwlist, &show))
 
7576
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.show_unit_menu", kwlist, &show))
7577
7577
        return NULL;
7578
7578
    
7579
7579
    gimp_size_entry_show_unit_menu(GIMP_SIZE_ENTRY(self->obj), show);
7588
7588
    static char *kwlist[] = { "digits", NULL };
7589
7589
    int digits;
7590
7590
 
7591
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpSizeEntry.set_pixel_digits", kwlist, &digits))
 
7591
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.set_pixel_digits", kwlist, &digits))
7592
7592
        return NULL;
7593
7593
    
7594
7594
    gimp_size_entry_set_pixel_digits(GIMP_SIZE_ENTRY(self->obj), digits);
7613
7613
    static char *kwlist[] = { "setting", NULL };
7614
7614
    int setting;
7615
7615
 
7616
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpSizeEntry.set_activates_default", kwlist, &setting))
 
7616
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.set_activates_default", kwlist, &setting))
7617
7617
        return NULL;
7618
7618
    
7619
7619
    gimp_size_entry_set_activates_default(GIMP_SIZE_ENTRY(self->obj), setting);
7629
7629
    int field;
7630
7630
    GtkWidget *ret;
7631
7631
 
7632
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpSizeEntry.get_help_widget", kwlist, &field))
 
7632
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.SizeEntry.get_help_widget", kwlist, &field))
7633
7633
        return NULL;
7634
7634
    
7635
7635
    ret = gimp_size_entry_get_help_widget(GIMP_SIZE_ENTRY(self->obj), field);
7760
7760
    char *id;
7761
7761
    int ret;
7762
7762
 
7763
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:GimpStringComboBox.set_active", kwlist, &id))
 
7763
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Gimp.StringComboBox.set_active", kwlist, &id))
7764
7764
        return NULL;
7765
7765
    
7766
7766
    ret = gimp_string_combo_box_set_active(GIMP_STRING_COMBO_BOX(self->obj), id);
7849
7849
    static char *kwlist[] = { "digits", NULL };
7850
7850
    int digits;
7851
7851
 
7852
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:GimpUnitMenu.set_pixel_digits", kwlist, &digits))
 
7852
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Gimp.UnitMenu.set_pixel_digits", kwlist, &digits))
7853
7853
        return NULL;
7854
7854
    
7855
7855
    gimp_unit_menu_set_pixel_digits(GIMP_UNIT_MENU(self->obj), digits);
8145
8145
    static char *kwlist[] = { "min", "max", NULL };
8146
8146
    double min, max;
8147
8147
 
8148
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:GimpZoomModel.set_range", kwlist, &min, &max))
 
8148
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Gimp.ZoomModel.set_range", kwlist, &min, &max))
8149
8149
        return NULL;
8150
8150
    
8151
8151
    gimp_zoom_model_set_range(GIMP_ZOOM_MODEL(self->obj), min, max);
8162
8162
    double scale;
8163
8163
    GimpZoomType zoom_type;
8164
8164
 
8165
 
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Od:GimpZoomModel.zoom", kwlist, &py_zoom_type, &scale))
 
8165
    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"Od:Gimp.ZoomModel.zoom", kwlist, &py_zoom_type, &scale))
8166
8166
        return NULL;
8167
8167
    if (pyg_enum_get_value(GIMP_TYPE_ZOOM_TYPE, py_zoom_type, (gpointer)&zoom_type))
8168
8168
        return NULL;