? setenv.sh Index: setup.py =================================================================== RCS file: /cvs/gnome/sketch/setup.py,v retrieving revision 1.2 diff -u -r1.2 setup.py --- setup.py 4 Aug 2001 20:53:04 -0000 1.2 +++ setup.py 14 Jan 2003 20:05:31 -0000 @@ -145,10 +145,15 @@ # get gtk config print 'determine GTK configuration...', - libs, cflags = run_config_script('gtk-config') + libs, cflags = run_config_script('pkg-config', 'gtk+-2.0') flags['gtk']['libs'] = libs flags['gtk']['cflags'] = cflags print 'done' + print 'determine PyGTK configuration...', + libs, cflags = run_config_script('pkg-config', 'pygtk-2.0') + flags['gtk']['libs'] += " " + libs + flags['gtk']['cflags'] += " " + cflags + print "done" if '_libart' in flags['ignore_targets']: print 'configuring without libart', Index: sketch.py =================================================================== RCS file: /cvs/gnome/sketch/sketch.py,v retrieving revision 1.6 diff -u -r1.6 sketch.py --- sketch.py 13 Jul 2000 21:49:25 -0000 1.6 +++ sketch.py 14 Jan 2003 20:05:31 -0000 @@ -1,7 +1,7 @@ #! /usr/bin/env python # Sketch - A Python-based interactive drawing program -# Copyright (C) 1996, 1997, 1998, 1999, 2000 by Bernhard Herzog +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -33,9 +33,8 @@ #if os.environ.has_key('LC_CTYPE'): os.environ['LC_CTYPE'] = 'C' -if sys.version < '1.5.1': - sys.stderr.write("Sorry, Sketch requires at least Python 1.5.1\n") - sys.exit(1) +#import pygtk +#pygtk.require("2.0") import Sketch.UI Index: Sketch/Modules/_skgtkmodule.c =================================================================== RCS file: /cvs/gnome/sketch/Sketch/Modules/_skgtkmodule.c,v retrieving revision 1.7 diff -u -r1.7 _skgtkmodule.c --- Sketch/Modules/_skgtkmodule.c 4 Dec 2001 21:21:11 -0000 1.7 +++ Sketch/Modules/_skgtkmodule.c 14 Jan 2003 20:05:31 -0000 @@ -1,5 +1,5 @@ /* Sketch - A Python-based interactive drawing program - * Copyright (C) 1997, 1998, 1999, 2000, 2001 by Bernhard Herzog + * Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003 by Bernhard Herzog * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -45,13 +45,13 @@ static PyObject * skgtk_widget_visual_type(PyObject * self, PyObject * args) { - PyGtk_Object * widget_object; + PyGObject * widget_object; GdkVisual * visual; - if (!PyArg_ParseTuple(args, "O!", &PyGtk_Type, &widget_object)) + if (!PyArg_ParseTuple(args, "O!", &PyGObject_Type, &widget_object)) return NULL; - visual = gtk_widget_get_visual(GTK_WIDGET(PyGtk_Get(widget_object))); + visual = gtk_widget_get_visual(GTK_WIDGET(widget_object->obj)); return PyInt_FromLong(visual->type); } @@ -59,15 +59,15 @@ static PyObject * skgtk_window_set_colormap(PyObject * self, PyObject * args) { - PyGdkWindow_Object * window_object; - PyGdkColormap_Object * cmap_object; + PyGObject * window_object; + PyGObject * cmap_object; - if (!PyArg_ParseTuple(args, "O!O!", &PyGdkWindow_Type, &window_object, - &PyGdkColormap_Type, &cmap_object)) + if (!PyArg_ParseTuple(args, "O!O!", &PyGObject_Type, &window_object, + &PyGObject_Type, &cmap_object)) return NULL; - gdk_window_set_colormap(PyGdkWindow_Get(window_object), - PyGdkColormap_Get(cmap_object)); + gdk_window_set_colormap(GDK_WINDOW(window_object->obj), + GDK_COLORMAP(cmap_object->obj)); Py_INCREF(Py_None); return Py_None; @@ -76,26 +76,26 @@ static PyObject* skgtk_copy_colormap(PyObject * self, PyObject * args) { - PyGdkColormap_Object * cmap_object; + PyGObject * cmap_object; GdkVisual * visual; - if (!PyArg_ParseTuple(args, "O!", &PyGdkColormap_Type, &cmap_object)) + if (!PyArg_ParseTuple(args, "O!", &PyGObject_Type, &cmap_object)) return NULL; - visual = gdk_colormap_get_visual(PyGdkColormap_Get(cmap_object)); - return PyGdkColormap_New(gdk_colormap_new(visual, 1)); + visual = gdk_colormap_get_visual(GDK_COLORMAP(cmap_object->obj)); + return pygobject_new(G_OBJECT(gdk_colormap_new(visual, 1))); } static PyObject* skgtk_colormap_alloc_color(PyObject * self, PyObject * args) { - PyGdkColormap_Object * cmap_object; + PyGObject * cmap_object; GdkColor color = {0, 0, 0, 0}; int red, green, blue; int writeable, best_match; - if (!PyArg_ParseTuple(args, "O!iiiii", &PyGdkColormap_Type, &cmap_object, + if (!PyArg_ParseTuple(args, "O!iiiii", &PyGObject_Type, &cmap_object, &(red), &(green), &(blue), &writeable, &best_match)) { return NULL; @@ -104,13 +104,13 @@ color.green = green; color.blue = blue; - if (!gdk_colormap_alloc_color(PyGdkColormap_Get(cmap_object), + if (!gdk_colormap_alloc_color(GDK_COLORMAP(cmap_object->obj), &color, writeable, best_match)) { PyErr_SetString(PyExc_RuntimeError, "couldn't allocate color"); return NULL; } - return PyGdkColor_New(&color); + return pyg_boxed_new(GDK_TYPE_COLOR, &color, TRUE, TRUE); } @@ -126,9 +126,9 @@ skgtk_set_foreground_and_fill(PyObject *self, PyObject *args) { PyObject * pixel_or_pixmap; - PyGdkGC_Object * gc_object; + PyGObject * gc_object; - if (!PyArg_ParseTuple(args, "O!O", &PyGdkGC_Type, &gc_object, + if (!PyArg_ParseTuple(args, "O!O", &PyGObject_Type, &gc_object, &pixel_or_pixmap)) return NULL; @@ -138,17 +138,17 @@ color.pixel = PyInt_AsLong(pixel_or_pixmap); color.red = color.green = color.blue = 0; - gdk_gc_set_foreground(PyGdkGC_Get(gc_object), &color); - gdk_gc_set_fill(PyGdkGC_Get(gc_object), GDK_SOLID); + gdk_gc_set_foreground(GDK_GC(gc_object->obj), &color); + gdk_gc_set_fill(GDK_GC(gc_object->obj), GDK_SOLID); } - else if (PyGdkWindow_Check(pixel_or_pixmap)) + else if (pygobject_check(pixel_or_pixmap, &PyGObject_Type)) { - if (gdk_window_get_type(PyGdkWindow_Get(pixel_or_pixmap)) - == GDK_WINDOW_PIXMAP) + PyGObject * pixmap_object = (PyGObject*)pixel_or_pixmap; + if (GDK_IS_PIXMAP(pixmap_object->obj)) { - gdk_gc_set_tile(PyGdkGC_Get(gc_object), - PyGdkWindow_Get(pixel_or_pixmap)); - gdk_gc_set_fill(PyGdkGC_Get(gc_object), GDK_TILED); + gdk_gc_set_tile(GDK_GC(gc_object->obj), + GDK_PIXMAP(pixmap_object->obj)); + gdk_gc_set_fill(GDK_GC(gc_object), GDK_TILED); } } Py_INCREF(Py_None); @@ -159,23 +159,24 @@ skgtk_set_clip_mask(PyObject *self, PyObject *args) { PyObject * mask; - PyGdkGC_Object * gc_object; + PyGObject * gc_object; - if (!PyArg_ParseTuple(args, "O!O", &PyGdkGC_Type, &gc_object, &mask)) + if (!PyArg_ParseTuple(args, "O!O", &PyGObject_Type, &gc_object, &mask)) return NULL; - if (PyGdkWindow_Check(mask)) + if (pygobject_check(mask, &PyGObject_Type)) { - gdk_gc_set_clip_mask(PyGdkGC_Get(gc_object), PyGdkWindow_Get(mask)); + gdk_gc_set_clip_mask(GDK_GC(gc_object->obj), + GDK_PIXMAP(((PyGObject*)mask)->obj)); } else if (SKRegion_Check(mask)) { - gdk_gc_set_clip_region(PyGdkGC_Get(gc_object), + gdk_gc_set_clip_region(GDK_GC(gc_object->obj), SKRegion_AsRegion(mask)); } else if (mask == Py_None) { - gdk_gc_set_clip_mask(PyGdkGC_Get(gc_object), NULL); + gdk_gc_set_clip_mask(GDK_GC(gc_object->obj), NULL); } else { @@ -191,15 +192,16 @@ static PyObject * skgtk_draw_image(PyObject *self, PyObject *args) { - PyObject * window, *gc, *image; + PyGObject *window, *gc; + PyObject *image; gint xsrc, ysrc, xdest, ydest, width, height; - if (!PyArg_ParseTuple(args, "O!O!O!iiiiii", &PyGdkWindow_Type, &window, - &PyGdkGC_Type, &gc, &SKImageType, &image, + if (!PyArg_ParseTuple(args, "O!O!O!iiiiii", &PyGObject_Type, &window, + &PyGObject_Type, &gc, &SKImageType, &image, &xsrc, &ysrc, &xdest, &ydest, &width, &height)) return NULL; - gdk_draw_image(PyGdkWindow_Get(window), PyGdkGC_Get(gc), + gdk_draw_image(GDK_DRAWABLE(window->obj), GDK_GC(gc->obj), SKImage_AsImage(image), xsrc, ysrc, xdest, ydest, width, height); @@ -211,33 +213,31 @@ static PyObject * skgtk_draw_bitmap(PyObject *self, PyObject *args) { - PyObject * window, *gc, *bitmap; + PyGObject * window, *gc, *bitmap; gint xdest, ydest; gint width, height; - if (!PyArg_ParseTuple(args, "O!O!O!ii", &PyGdkWindow_Type, &window, - &PyGdkGC_Type, &gc, &PyGdkWindow_Type, &bitmap, + if (!PyArg_ParseTuple(args, "O!O!O!ii", &PyGObject_Type, &window, + &PyGObject_Type, &gc, &PyGObject_Type, &bitmap, &xdest, &ydest)) return NULL; - if (gdk_window_get_type(PyGdkWindow_Get(bitmap)) != GDK_WINDOW_PIXMAP) + if (!GDK_IS_PIXMAP(bitmap->obj) + || gdk_drawable_get_depth(GDK_DRAWABLE(bitmap->obj)) > 1) { PyErr_SetString(PyExc_TypeError, "bitmap expected"); return NULL; } -/* gdk_draw_bitmap(PyGdkWindow_Get(window), PyGdkGC_Get(gc), - PyGdkWindow_Get(bitmap), - 0, 0, xdest, ydest, -1, -1);*/ - gdk_window_get_size(PyGdkWindow_Get(bitmap), &width, &height); + gdk_drawable_get_size(GDK_DRAWABLE(bitmap->obj), &width, &height); - gdk_gc_set_ts_origin(PyGdkGC_Get(gc), xdest, ydest); - gdk_gc_set_stipple(PyGdkGC_Get(gc), PyGdkWindow_Get(bitmap)); - gdk_gc_set_fill(PyGdkGC_Get(gc), GDK_STIPPLED); - gdk_draw_rectangle(PyGdkWindow_Get(window), PyGdkGC_Get(gc), TRUE, + gdk_gc_set_ts_origin(GDK_GC(gc->obj), xdest, ydest); + gdk_gc_set_stipple(GDK_GC(gc->obj), GDK_PIXMAP(bitmap->obj)); + gdk_gc_set_fill(GDK_GC(gc->obj), GDK_STIPPLED); + gdk_draw_rectangle(GDK_DRAWABLE(window->obj), GDK_GC(gc->obj), TRUE, xdest, ydest, width, height); - gdk_gc_set_fill(PyGdkGC_Get(gc), GDK_SOLID); + gdk_gc_set_fill(GDK_GC(gc->obj), GDK_SOLID); Py_INCREF(Py_None); return Py_None; @@ -247,14 +247,14 @@ static PyObject * skgtk_clear_area(PyObject * self, PyObject * args) { - PyObject * window; + PyGObject * window; gint x, y, width, height; - if (!PyArg_ParseTuple(args, "O!iiii", &PyGdkWindow_Type, &window, + if (!PyArg_ParseTuple(args, "O!iiii", &PyGObject_Type, &window, &x, &y, &width, &height)) return NULL; - gdk_window_clear_area(PyGdkWindow_Get(window), x, y, width, height); + gdk_window_clear_area(GDK_WINDOW(window->obj), x, y, width, height); Py_INCREF(Py_None); return Py_None; @@ -264,21 +264,20 @@ static PyObject * skgtk_copy_area(PyObject * self, PyObject * args) { - PyObject * window; - PyObject *srcwin, *gc; + PyGObject *window, *srcwin, *gc; gint src_x, src_y, dest_x, dest_y; guint width, height; - if (!PyArg_ParseTuple(args, "O!O!iiO!iiii", &PyGdkWindow_Type, &window, - &PyGdkGC_Type, &gc, + if (!PyArg_ParseTuple(args, "O!O!iiO!iiii", &PyGObject_Type, &window, + &PyGObject_Type, &gc, &dest_x, &dest_y, - &PyGdkWindow_Type, &srcwin, &src_x, &src_y, + &PyGObject_Type, &srcwin, &src_x, &src_y, &width, &height)) return NULL; - gdk_window_copy_area(PyGdkWindow_Get(window), PyGdkGC_Get(gc), + gdk_window_copy_area(GDK_WINDOW(window->obj), GDK_GC(gc->obj), dest_x, dest_y, - PyGdkWindow_Get(srcwin), src_x, src_y, width, height); + GDK_WINDOW(srcwin->obj), src_x, src_y, width, height); Py_INCREF(Py_None); return Py_None; @@ -297,19 +296,19 @@ static PyObject * skgtk_draw_artpixbuf(PyObject *self, PyObject *args) { - PyObject * window, *gc; + PyGObject *window, *gc; SKArtPixBufObject * pixbuf; gint x, y; - if (!PyArg_ParseTuple(args, "O!O!O!ii", &PyGdkWindow_Type, &window, - &PyGdkGC_Type, &gc, PSKArtPixBufType, &pixbuf, + if (!PyArg_ParseTuple(args, "O!O!O!ii", &PyGObject_Type, &window, + &PyGObject_Type, &gc, PSKArtPixBufType, &pixbuf, &x, &y)) return NULL; gdk_rgb_init(); if (pixbuf->artpixbuf->n_channels == 3) { - gdk_draw_rgb_image(PyGdkWindow_Get(window), PyGdkGC_Get(gc), + gdk_draw_rgb_image(GDK_DRAWABLE(window->obj), GDK_GC(gc->obj), x, y, pixbuf->artpixbuf->width, pixbuf->artpixbuf->height, @@ -319,7 +318,7 @@ } else { - gdk_draw_rgb_32_image(PyGdkWindow_Get(window), PyGdkGC_Get(gc), + gdk_draw_rgb_32_image(GDK_DRAWABLE(window->obj), GDK_GC(gc->obj), x, y, pixbuf->artpixbuf->width, pixbuf->artpixbuf->height, @@ -363,10 +362,11 @@ static PyObject * skgtk_set_adjustment(PyObject * self, PyObject * args) { - PyObject *adjustment, *dict, *key, *value; + PyGObject *adjustment; + PyObject *dict, *key, *value; int pos; - if (!PyArg_ParseTuple(args, "O!O!", &PyGtk_Type, &adjustment, + if (!PyArg_ParseTuple(args, "O!O!", &PyGObject_Type, &adjustment, &PyDict_Type, &dict)) return NULL; @@ -375,7 +375,7 @@ { if (PyString_Check(key) && PyNumber_Check(value)) { - if (PyMember_Set((char*)(GTK_ADJUSTMENT(PyGtk_Get(adjustment))), + if (PyMember_Set((char*)(GTK_ADJUSTMENT(adjustment->obj)), adjustment_memberlist, PyString_AsString(key), value) == -1) return NULL; @@ -398,17 +398,16 @@ static PyObject * draw_grid(PyObject * self, PyObject * arg) { - double xwidth, ywidth; - double orig_x, orig_y; - PyGdkGC_Object *gc_object; - PyGdkWindow_Object * window_object; - int nx, ny; - int ix, iy; - GdkPoint * points, *current; + double xwidth, ywidth; + double orig_x, orig_y; + PyGObject *gc_object, *window_object; + int nx, ny; + int ix, iy; + GdkPoint *points, *current; if (!PyArg_ParseTuple(arg, "O!O!ddddii", - &PyGdkWindow_Type, &window_object, - &PyGdkGC_Type, &gc_object, + &PyGObject_Type, &window_object, + &PyGObject_Type, &gc_object, &orig_x, &orig_y, &xwidth, &ywidth, &nx, &ny)) return NULL; @@ -424,7 +423,7 @@ current++; } } - gdk_draw_points(PyGdkWindow_Get(window_object), PyGdkGC_Get(gc_object), + gdk_draw_points(GDK_DRAWABLE(window_object->obj), GDK_GC(gc_object->obj), points, nx * ny); free(points); @@ -437,16 +436,16 @@ get_pixel(PyObject * self, PyObject * arg) { GdkImage * image; - PyGdkWindow_Object * window_object; + PyGObject * window_object; int x, y; int retval; - if (!PyArg_ParseTuple(arg, "O!ii", &PyGdkWindow_Type, &window_object, + if (!PyArg_ParseTuple(arg, "O!ii", &PyGObject_Type, &window_object, &x, &y)) return NULL; - image = gdk_image_get(PyGdkWindow_Get(window_object), x, y, 1, 1); + image = gdk_image_get(GDK_DRAWABLE(window_object->obj), x, y, 1, 1); if (!image) { fprintf(stderr, "Warning! skaux.GetPixel: image == NULL"); @@ -574,6 +573,7 @@ Sketch_Interface * sketch_interface; +PyTypeObject *SKGTK_PyGObject_Type; /* * Init module @@ -613,6 +613,19 @@ ADD_INT(GDK_IMAGE_NORMAL); ADD_INT(GDK_IMAGE_SHARED); ADD_INT(GDK_IMAGE_FASTEST); + + /* import some objects from gobject */ + if ((module = PyImport_ImportModule("gobject")) != NULL) { + PyObject *moddict = PyModule_GetDict(module); + + SKGTK_PyGObject_Type = (PyTypeObject *)PyDict_GetItemString(moddict, + "GObject"); + } + else + { + Py_FatalError("could not import gobject"); + return; + } /* import some objects from pygtk */ init_pygtk(); Index: Sketch/Modules/_skgtkmodule.h =================================================================== RCS file: /cvs/gnome/sketch/Sketch/Modules/_skgtkmodule.h,v retrieving revision 1.2 diff -u -r1.2 _skgtkmodule.h --- Sketch/Modules/_skgtkmodule.h 25 Jan 2000 23:42:02 -0000 1.2 +++ Sketch/Modules/_skgtkmodule.h 14 Jan 2003 20:05:31 -0000 @@ -1,5 +1,5 @@ /* Sketch - A Python-based interactive drawing program - * Copyright (C) 1998, 1999, 2000 by Bernhard Herzog + * Copyright (C) 1998, 1999, 2000, 2003 by Bernhard Herzog * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -27,11 +27,15 @@ extern Sketch_Interface * sketch_interface; #ifdef SKGTK_MAIN +#include #include #else #define NO_IMPORT_PYGTK #include #endif +/* This is initialized in init_skgtk */ +extern PyTypeObject *SKGTK_PyGObject_Type; +#define PyGObject_Type (*SKGTK_PyGObject_Type) #endif /* _SKGTK_H */ Index: Sketch/Modules/clipmask.c =================================================================== RCS file: /cvs/gnome/sketch/Sketch/Modules/clipmask.c,v retrieving revision 1.2 diff -u -r1.2 clipmask.c --- Sketch/Modules/clipmask.c 13 May 2002 20:20:42 -0000 1.2 +++ Sketch/Modules/clipmask.c 14 Jan 2003 20:05:31 -0000 @@ -1,5 +1,5 @@ /* Sketch - A Python-based interactive drawing program - * Copyright (C) 1998, 1999, 2002 by Bernhard Herzog + * Copyright (C) 1998, 1999, 2002, 2003 by Bernhard Herzog * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -22,12 +22,11 @@ #include "_skgtkmodule.h" #include "clipmask.h" -static PyObject * +static void mask_intersect_regions(GdkRegion * region1, GdkRegion * region2) { - GdkRegion * result = gdk_regions_intersect(region1, region2); - - return SKRegion_FromRegion(result); + GdkRegion * result = gdk_region_copy(region1); + gdk_region_intersect(region1, region2); } static PyObject * @@ -64,7 +63,7 @@ gdk_gc_destroy(gc); - return PyGdkWindow_New(result); + return pygobject_new(G_OBJECT(result)); } @@ -114,7 +113,7 @@ gdk_gc_destroy(gc); - return PyGdkWindow_New(result); + return pygobject_new(G_OBJECT(result)); } static PyObject * @@ -134,20 +133,33 @@ if (SKRegion_Check(mask1)) { if (SKRegion_Check(mask2)) - return mask_intersect_regions(SKRegion_AsRegion(mask1), - SKRegion_AsRegion(mask2)); - else if (PyGdkWindow_Check(mask2)) - return mask_intersect_region_with_bitmap(SKRegion_AsRegion(mask1), - PyGdkWindow_Get(mask2)); + { + mask_intersect_regions(SKRegion_AsRegion(mask1), + SKRegion_AsRegion(mask2)); + Py_INCREF(mask1); + return mask1; + } + else if (pygobject_check(mask2, &PyGObject_Type)) + { + PyGObject * gmask = (PyGObject*)mask2; + if (GDK_IS_PIXMAP(gmask->obj)) + return mask_intersect_region_with_bitmap(SKRegion_AsRegion(mask1), + GDK_PIXMAP(gmask->obj)); + } } - else if (PyGdkWindow_Check(mask1)) + else if (pygobject_check(mask1, &PyGObject_Type)) { + PyGObject * gmask1 = (PyGObject*)mask1; + if (SKRegion_Check(mask2)) return mask_intersect_region_with_bitmap(SKRegion_AsRegion(mask2), - PyGdkWindow_Get(mask1)); - else if (PyGdkWindow_Check(mask2)) - return mask_intersect_bitmaps(PyGdkWindow_Get(mask1), - PyGdkWindow_Get(mask2)); + GDK_PIXMAP(gmask1->obj)); + else if (pygobject_check(mask2, &PyGObject_Type)) + { + PyGObject * gmask2 = (PyGObject*)mask2; + return mask_intersect_bitmaps(GDK_PIXMAP(gmask1->obj), + GDK_PIXMAP(gmask2->obj)); + } } PyErr_SetString(PyExc_TypeError, Index: Sketch/Modules/curvedraw.c =================================================================== RCS file: /cvs/gnome/sketch/Sketch/Modules/curvedraw.c,v retrieving revision 1.1.1.1 diff -u -r1.1.1.1 curvedraw.c --- Sketch/Modules/curvedraw.c 24 Jan 2000 23:03:30 -0000 1.1.1.1 +++ Sketch/Modules/curvedraw.c 14 Jan 2003 20:05:31 -0000 @@ -1,5 +1,5 @@ /* Sketch - A Python-based interactive drawing program - * Copyright (C) 1997, 1998, 1999 by Bernhard Herzog + * Copyright (C) 1997, 1998, 1999, 2003 by Bernhard Herzog * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -210,15 +210,15 @@ SKCoord nx, ny, x1, y1, x2, y2, lastx, lasty; int x[4], y[4]; PyObject * fill, * line, *rect_or_none; - PyGdkGC_Object * gc_object; - PyGdkWindow_Object * window_object; + PyGObject * gc_object; + PyGObject * window_object; SKRectObject * clip_rect = NULL; SKCurveObject * path; int optimize_clip = 0; if (!PyArg_ParseTuple(args, "O!O!O!O!OOO", - &PyGdkWindow_Type, &window_object, - &PyGdkGC_Type, &gc_object, + &PyGObject_Type, &window_object, + &PyGObject_Type, &gc_object, sketch_interface->SKCurveType, &path, sketch_interface->SKTrafoType, &trafo, &line, &fill, &rect_or_none)) @@ -321,12 +321,13 @@ { if (path->closed && PyObject_IsTrue(fill)) { - gdk_draw_polygon(window_object->obj, gc_object->obj, - 1, points, length); + gdk_draw_polygon(GDK_DRAWABLE(window_object->obj), + GDK_GC(gc_object->obj), 1, points, length); } if (PyObject_IsTrue(line)) { - gdk_draw_lines(window_object->obj, gc_object->obj, points, length); + gdk_draw_lines(GDK_DRAWABLE(window_object->obj), + GDK_GC(gc_object->obj), points, length); } } #if 0 @@ -509,8 +510,8 @@ PyObject *fill_func, *line_func, *push_clip, *pop_clip, *set_clip; PyObject *rect_or_none, *paths; SKCurveObject *path; - PyGdkGC_Object * gc_object; - PyGdkWindow_Object * window_object; + PyGObject * gc_object; + PyGObject * window_object; SKRectObject * clip_rect = NULL; GdkPoint start; SKRegionObject * oregion = NULL; @@ -518,8 +519,8 @@ double arrow_retract1 = 0.0, arrow_retract2 = 0.0; if (!PyArg_ParseTuple(args, "O!O!O!OOOOOOO!O!ii|dd", - &PyGdkWindow_Type, &window_object, - &PyGdkGC_Type, &gc_object, + &PyGObject_Type, &window_object, + &PyGObject_Type, &gc_object, sketch_interface->SKTrafoType, &trafo, &line_func, &fill_func, &push_clip, &pop_clip, &set_clip, &rect_or_none, @@ -656,7 +657,8 @@ if (!result) goto fail; Py_DECREF(result); - gdk_draw_polygon(window_object->obj, gc_object->obj, + gdk_draw_polygon(GDK_DRAWABLE(window_object->obj), + GDK_GC(gc_object->obj), 1, points, length); } @@ -695,8 +697,8 @@ len -= retract; } if (len) - gdk_draw_lines(window_object->obj, gc_object->obj, - pts, len); + gdk_draw_lines(GDK_DRAWABLE(window_object->obj), + GDK_GC(gc_object->obj), pts, len); } } } @@ -832,22 +834,23 @@ PyObject * SKCurve_PyDrawBezierSegment(PyObject * self, PyObject * arg) { - PyGdkGC_Object *gc_object; - PyGdkWindow_Object * window_object; + PyGObject *gc_object; + PyGObject * window_object; int x[4], y[4]; GdkPoint points[BEZIER_FILL_LENGTH]; int count; if (!PyArg_ParseTuple(arg, "O!O!iiiiiiii", - &PyGdkWindow_Type, &window_object, - &PyGdkGC_Type, &gc_object, + &PyGObject_Type, &window_object, + &PyGObject_Type, &gc_object, &x[0], &y[0], &x[1], &y[1], &x[2], &y[2], &x[3], &y[3])) return NULL; count = bezier_fill_points(points, x, y); - gdk_draw_lines(window_object->obj, gc_object->obj, points, count); + gdk_draw_lines(GDK_DRAWABLE(window_object->obj), GDK_GC(gc_object->obj), + points, count); Py_INCREF(Py_None); return Py_None; Index: Sketch/Modules/imageobject.c =================================================================== RCS file: /cvs/gnome/sketch/Sketch/Modules/imageobject.c,v retrieving revision 1.2 diff -u -r1.2 imageobject.c --- Sketch/Modules/imageobject.c 2 Aug 2000 19:41:38 -0000 1.2 +++ Sketch/Modules/imageobject.c 14 Jan 2003 20:05:31 -0000 @@ -1,5 +1,5 @@ /* Sketch - A Python-based interactive drawing program - * Copyright (C) 1997, 1998, 1999, 2000 by Bernhard Herzog + * Copyright (C) 1997, 1998, 1999, 2000, 2003 by Bernhard Herzog * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -176,18 +176,18 @@ PyObject * SKImage_PyNew(PyObject * self, PyObject * args) { - PyObject * window; + PyGObject * window; int width, height; int type; GdkImage * image; PyObject * image_object; - if (!PyArg_ParseTuple(args, "O!iii", &PyGdkWindow_Type, &window, + if (!PyArg_ParseTuple(args, "O!iii", &PyGObject_Type, &window, &type, &width, &height)) return NULL; image = gdk_image_new(type, - gdk_window_get_visual(PyGdkWindow_Get(window)), + gdk_window_get_visual(GDK_WINDOW(window->obj)), width, height); image_object = SKImage_FromImage(image); if (!image_object) Index: Sketch/Modules/regionobject.c =================================================================== RCS file: /cvs/gnome/sketch/Sketch/Modules/regionobject.c,v retrieving revision 1.2 diff -u -r1.2 regionobject.c --- Sketch/Modules/regionobject.c 2 Aug 2000 19:41:38 -0000 1.2 +++ Sketch/Modules/regionobject.c 14 Jan 2003 20:05:31 -0000 @@ -1,5 +1,5 @@ /* Sketch - A Python-based interactive drawing program - * Copyright (C) 1998, 1999, 2000 by Bernhard Herzog + * Copyright (C) 1998, 1999, 2000, 2003 by Bernhard Herzog * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -115,12 +115,12 @@ region_IntersectRegion(SKRegionObject *self, PyObject *args) { SKRegionObject * other; - GdkRegion * result; + if (!PyArg_ParseTuple(args, "O!", &SKRegionType, &other)) return NULL; - result = gdk_regions_intersect(self->region, other->region); - gdk_region_destroy(self->region); - self->region = result; + + gdk_region_intersect(self->region, other->region); + Py_INCREF(Py_None); return Py_None; } @@ -129,12 +129,12 @@ region_UnionRegion(SKRegionObject *self, PyObject *args) { SKRegionObject *r; - GdkRegion * result; + if (!PyArg_ParseTuple(args, "O!", &SKRegionType, &r)) return NULL; - result = gdk_regions_union(self->region, r->region); - gdk_region_destroy(self->region); - self->region = result; + + gdk_region_union(self->region, r->region); + Py_INCREF(Py_None); return Py_None; } @@ -143,12 +143,12 @@ region_UnionRectWithRegion(SKRegionObject *self, PyObject *args) { GdkRectangle r; - GdkRegion * result; - if (!PyArg_ParseTuple(args, "hhhh", &r.x, &r.y, &r.width, &r.height)) + + if (!PyArg_ParseTuple(args, "iiii", &r.x, &r.y, &r.width, &r.height)) return NULL; - result = gdk_region_union_with_rect(self->region, &r); - gdk_region_destroy(self->region); - self->region = result; + + gdk_region_union_with_rect(self->region, &r); + Py_INCREF(Py_None); return Py_None; } @@ -157,12 +157,12 @@ region_SubtractRegion(SKRegionObject *self, PyObject *args) { SKRegionObject *r; - GdkRegion * result; + if (!PyArg_ParseTuple(args, "O!", &SKRegionType, &r)) return NULL; - result = gdk_regions_subtract(self->region, r->region); - gdk_region_destroy(self->region); - self->region = result; + + gdk_region_subtract(self->region, r->region); + Py_INCREF(Py_None); return Py_None; } @@ -171,12 +171,12 @@ region_XorRegion(SKRegionObject *self, PyObject *args) { SKRegionObject *r; - GdkRegion * result; + if (!PyArg_ParseTuple(args, "O!", &SKRegionType, &r)) return NULL; - result = gdk_regions_xor(self->region, r->region); - gdk_region_destroy(self->region); - self->region = result; + + gdk_region_xor(self->region, r->region); + Py_INCREF(Py_None); return Py_None; } @@ -268,7 +268,5 @@ SKRegion_UnionWithRegion(SKRegionObject * self, GdkRegion *region) { GdkRegion * result; - result = gdk_regions_union(self->region, region); - gdk_region_destroy(self->region); - self->region = result; + gdk_region_union(self->region, region); } Index: Sketch/Modules/skgtkimage.c =================================================================== RCS file: /cvs/gnome/sketch/Sketch/Modules/skgtkimage.c,v retrieving revision 1.1.1.1 diff -u -r1.1.1.1 skgtkimage.c --- Sketch/Modules/skgtkimage.c 24 Jan 2000 23:03:36 -0000 1.1.1.1 +++ Sketch/Modules/skgtkimage.c 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ /* Sketch - A Python-based interactive drawing program - * Copyright (C) 1997, 1998, 1999 by Bernhard Herzog + * Copyright (C) 1997, 1998, 1999, 2003 by Bernhard Herzog * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -650,14 +650,13 @@ static void make_region(SKTrafoObject * trafo, int xsize, int ysize, int startx, int starty, int width, int height, - int * pminx, int * pmaxx, GdkRegion ** region) + int * pminx, int * pmaxx, GdkRegion * region) { GdkRectangle rect; double sx, sy; int y, desty; int minx, maxx; double minxx, minxy, maxxx, maxxy; - GdkRegion * temp_region; rect.height = 1; @@ -748,16 +747,14 @@ pminx[y] = minx; pmaxx[y] = maxx; rect.x = minx; rect.y = desty; rect.width = maxx - minx + 1; - temp_region = gdk_region_union_with_rect(*region, &rect); - gdk_region_destroy(*region); - *region = temp_region; + gdk_region_union_with_rect(region, &rect); } } static PyObject * transform_image(SKVisualObject * visual, SKTrafoObject * trafo, Imaging image, GdkImage * ximage, int dest_x, int dest_y, - int dest_width, int dest_height, GdkRegion ** region) + int dest_width, int dest_height, GdkRegion * region) { int startx = dest_x, starty = dest_y; int width = dest_width, height = dest_height; @@ -877,6 +874,6 @@ return transform_image(visual, trafo, src->image, dest->image, dest_x, dest_y, dest_width, dest_height, - &(region->region)); + region->region); } Index: Sketch/Modules/skvisual.c =================================================================== RCS file: /cvs/gnome/sketch/Sketch/Modules/skvisual.c,v retrieving revision 1.4 diff -u -r1.4 skvisual.c --- Sketch/Modules/skvisual.c 13 Sep 2000 22:39:44 -0000 1.4 +++ Sketch/Modules/skvisual.c 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ /* Sketch - A Python-based interactive drawing program - * Copyright (C) 1997, 1998, 1999, 2000 by Bernhard Herzog + * Copyright (C) 1997, 1998, 1999, 2000, 2003 by Bernhard Herzog * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -182,7 +182,7 @@ PyObject * result; gdk_draw_image(tile, self->tilegc, self->tile, 0, 0, 0, 0, 8, 8); - result = PyGdkWindow_New(tile); + result = pygobject_new(G_OBJECT(tile)); gdk_pixmap_unref(tile); return result; } @@ -487,13 +487,13 @@ SKVisual_PyCreateVisual(PyObject * self, PyObject * args) { PyObject * skvisual, *additional_args = NULL; - PyGdkWindow_Object * window_object; + PyGObject * window_object; - if (!PyArg_ParseTuple(args, "O!|O!", &PyGdkWindow_Type, &window_object, + if (!PyArg_ParseTuple(args, "O!|O!", &PyGObject_Type, &window_object, &PyTuple_Type, &additional_args)) return NULL; - skvisual = SKVisual_FromWindow(PyGdkWindow_Get(window_object), + skvisual = SKVisual_FromWindow(GDK_WINDOW(window_object->obj), additional_args); return skvisual; Index: Sketch/UI/__init__.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/__init__.py,v retrieving revision 1.10 diff -u -r1.10 __init__.py --- Sketch/UI/__init__.py 1 Aug 2002 13:43:44 -0000 1.10 +++ Sketch/UI/__init__.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999, 2000, 2002 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -197,7 +197,8 @@ import sys, getopt from Sketch.Lib import util - opts, argv = getopt.getopt(argv, 'hi', ['display=', 'help', 'version']) + opts, argv = getopt.getopt(argv, 'hi', ['display=', 'help', 'version', + "sync"]) # the option -i is a hack to allow sketch to be used as a `python # interpreter' in the python shell in python-mode.el @@ -208,6 +209,9 @@ if optchar == '--display': gtkargs.append(optchar) gtkargs.append(value) + elif optchar == '--sync': + gtkargs.append(optchar) + gtkargs.append(value) elif optchar == '-h' or optchar == '--help': print _usage sys.exit(0) @@ -228,8 +232,8 @@ init(argv) - import gtk - gtk.push_rgb_visual() + #import gtk + #gtk.push_rgb_visual() application = SketchApplication(filenames) #Sketch.Issue(Sketch.const.APP_INITIALIZED, application) Index: Sketch/UI/canvas.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/canvas.py,v retrieving revision 1.13 diff -u -r1.13 canvas.py --- Sketch/UI/canvas.py 29 Jun 2000 20:21:59 -0000 1.13 +++ Sketch/UI/canvas.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1996, 1997, 1998, 1999, 2000 by Bernhard Herzog +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -18,7 +18,7 @@ from types import IntType from math import hypot -import GDK, gtk +import gtk, gtk.keysyms import Sketch from Sketch import _, Point @@ -31,10 +31,10 @@ import skpixmaps, cursors bitmaps = skpixmaps.bitmaps -constraint_keysyms = {GDK.Control_L : Sketch.Editor.ControlMask, - GDK.Control_R : Sketch.Editor.ControlMask, - GDK.Shift_L : Sketch.Editor.ShiftMask, - GDK.Shift_R : Sketch.Editor.ShiftMask} +constraint_keysyms = {gtk.keysyms.Control_L : Sketch.Editor.ControlMask, + gtk.keysyms.Control_R : Sketch.Editor.ControlMask, + gtk.keysyms.Shift_L : Sketch.Editor.ShiftMask, + gtk.keysyms.Shift_R : Sketch.Editor.ShiftMask} # physical handle types # for rect/circle handles: filled == handle_id & 1 @@ -94,8 +94,8 @@ del e def translate_state(state): - # translate the modifier/button state from GDK to the Editor - # constants. Since the editor constants are the same as in GDK this + # translate the modifier/button state from gtk to the Editor + # constants. Since the editor constants are the same as in gtk this # isn't really necessary, but it might be needed when Sketch is ever # ported to a different toolkit. return state @@ -178,11 +178,11 @@ def bind_events(self): SketchView.bind_events(self) - self.add_events(GDK.POINTER_MOTION_MASK - | GDK.BUTTON_PRESS_MASK - | GDK.BUTTON_RELEASE_MASK - | GDK.POINTER_MOTION_HINT_MASK - | GDK.KEY_PRESS_MASK | GDK.KEY_RELEASE_MASK) + self.add_events(gtk.gdk.POINTER_MOTION_MASK + | gtk.gdk.BUTTON_PRESS_MASK + | gtk.gdk.BUTTON_RELEASE_MASK + | gtk.gdk.POINTER_MOTION_HINT_MASK + | gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK) self.connect('button_press_event', self.button_press) self.connect('motion_notify_event', self.motion_notify) self.connect('button_release_event', self.button_release) @@ -190,20 +190,23 @@ self.connect_after('key_release_event', self.key_release) def button_press(self, widget, event): + #print "SketchCanvas.button_press", event self.application.SetContext(self.main_window) if event.button == 1: - self.start_event = event + self.start_event = event.copy() self.start_drag = 1 self.cancelled = 0 - gtk.grab_add(self) + #self.grab_add() if not self.editor.DelayButtonPress(): self.begin_drag(event) elif event.button == 3: self.popup_context_menu(event) def button_release(self, widget, event): + #print "SketchCanvas.button_release", event if event.button == 1: - gtk.grab_remove(self) + pass + #self.grab_remove() self.start_event = None self.start_drag = 0 if event.window == self.window: @@ -223,16 +226,21 @@ recursive = 0 def motion_notify(self, widget, event): + #print "SketchCanvas.motion_notify", event #print 'motion', self.recursive if self.recursive: self.get_pointer() return + if event.is_hint: + x, y = self.get_pointer() + else: + x = event.x + y = event.y if self.start_drag: sx = self.start_event.x sy = self.start_event.y - if hypot(event.x - sx, event.y - sy) >= 3: + if hypot(x - sx, y - sy) >= 3: self.begin_drag(self.start_event) - x, y = self.get_pointer() p = self.win_to_doc(x, y) self.set_current_pos(p) if self.dragging: @@ -241,8 +249,8 @@ self.set_handle_cursor(event.x, event.y) self.recursive = 1 #gtk.threads_leave() # THREADBUG - while gtk.events_pending(): - gtk.mainiteration(0) + #while gtk.events_pending(): + # gtk.mainiteration(0) #gtk.threads_enter() # THREADBUG self.recursive = 0 @@ -272,7 +280,7 @@ # pressed to update the display to reflect whatever # constraints are triggered by the modifier. self.fake_motion_event(event) - elif event.keyval == GDK.Escape: + elif event.keyval == gtk.keysyms.Escape: self.cancel() else: #print event.keyval, event.state @@ -519,9 +527,9 @@ if cursor != self.last_cursor: self.last_cursor = cursor if type(cursor) == IntType: - cursor = gtk.cursor_new(cursor) + cursor = gtk.gdk.Cursor(cursor) # else, assume cursor is a cursor object - self.get_window().set_cursor(cursor) + self.window.set_cursor(cursor) # # Index: Sketch/UI/cursors.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/cursors.py,v retrieving revision 1.2 diff -u -r1.2 cursors.py --- Sketch/UI/cursors.py 29 Jun 2000 20:21:59 -0000 1.2 +++ Sketch/UI/cursors.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -15,7 +15,7 @@ # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -import GDK +import gtk.gdk as GDK CurStd = GDK.TOP_LEFT_ARROW CurEdit = GDK.DRAFT_SMALL Index: Sketch/UI/fillpanel.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/fillpanel.py,v retrieving revision 1.2 diff -u -r1.2 fillpanel.py --- Sketch/UI/fillpanel.py 7 Dec 2001 20:52:22 -0000 1.2 +++ Sketch/UI/fillpanel.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999, 2000, 2001 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -17,8 +17,7 @@ from math import atan2, pi, cos, sin -import gtk, GDK -from _gtk import gdk_draw_line +import gtk import Sketch import Sketch.Graphics @@ -50,17 +49,17 @@ def realize_method(self, *args): apply(SketchDrawingArea.realize_method, (self,) + args) - self.fill_rect = Rect(0, 0, self.window.width, self.window.height) + self.fill_rect = Rect(0, 0, *self.window.get_size()) self.compute_trafo() def compute_trafo(self): if not hasattr(self, 'window'): return - height = self.window.height + width, height = self.window.get_size() doc_to_win = Trafo(1, 0, 0, -1, 0, height) win_to_doc = doc_to_win.inverse() self.gc.SetViewportTransform(1.0, doc_to_win, win_to_doc) - self.fill_rect = Rect(0, 0, self.window.width, self.window.height) + self.fill_rect = Rect(0, 0, width, height) self.gc.SetProperties(self.properties, self.fill_rect) def SetPattern(self, pattern): @@ -72,14 +71,15 @@ def RedrawMethod(self, region = None): win = self.window + width, height = win.get_size() self.gc.StartDblBuffer() self.gc.SetFillColor(StandardColors.white) - self.gc.FillRectangle(0, 0, win.width, win.height) + self.gc.FillRectangle(0, 0, width, height) if self.properties.HasFill(): - self.gc.Rectangle(Trafo(win.width, 0, 0, win.height, 0, 0)) + self.gc.Rectangle(Trafo(width, 0, 0, height, 0, 0)) else: self.gc.SetLineColor(StandardColors.black) - self.gc.DrawLineXY(0, win.height, win.width, 0) + self.gc.DrawLineXY(0, height, width, 0) self.gc.EndDblBuffer() def ResizedMethod(self, width, height): @@ -95,9 +95,9 @@ def __init__(self, **kw): apply(PatternSample.__init__, (self,), kw) - self.add_events(GDK.POINTER_MOTION_MASK - | GDK.BUTTON_PRESS_MASK - | GDK.BUTTON_RELEASE_MASK) + self.add_events(gtk.gdk.POINTER_MOTION_MASK + | gtk.gdk.BUTTON_PRESS_MASK + | gtk.gdk.BUTTON_RELEASE_MASK) self.connect('button_press_event', self.button_press) self.connect('motion_notify_event', self.motion_notify) self.connect('button_release_event', self.button_release) @@ -117,14 +117,15 @@ self.allow_edit_dir = direction def SetCenter(self, pos): + width, height = self.window.get_size() x, y = pos - x = x * self.window.width - y = (1 - y) * self.window.height + x = x * width + y = (1 - y) * height self.center = (x, y) def init_gcs(self): PatternSample.init_gcs(self) - self.inv_gc = self.window.new_gc(function = GDK.XOR) + self.inv_gc = self.window.new_gc(function = gtk.gdk.XOR) _skgtk.set_foreground_and_fill(self.inv_gc, 0xFFFFFFFF) def button_press(self, widget, event): @@ -135,7 +136,7 @@ self.current_mode = 1 else: return - gtk.grab_add(self) + #gtk.grab_add(self) self.current_pos = (event.x, event.y, event.state & ConstraintMask) self.show_edit() self.dragging = 1 @@ -149,7 +150,7 @@ def button_release(self, widget, event): if self.dragging and event.button == self.drag_button: - gtk.grab_remove(self) + #gtk.grab_remove(self) self.hide_edit() self.current_pos = (event.x, event.y, event.state & ConstraintMask) self.report_edit() @@ -167,8 +168,7 @@ self.drawn = 0 def constrain_center(self, x, y): - width = self.window.width - height = self.window.height + width, height = self.window.get_size() x = float(x) / width y = float(y) / height if x < 0.25: x = 0 @@ -186,8 +186,9 @@ if self.current_mode == 0: if constraint: x, y = self.constrain_center(x, y) - gdk_draw_line(self.window, self.inv_gc, 0, y, self.window.width, y) - gdk_draw_line(self.window, self.inv_gc, x, 0, x,self.window.height) + width, height = self.window.get_size() + self.window.draw_line(self.inv_gc, 0, y, width, y) + self.window.draw_line(self.inv_gc, x, 0, x, height) else: cx, cy = self.center @@ -199,7 +200,7 @@ x = cx + cos(angle) * 1000.0 y = cy + sin(angle) * 1000.0 - gdk_draw_line(self.window, self.inv_gc, cx, cy, x, y) + self.window.draw_line(self.inv_gc, cx, cy, x, y) def report_edit(self): x, y, constraint = self.current_pos @@ -207,9 +208,9 @@ if constraint: x, y = self.constrain_center(x, y) self.center = (x, y) - win = self.window + width, height = self.window.get_size() what = "center" - detail = Point(float(x) / win.width, 1 - (float(y) / win.height)) + detail = Point(float(x) / width, 1 - (float(y) / height)) else: cx, cy = self.center angle = atan2(y - cy, x - cx) + 2 * pi @@ -237,7 +238,7 @@ def destroy(self): Publisher.Destroy(self) - gtk.GtkHBox.destroy() + gtk.HBox.destroy() def changed(self): self.issue(CHANGED) @@ -261,22 +262,22 @@ return (0, 0) -class EmptyPatternFrame(gtk.GtkVBox, PatternFrame): +class EmptyPatternFrame(gtk.VBox, PatternFrame): def __init__(self): - gtk.GtkVBox.__init__(self) + gtk.VBox.__init__(self) PatternFrame.__init__(self) - label = gtk.GtkLabel(_("No Fill")) + label = gtk.Label(_("No Fill")) self.pack_start(label) label.show() -class SolidPatternFrame(gtk.GtkVBox, PatternFrame): +class SolidPatternFrame(gtk.VBox, PatternFrame): def __init__(self): - gtk.GtkVBox.__init__(self) + gtk.VBox.__init__(self) PatternFrame.__init__(self, SolidPattern(StandardColors.black)) - button = gtk.GtkButton(_("Choose Color...")) + button = gtk.Button(_("Choose Color...")) self.pack_start(button, expand = 0) button.show() button.connect("clicked", self.ChooseColor) @@ -289,15 +290,15 @@ self.changed() -class GradientPatternFrame(gtk.GtkVBox, PatternFrame): +class GradientPatternFrame(gtk.VBox, PatternFrame): def __init__(self): - gtk.GtkVBox.__init__(self) + gtk.VBox.__init__(self) start_color = StandardColors.black end_color = StandardColors.white gradient = CreateSimpleGradient(start_color, end_color) PatternFrame.__init__(self, LinearGradient(gradient)) - box = gtk.GtkHBox() + box = gtk.HBox() self.start_button = ColorButton(_("Start"), _("Start Color"), start_color) self.start_button.Subscribe(CHANGED, self.set_color, 0) @@ -307,62 +308,62 @@ box.pack_start(self.end_button) self.pack_start(box, expand = 0) - menu = gtk.GtkMenu() + menu = gtk.Menu() for name, kind in ((_("Axial"),0), (_("Radial"),1), (_("Conical"),2)): - item = gtk.GtkMenuItem(name) + item = gtk.MenuItem(name) menu.append(item) item.connect("activate", self.set_type, kind) item.show() - self.optionmenu = gtk.GtkOptionMenu() + self.optionmenu = gtk.OptionMenu() self.optionmenu.set_menu(menu) self.pack_start(self.optionmenu, expand = 0) - box = gtk.GtkHBox() - label = gtk.GtkLabel(_("Border")) + box = gtk.HBox() + label = gtk.Label(_("Border")) box.pack_start(label) - self.adjust_border = gtk.GtkAdjustment(value = 0, + self.adjust_border = gtk.Adjustment(value = 0, lower = 0, upper = 100, step_incr = 1) - entry = gtk.GtkSpinButton(adj = self.adjust_border, digits = 0) + entry = gtk.SpinButton(adjustment = self.adjust_border, digits = 0) box.pack_start(entry) self.adjust_border.connect("value_changed", self.border_changed) self.pack_start(box, expand = 0) - label = gtk.GtkLabel(_("Center")) + label = gtk.Label(_("Center")) label.set_alignment(0.0, 0.5) self.pack_start(label, expand = 0) - box = gtk.GtkHBox() + box = gtk.HBox() # Use some arbitrary but relatively high bounds for the center # coordinates. The center may well lie outside the bounding # rect. - self.adjust_cx = gtk.GtkAdjustment(value = 0, + self.adjust_cx = gtk.Adjustment(value = 0, lower = -10000, upper = 10000, step_incr = 1) - entry = gtk.GtkSpinButton(adj = self.adjust_cx, digits = 0) + entry = gtk.SpinButton(adjustment = self.adjust_cx, digits = 0) box.pack_start(entry) self.adjust_cx.connect("value_changed", self.center_changed, 0) - self.adjust_cy = gtk.GtkAdjustment(value = 0, + self.adjust_cy = gtk.Adjustment(value = 0, lower = -10000, upper = 10000, step_incr = 1) - entry = gtk.GtkSpinButton(adj = self.adjust_cy, digits = 0) + entry = gtk.SpinButton(adjustment = self.adjust_cy, digits = 0) box.pack_start(entry) self.adjust_cy.connect("value_changed", self.center_changed, 1) self.pack_start(box, expand = 0) - box = gtk.GtkHBox() - label = gtk.GtkLabel(_("Angle")) + box = gtk.HBox() + label = gtk.Label(_("Angle")) box.pack_start(label) # The range for the angle doesn't matter as long as it contains # more than the range 0...360. Values outside that range are # automatically wrapped into that range by converting from angle # to vector in angle_changed and back in SetPattern - self.adjust_angle = gtk.GtkAdjustment(value = 0, + self.adjust_angle = gtk.Adjustment(value = 0, lower = -1000, upper = 1000, step_incr = 1) - entry = gtk.GtkSpinButton(adj = self.adjust_angle, digits = 1) + entry = gtk.SpinButton(adjustment = self.adjust_angle, digits = 1) box.pack_start(entry) self.adjust_angle.connect("value_changed", self.angle_changed) self.pack_start(box, expand = 0) @@ -460,10 +461,10 @@ self.SetPattern(self.pattern.WithDirection(dir)) self.changed() -class HatchingPatternFrame(gtk.GtkVBox, PatternFrame): +class HatchingPatternFrame(gtk.VBox, PatternFrame): def __init__(self): - gtk.GtkVBox.__init__(self) + gtk.VBox.__init__(self) fg = StandardColors.red bg = StandardColors.white PatternFrame.__init__(self, HatchingPattern(fg, bg)) @@ -495,12 +496,12 @@ self.changed() -class ImageTilePatternFrame(gtk.GtkVBox, PatternFrame): +class ImageTilePatternFrame(gtk.VBox, PatternFrame): def __init__(self): - gtk.GtkVBox.__init__(self) + gtk.VBox.__init__(self) PatternFrame.__init__(self) - label = gtk.GtkLabel("Image Tile Fill") + label = gtk.Label("Image Tile Fill") self.pack_start(label) label.show() @@ -533,30 +534,30 @@ self.hatching_frame = HatchingPatternFrame() self.imagetile_frame = ImageTilePatternFrame() - menu = gtk.GtkMenu() - self.notebook = notebook = gtk.GtkNotebook() + menu = gtk.Menu() + self.notebook = notebook = gtk.Notebook() for frame, name in ((self.empty_frame, _("No Fill")), (self.solid_frame, _("Solid")), (self.gradient_frame, _("Gradient")), (self.hatching_frame, _("Hatching")), (self.imagetile_frame, _("Tiled Image"))): - item = gtk.GtkMenuItem(name) + item = gtk.MenuItem(name) menu.append(item) item.show() item.connect("activate", self.set_pattern_type, frame) - notebook.append_page(frame, gtk.GtkLabel(name)) + notebook.append_page(frame, gtk.Label(name)) frame.Subscribe(CHANGED, self.update_sample, frame) - self.optionmenu = gtk.GtkOptionMenu() + self.optionmenu = gtk.OptionMenu() self.optionmenu.set_menu(menu) vbox.pack_start(self.optionmenu, expand = 0) vbox.pack_start(notebook) notebook.set_show_tabs(0) - self.apply_button = button = gtk.GtkButton(_("Apply")) + self.apply_button = button = gtk.Button(_("Apply")) button.connect("clicked", self.do_apply) self.action_area.pack_start(button, expand = 0, fill = 0) - button = gtk.GtkButton(_("Close")) + button = gtk.Button(_("Close")) button.connect("clicked", self.close) self.action_area.pack_start(button, expand = 0, fill = 0) Index: Sketch/UI/gtkdevice.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/gtkdevice.py,v retrieving revision 1.14 diff -u -r1.14 gtkdevice.py --- Sketch/UI/gtkdevice.py 12 Jan 2003 18:41:47 -0000 1.14 +++ Sketch/UI/gtkdevice.py 14 Jan 2003 20:05:32 -0000 @@ -30,10 +30,8 @@ import PIL.Image -import GDK -from _gtk import gdk_draw_line, gdk_draw_arc, gdk_draw_rectangle, \ - gdk_draw_polygon, gdk_draw_lines, gdk_pixmap_new, gdk_font_load, \ - gdk_draw_string, gdk_draw_pixmap +import gtk +import gtk.gdk as GDK import Sketch @@ -145,8 +143,8 @@ if _init_from_widget_done: return - visual = _skgtk.widget_visual_type(widget._o) - window = widget.get_window() + visual = _skgtk.widget_visual_type(widget) + window = widget.window if visual == _skgtk.GDK_VISUAL_TRUE_COLOR: skvisual = _skgtk.CreateVisual(window) #skvisual.set_gamma(config.preferences.screen_gamma) @@ -207,6 +205,9 @@ self.visual = skvisual self.InitClip() + def drawable_size(self): + return self.drawable.get_size() + # # Clipping # @@ -273,12 +274,11 @@ ClipBitmap = ClipRegion def create_clip_bitmap(self): - width = self.drawable.width - height = self.drawable.height - bitmap = gdk_pixmap_new(self.window, width, height, 1) + width, height = self.drawable_size() + bitmap = gtk.gdk.Pixmap(self.window, width, height, 1) gc = bitmap.new_gc() gc.function = GDK.CLEAR - gdk_draw_rectangle(bitmap, gc, 1, 0, 0, width, height) + bitmap.draw_rectangle(gc, 1, 0, 0, width, height) gc.function = GDK.SET return (bitmap, gc) @@ -351,16 +351,14 @@ # def StartDblBuffer(self): - self.buffer_pixmap = gdk_pixmap_new(self.window, - self.window.width, - self.window.height, - self.window.depth) + x, y, width, height, depth = self.window.get_geometry() + self.buffer_pixmap = gtk.gdk.Pixmap(self.window, width, height, depth) self.drawable = self.buffer_pixmap def EndDblBuffer(self): self.drawable = self.window - gdk_draw_pixmap(self.drawable, self.gc, self.buffer_pixmap, - 0, 0, 0, 0, self.drawable.width, self.drawable.height) + self.drawable.draw_drawable(self.gc, self.buffer_pixmap, 0, 0, 0, 0, + -1, -1) self.buffer_pixmap = None @@ -418,44 +416,43 @@ def DrawLine(self, start, end): startx, starty = self.DocToWin(start) endx, endy = self.DocToWin(end) - gdk_draw_line(self.drawable, self.gc, startx, starty, endx, endy) + self.drawable.draw_line(self.gc, startx, starty, endx, endy) def DrawLineXY(self, x1, y1, x2, y2): startx, starty = self.DocToWin(x1, y1) endx, endy = self.DocToWin(x2, y2) - gdk_draw_line(self.drawable, self.gc, startx, starty, endx, endy) + self.drawable.draw_line(self.gc, startx, starty, endx, endy) def DrawLines(self, pts): pts = map(self.DocToWin, pts) - gdk_draw_lines(self.drawable, self.gc, pts) + self.drawable.draw_lines(self.gc, pts) def FillPolygon(self, pts): pts = map(self.DocToWin, pts) - gdk_draw_polygon(self.drawable, self.gc, pts) + self.drawable.draw_polygon(self.gc, pts) def DrawRectangle(self, start, end): # draw the outline of the rectangle whose opposite corners are # start and end. pts = TransformRectangle(self.doc_to_win, Rect(start, end)) if type(pts) == TupleType: - apply(gdk_draw_rectangle, (self.drawable, self.gc, 0) + pts) + apply(self.drawable.draw_rectangle, (self.gc, 0) + pts) else: - gdk_draw_lines(self.drawable, self.gc, pts) + self.drawable.draw_lines(self.gc, pts) def FillRectangle(self, left, top, right, bottom): pts = TransformRectangle(self.doc_to_win, Rect(left, top, right, bottom)) if type(pts) == TupleType: - apply(gdk_draw_rectangle, (self.drawable, self.gc, 1,) + pts) + apply(self.drawable.draw_rectangle, (self.gc, 1,) + pts) else: - gdk_draw_polygon(self.drawable, self.gc, 1, pts) + self.drawable.draw_polygon(self.gc, 1, pts) def DrawEllipse(self, start, end): pts = TransformRectangle(self.doc_to_win, Rect(start, end)) if type(pts) == TupleType: - apply(gdk_draw_arc, - (self.drawable, self.gc, 0) + pts + (0, 360 * 64)) + apply(self.drawable.draw_arc, (self.gc, 0) + pts + (0, 360 * 64)) else: d = end - start self.PushTrafo() @@ -468,8 +465,7 @@ center.x + radius, center.y + radius) pts = TransformRectangle(self.doc_to_win, rect) if type(pts) == TupleType: - apply(gdk_draw_arc, - (self.drawable, self.gc, 0) + pts + (0, 360 * 64)) + apply(self.drawable.draw_arc, (self.gc, 0) + pts + (0, 360 * 64)) else: self.PushTrafo() self.Concat(Trafo(radius, 0, 0, radius, center.x, center.y)) @@ -481,8 +477,7 @@ center.x + radius, center.y + radius) pts = TransformRectangle(self.doc_to_win, rect) if type(pts) == TupleType: - apply(gdk_draw_arc, - (self.drawable, self.gc, 1) + pts + (0, 360 * 64)) + apply(self.drawable.draw_arc, (self.gc, 1) + pts + (0, 360 * 64)) else: self.PushTrafo() self.Concat(Trafo(radius, 0, 0, radius, center.x, center.y)) @@ -510,9 +505,9 @@ def create_ximage(self): if self.ximage is None: - d = self.drawable + width, height = self.drawable_size() self.ximage = create_image(self.window, _skgtk.GDK_IMAGE_NORMAL, - d.width, d.height) + width, height) def create_sized_ximage(self, width, height): return create_image(self.window, _skgtk.GDK_IMAGE_NORMAL, @@ -523,8 +518,7 @@ # def get_pattern_image(self): - width = self.drawable.width - height = self.drawable.height + width, height = self.drawable_size() winrect = self.doc_to_win(self.fill_rect) left, top, right, bottom = map(int, map(round, winrect)) l = max(left, 0); r = min(right, width); @@ -611,19 +605,19 @@ if height == 0: height = 1 ximage = self.create_sized_ximage(abs(width), abs(height)) print ximage.width, ximage.height, ximage.depth - pixmap = gdk_pixmap_new(self.window, abs(width), abs(height), + pixmap = gtk.gdk.Pixmap(self.window, abs(width), abs(height), ximage.depth) _skgtk.copy_image_to_ximage(self.visual, tile.im, ximage, 0, 0, width, height) gc = self.drawable.new_gc() _skgtk.draw_image(pixmap, gc, ximage, 0, 0, - 0, 0, abs(width), abs(height)) + 0, 0, abs(width), abs(height)) _skgtk.set_foreground_and_fill(self.gc, pixmap) x, y = trafo.DocToWin(0, 0) self.gc.ts_x_origin = x self.gc.ts_y_origin = y - gdk_draw_rectangle(self.drawable, self.gc, 1, - 0, 0, self.drawable.width, self.drawable.height) + dwidth, dheight = self.drawable_size() + self.drawable.draw_rectangle(self.gc, 1, 0, 0, dwidth, dheight) else: image, temp_trafo, pos = self.get_pattern_image() if image is None: @@ -766,10 +760,10 @@ clip = 0 elif self.fill: self.properties.ExecuteFill(self, self.fill_rect) - apply(gdk_draw_rectangle, (self.drawable, self.gc, 1) + pts) + apply(self.drawable.draw_rectangle, (self.gc, 1) + pts) if self.line: self.properties.ExecuteLine(self) - apply(gdk_draw_rectangle, (self.drawable, self.gc, 0) + pts) + apply(self.drawable.draw_rectangle, (self.gc, 0) + pts) else: if self.proc_fill: if not clip: @@ -781,10 +775,10 @@ clip = 0 elif self.fill: self.properties.ExecuteFill(self, self.fill_rect) - gdk_draw_polygon(self.drawable, self.gc, 1, pts) + self.drawable.draw_polygon(self.gc, 1, pts) if self.line: self.properties.ExecuteLine(self) - gdk_draw_lines(self.drawable, self.gc, pts) + self.drawable.draw_lines(self.gc, pts) if clip: if type(pts) == TupleType: self.ClipRect(pts) @@ -810,11 +804,11 @@ h = y2 - y1 if self.fill: self.properties.ExecuteFill(self, self.fill_rect) - gdk_draw_arc(self.drawable, self.gc, 1, x1, y1, w, h, 0, 23040) + self.drawable.draw_arc(self.gc, 1, x1, y1, w, h, 0, 23040) # 23040 == 360 * 64 if self.line: self.properties.ExecuteLine(self) - gdk_draw_arc(self.drawable, self.gc, 0, x1, y1, w, h, 0, 23040) + self.drawable.draw_arc(self.gc, 0, x1, y1, w, h, 0, 23040) else: retract1 = retract2 = 0.0 if self.line: @@ -908,7 +902,7 @@ pos = map(self.DocToWin, pos) for i in range(len(text)): x, y = pos[i] - gdk_draw_string(window, xfont, gc, x, y, text[i]) + window.draw_string(xfont, gc, x, y, text[i]) else: # 'greek'. XXX is this really necessary? It avoids # rendering fonts that are too small to read. @@ -917,13 +911,13 @@ ux, uy = up lx = ux / 2; ly = uy / 2 uppercase = string.uppercase - draw = gdk_draw_line # we should draw rectangles... + draw = window.gdk_draw_line # we should draw rectangles... for i in range(len(text)): x, y = pos[i] if text[i] in uppercase: - draw(window, gc, x, y, x + ux, y + uy) + draw(gc, x, y, x + ux, y + uy) else: - draw(window, gc, x, y, x + lx, y + ly) + draw(gc, x, y, x + lx, y + ly) finally: self.PopTrafo() @@ -941,9 +935,8 @@ self.ClipBitmap(bitmap) self.properties.ExecuteFill(self, self.fill_rect) if not self.proc_fill: - gdk_draw_rectangle(self.drawable, self.gc, 1, 0, 0, - self.drawable.width, - self.drawable.height) + self.drawable.draw_rectangle(self.gc, 1, 0, 0, + *self.drawable_size()) if not clip: self.PopClip() else: @@ -988,7 +981,7 @@ if font_cache is not None and font_cache.has_key(xlfd): font = font_cache[xlfd] else: - font = gdk_font_load(xlfd) + font = gtk.gdk.Font(xlfd) if font_cache is not None: font_cache[xlfd] = font @@ -1203,11 +1196,11 @@ self.gc.line_style = GDK.LINE_ON_OFF_DASH self.gc.set_dashes(0, (5,5)) x, y = self.DocToWin(point) + width, height = self.drawable_size() if horizontal: - gdk_draw_line(self.drawable, self.gc, 0, y, self.drawable.width, y) + self.drawable.draw_line(self.gc, 0, y, width, y) else: - gdk_draw_line(self.drawable, self.gc, x, 0, x, - self.drawable.height) + self.drawable.draw_line(self.gc, x, 0, x, height) self.gc.line_style = GDK.LINE_SOLID def DrawPageOutline(self, width, height): @@ -1223,19 +1216,19 @@ w = right - left h = bottom - top self.SetFillColor(StandardColors.gray) - gdk_draw_rectangle(self.drawable, self.gc, 1, - left + sw, bottom, w + 1, sw + 1) - gdk_draw_rectangle(self.drawable, self.gc, 1, - right, top + sw, sw + 1, h + 1) + self.drawable.draw_rectangle(self.gc, 1, + left + sw, bottom, w + 1, sw + 1) + self.drawable.draw_rectangle(self.gc, 1, + right, top + sw, sw + 1, h + 1) self.SetFillColor(StandardColors.black) - gdk_draw_rectangle(self.drawable, self.gc, 0, left, top, w, h) + self.drawable.draw_rectangle(self.gc, 0, left, top, w, h) # # def ClearWindowRectangle(self, x, y, w, h): self.SetFillColor(StandardColors.white) - gdk_draw_rectangle(self.drawable, self.gc, 1, x, y, w, h) + self.drawable.draw_rectangle(self.gc, 1, x, y, w, h) # @@ -1304,7 +1297,7 @@ if self.line: startx, starty = self.DocToWin(p1) endx, endy = self.DocToWin(p2) - gdk_draw_line(self.drawable, self.gc, startx, starty, endx, endy) + self.drawable.draw_line(self.gc, startx, starty, endx, endy) # draw a rectangular 'handle' at P. The size of the handle is given # by self.handle_size and is always in window coordinates (i.e. is @@ -1316,11 +1309,11 @@ x = x - size y = y - size if filled: - gdk_draw_rectangle(self.drawable, self.gc, 1, x, y, - 2 * size + 1, 2 * size + 1) + self.drawable.draw_rectangle(self.gc, 1, x, y, + 2 * size + 1, 2 * size + 1) else: - gdk_draw_rectangle(self.drawable, self.gc, 0, x, y, - 2 * size, 2 * size) + self.drawable.draw_rectangle(self.gc, 0, x, y, + 2 * size, 2 * size) def DrawSmallRectHandle(self, p, filled = 1): x, y = self.DocToWin(p) @@ -1328,11 +1321,10 @@ x = x - size y = y - size if filled: - gdk_draw_rectangle(self.drawable, self.gc, 1, x, y, - 2 * size + 1, 2 * size + 1) + self.drawable.draw_rectangle(self.gc, 1, x, y, + 2 * size + 1, 2 * size + 1) else: - gdk_draw_rectangle(self.drawable, self.gc, 0, x, y, - 2 * size, 2 * size) + self.drawable.draw_rectangle(self.gc, 0, x, y, 2 * size, 2 * size) def DrawCircleHandle(self, p, filled = 1): x, y = self.DocToWin(p) @@ -1341,11 +1333,11 @@ y = y - size if filled: # 23040 = 360 * 64 - gdk_draw_arc(self.drawable, self.gc, 1, x, y, - 2 * size + 1, 2 * size + 1, 0, 23040) + self.drawable.draw_arc(self.gc, 1, x, y, 2 * size + 1, 2 * size +1, + 0, 23040) else: - gdk_draw_arc(self.drawable, self.gc, 0, x, y, - 2 * size, 2 * size, 0, 23040) + self.drawable.draw_arc(self.gc, 0, x, y, 2 * size, 2 * size, + 0, 23040) def DrawSmallCircleHandle(self, p, filled = 1): x, y = self.DocToWin(p) @@ -1354,11 +1346,11 @@ y = y - size if filled: # 23040 = 360 * 64 - gdk_draw_arc(self.drawable, self.gc, 1, x, y, - 2 * size + 1, 2 * size + 1, 0, 23040) + self.drawable.draw_arc(self.gc, 1, x, y, + 2 * size + 1, 2 * size + 1, 0, 23040) else: - gdk_draw_arc(self.drawable, self.gc, 0, x, y, - 2 * size, 2 * size, 0, 23040) + self.drawable.draw_arc(self.gc, 0, x, y, + 2 * size, 2 * size, 0, 23040) def DrawSmallRectHandleList(self, pts, filled = 1): pts = map(self.doc_to_win.DocToWin, pts) @@ -1372,8 +1364,8 @@ lx = ly = None for x, y in pts: if y != ly or x != lx: - gdk_draw_rectangle(drawable, gc, filled, - x - size, y - size, size2, size2) + drawable.draw_rectangle(gc, filled, + x - size, y - size, size2, size2) lx = x ly = y @@ -1388,7 +1380,7 @@ for start, end in lines: startx, starty = DocToWin(start) endx, endy = DocToWin(end) - gdk_draw_line(self.drawable, self.gc, startx, starty, endx, endy) + self.drawable.draw_line(self.gc, startx, starty, endx, endy) self.gc.line_style = self.normal_line_style @@ -1408,8 +1400,9 @@ if isinstance(pixmap, StringType): pixmap = getattr(bitmaps, pixmap) x, y = self.DocToWin(p) - x = x - pixmap.width / 2 - y = y - pixmap.height / 2 + width, height = pixmap.get_size() + x = x - width / 2 + y = y - height / 2 draw_bitmap(self.drawable, self.gc, pixmap, x, y) def DrawCaretHandle(self, p, up): @@ -1445,7 +1438,7 @@ self.gc = None def init_gc(self, window, **gcargs): - self.drawable = gdk_pixmap_new(window, pixmap_width, pixmap_width, 1) + self.drawable = gtk.gdk.Pixmap(window, pixmap_width, pixmap_width, 1) self.window = window self.gc = self.drawable.new_gc(line_width = 3) _skgtk.set_foreground_and_fill(self.gc, 1) @@ -1659,8 +1652,8 @@ y + pixmap_width_2 + 1) rect = Rect(top_left, bot_right) self.gc.function = GDK.CLEAR - gdk_draw_rectangle(self.drawable, self.gc, 1, 0, 0, - pixmap_width + 1, pixmap_width + 1) + self.drawable.draw_rectangle(self.gc, 1, 0, 0, + pixmap_width + 1, pixmap_width + 1) self.gc.function = GDK.COPY self.fill = 0 line_width = max(line_width, hit_properties.line_width) Index: Sketch/UI/gtkmisc.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/gtkmisc.py,v retrieving revision 1.5 diff -u -r1.5 gtkmisc.py --- Sketch/UI/gtkmisc.py 14 Dec 2001 20:56:36 -0000 1.5 +++ Sketch/UI/gtkmisc.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 by Bernhard Herzog +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -16,42 +16,40 @@ # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import os -import gtk, _gtk -from gtk import GtkDialog, GtkHBox, GtkButton, GtkLabel, GtkPixmap, \ - GtkFileSelection, GtkWidget, GtkColorSelectionDialog +import gtk from Sketch import _, _skgtk from Sketch.Base import Publisher, const from Sketch.Graphics import CreateRGBColor from gtkdevice import GraphicsDevice -class MessageBox(GtkDialog): +class MessageBox(gtk.Dialog): def __init__(self, title, message, buttons, default = 0, pixmap = None, modal = 1): - GtkDialog.__init__(self) + gtk.Dialog.__init__(self) self.set_title(title) self.connect("destroy", self.quit) self.connect("delete_event", self.quit) self.modal = modal if modal: gtk.grab_add(self) - hbox = GtkHBox(spacing = 5) + hbox = gtk.HBox(spacing = 5) hbox.set_border_width(5) self.vbox.pack_start(hbox) hbox.show() if pixmap: self.realize() - pixmap = GtkPixmap(self, pixmap) + pixmap = gtk.Pixmap(self, pixmap) hbox.pack_start(pixmap, expand=FALSE) pixmap.show() - label = GtkLabel(message) + label = gtk.Label(message) label.set_justify(gtk.JUSTIFY_LEFT) hbox.pack_start(label) label.show() for text in buttons: - b = GtkButton(text) + b = gtk.Button(text) b.set_border_width(10) b.set_flags(gtk.CAN_DEFAULT) b.set_data("user_data", text) @@ -153,10 +151,10 @@ return None -class FileSelector(ModalDialogMixin, GtkFileSelection): +class FileSelector(ModalDialogMixin, gtk.FileSelection): def __init__(self, title): - GtkFileSelection.__init__(self, title) + gtk.FileSelection.__init__(self, title) ModalDialogMixin.__init__(self) def get_result(self): @@ -168,10 +166,10 @@ return win.run() -class ColorDialog(ModalDialogMixin, GtkColorSelectionDialog): +class ColorDialog(ModalDialogMixin, gtk.ColorSelectionDialog): def __init__(self, title, color = None): - GtkColorSelectionDialog.__init__(self, title) + gtk.ColorSelectionDialog.__init__(self, title) ModalDialogMixin.__init__(self) if color is not None: self.colorsel.set_color(tuple(color)) @@ -194,10 +192,10 @@ fg = cmap.alloc(0xFFFF, 0xFFFF, 0xFFFF) return fg, bg -class ColorButton(GtkButton, Publisher): +class ColorButton(gtk.Button, Publisher): def __init__(self, title, dialog_title, color): - GtkButton.__init__(self, title) + gtk.Button.__init__(self, title) self.dialog_title = dialog_title self.color = color self.connect("clicked", self.choose_color) @@ -224,21 +222,16 @@ self.color))) self.issue(const.CHANGED, self.color) -class SketchDrawingArea(GtkWidget): - - get_type = _gtk.gtk_drawing_area_get_type +class SketchDrawingArea(gtk.DrawingArea): def __init__(self, **kw): - self._o = _gtk.gtk_drawing_area_new() + gtk.DrawingArea.__init__(self, **kw) self.region = _skgtk.create_region() self.idle_redraw_tag = None self.gcs_initialized = 0 self.gc = GraphicsDevice() self.bind_events() - def size(self, w, h): - _gtk.gtk_drawing_area_size(self._o, w, h) - def bind_events(self): self.connect("expose_event", self.expose_event) self.connect("realize", self.realize_method) @@ -267,11 +260,7 @@ self.RedrawMethod(region) def realize_method(self, *args): - window = self.get_window() - # the window can change if the widget (or a parent) has been - # reparented - if not self.gcs_initialized or window != self.window: - self.window = window + if not self.gcs_initialized: self.init_gcs() def init_gcs(self): Index: Sketch/UI/libartdevice.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/libartdevice.py,v retrieving revision 1.17 diff -u -r1.17 libartdevice.py --- Sketch/UI/libartdevice.py 15 Apr 2002 20:41:23 -0000 1.17 +++ Sketch/UI/libartdevice.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1999, 2000 by Bernhard Herzog +# Copyright (C) 1999, 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -239,6 +239,9 @@ #pass print '__del__', self + def drawable_size(self): + return self.drawable.get_geometry()[2:4] + def InitClip(self): self.clip_stack = () self.clip_region = None @@ -259,8 +262,7 @@ if self.drawable is None: return if width is None: - width = self.drawable.width - height = self.drawable.height + width, height = self.drawable_size() #if self.ximage is None: # self.ximage = _skgtk.create_image(self.window, # _skgtk.GDK_IMAGE_FASTEST, @@ -296,8 +298,7 @@ def BeginDraw(self, region = None): self.image = None - dw = self.drawable.width - dh = self.drawable.height + dw, dh = self.drawable_size() if region is not None: rx, ry, w, h = region.ClipBox() if rx > dw or rx + w <= 0: @@ -510,8 +511,7 @@ # Patterns # def get_pattern_image(self): - width = self.drawable.width - height = self.drawable.height + width, height = self.drawable_size() winrect = self.libart_trafo(self.fill_rect) left, top, right, bottom = map(int, map(round, winrect)) x0, y0 = self.libart_offset Index: Sketch/UI/mainwindow.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/mainwindow.py,v retrieving revision 1.11 diff -u -r1.11 mainwindow.py --- Sketch/UI/mainwindow.py 13 Sep 2000 23:42:21 -0000 1.11 +++ Sketch/UI/mainwindow.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999, 2000 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -18,7 +18,7 @@ import os import gtk -from GTK import EXPAND, FILL, SHRINK, UPDATE_DELAYED, CAN_FOCUS +from gtk import EXPAND, FILL, SHRINK, UPDATE_DELAYED, CAN_FOCUS import Sketch import Sketch.Editor @@ -34,38 +34,42 @@ import gtkdevice from skpixmaps import pixmaps -class IndicatorButton(gtk.GtkToggleButton): +class IndicatorButton(gtk.ToggleButton): - def __init__(self, context, window): - self.pixmap_on = apply(gtk.GtkPixmap, pixmaps.LightBulbOn) - self.pixmap_off = apply(gtk.GtkPixmap, pixmaps.LightBulbOff) - gtk.GtkToggleButton.__init__(self) + def __init__(self, context, main_window): + image = gtk.Image() + image.set_from_pixmap(*pixmaps.LightBulbOn) + self.pixmap_on = image + image = gtk.Image() + image.set_from_pixmap(*pixmaps.LightBulbOff) + self.pixmap_off = image + gtk.ToggleButton.__init__(self) self.add(self.pixmap_off) - self.window = window + self.main_window = main_window self.context = context self.context.Subscribe(CHANGED, self.ContextChanged) - self.clicked_id = self.connect('clicked', self.set_window) + self.clicked_id = self.connect('clicked', self.set_main_window) self.connect('destroy', self.Destroy) def Destroy(self, *args): self.context.Unsubscribe(CHANGED, self.ContextChanged) - self.window = None + self.main_window = None def ContextChanged(self): - self.signal_handler_block(self.clicked_id) - on = self.window == self.context.window + self.handler_block(self.clicked_id) + on = self.main_window == self.context.window self.set_active(on) - self.remove(self.children()[0]) + self.remove(self.get_children()[0]) if on: self.add(self.pixmap_on) else: self.add(self.pixmap_off) self.show_all() - self.signal_handler_unblock(self.clicked_id) + self.handler_unblock(self.clicked_id) - def set_window(self, widget): - if self.window is not self.context.window: - self.context.SetWindow(self.window) + def set_main_window(self, widget): + if self.main_window is not self.context.window: + self.context.SetWindow(self.main_window) else: self.ContextChanged() @@ -115,38 +119,38 @@ self.window.destroy() def build_window(self): - self.window = gtk.GtkWindow() + self.window = gtk.Window() self.window.connect("destroy", self.close) self.window.realize() #gtkdevice.set_colormap(self.window) - vbox = gtk.GtkVBox() + vbox = gtk.VBox() vbox.set_resize_mode(gtk.RESIZE_QUEUE) self.window.add(vbox) - table = gtk.GtkTable(3, 3) + table = gtk.Table(3, 3) vbox.pack_start(table) - menubutton = gtk.GtkButton() - arrow = gtk.GtkArrow() + menubutton = gtk.Button() + arrow = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_OUT) menubutton.add(arrow) menubutton.connect('button_press_event', self.show_menu) table.attach(menubutton, 0, 1, 0, 1, FILL, FILL) - self.hruler = gtk.GtkHRuler() + self.hruler = gtk.HRuler() table.attach(self.hruler, 1, 2, 0, 1, EXPAND|FILL, 0) - self.vruler = gtk.GtkVRuler() + self.vruler = gtk.VRuler() table.attach(self.vruler, 0, 1, 1, 2, 0, EXPAND|FILL) - hadjust = gtk.GtkAdjustment() - hscrollbar = gtk.GtkHScrollbar(hadjust) + hadjust = gtk.Adjustment() + hscrollbar = gtk.HScrollbar(hadjust) hscrollbar.set_update_policy(UPDATE_DELAYED) table.attach(hscrollbar, 1, 2, 2, 3, EXPAND|FILL, 0) - vadjust = gtk.GtkAdjustment() - vscrollbar = gtk.GtkVScrollbar(vadjust) + vadjust = gtk.Adjustment() + vscrollbar = gtk.VScrollbar(vadjust) vscrollbar.set_update_policy(UPDATE_DELAYED) table.attach(vscrollbar, 2, 3, 1, 2, 0, EXPAND|FILL) @@ -163,11 +167,11 @@ self.canvas.Subscribe(POSITION, self.update_rulers) table.attach(self.canvas, 1, 2, 1, 2) - self.statusbar = gtk.GtkHBox() #GtkTable(3, 1) + self.statusbar = gtk.HBox() #GtkTable(3, 1) #self.statusbar.set_resize_mode(gtk.RESIZE_QUEUE) vbox.pack_start(self.statusbar, 0, 0) - frame = gtk.GtkFrame() + frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) #self.statusbar.attach(frame, 0, 1, 0, 1, SHRINK|FILL, 0) self.statusbar.pack_start(frame) @@ -175,7 +179,7 @@ self.document.Subscribe(UNDO, self.modified.Update) frame.add(self.modified) - frame = gtk.GtkFrame() + frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) #self.statusbar.attach(frame, 1, 2, 0, 1, SHRINK|FILL, 0) self.statusbar.pack_start(frame) @@ -183,7 +187,7 @@ self.canvas.Subscribe(POSITION, self.poslabel.Update) frame.add(self.poslabel) - frame = gtk.GtkFrame() + frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) frame.show() #self.statusbar.attach(frame, 2, 3, 0, 1, SHRINK|EXPAND|FILL, 0) @@ -193,9 +197,8 @@ self.infolabel.show() frame.add(self.infolabel) - size = Sketch.UI.preferences.window_size - apply(self.window.set_usize, size) - self.window.set_policy(1, 1, 0) + self.window.set_size_request(*Sketch.UI.preferences.window_size) + #self.window.set_policy(1, 1, 0) self.window.show_all() self.canvas.FitPageToWindow() @@ -208,8 +211,8 @@ def update_rulers(self): pos = self.canvas.CurrentPos() - self.hruler['position'] = pos.x - self.vruler['position'] = pos.y + self.hruler.set_property('position', pos.x) + self.vruler.set_property('position', pos.y) def show_menu(self, widget, event): # this was inspired by gimp... Index: Sketch/UI/menu.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/menu.py,v retrieving revision 1.6 diff -u -r1.6 menu.py --- Sketch/UI/menu.py 22 Jun 2000 18:31:40 -0000 1.6 +++ Sketch/UI/menu.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1999, 2000 by Bernhard Herzog +# Copyright (C) 1999, 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -15,11 +15,10 @@ # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -from types import ListType, StringType +from types import StringType -import gtk, GDK +import gtk -from Sketch import _ import Sketch.Editor import skapp @@ -35,8 +34,8 @@ if stroke: key, mods = stroke self.add_accelerator("activate", accel, key, mods, 'visible') - self.connect('add-accelerator', self.accel_added) - self.connect('remove-accelerator', self.accel_removed) + #self.connect('add-accelerator', self.accel_added) + #self.connect('remove-accelerator', self.accel_removed) def subscribe(self): for channel in self.command.channels: @@ -63,23 +62,23 @@ def accel_removed(self, item, accel, key, mod): skapp.keymap.RemoveItem((key, mod)) -class SketchMenuCommand(SketchMenuItem, gtk.GtkMenuItem): +class SketchMenuCommand(SketchMenuItem, gtk.MenuItem): def __init__(self, command, context, accel, stroke = ''): if command.HasDynText(): - gtk.GtkMenuItem.__init__(self) - self.label = gtk.GtkLabel(command.Title()) + gtk.MenuItem.__init__(self) + self.label = gtk.Label(command.Title()) self.label.set_alignment(0.0, 0.5) self.label.show() self.add(self.label) else: - gtk.GtkMenuItem.__init__(self, command.Title()) + gtk.MenuItem.__init__(self, command.Title()) SketchMenuItem.__init__(self, command, context, accel, stroke) -class SketchMenuCheck(SketchMenuItem, gtk.GtkCheckMenuItem): +class SketchMenuCheck(SketchMenuItem, gtk.CheckMenuItem): def __init__(self, command, context, accel, stroke = ''): - gtk.GtkCheckMenuItem.__init__(self, command.Title()) + gtk.CheckMenuItem.__init__(self, command.Title()) SketchMenuItem.__init__(self, command, context, accel, stroke) def changed(self): @@ -87,16 +86,16 @@ checked = self.command.Checked(self.context) active = self.active if checked and not active or not checked and active: - self.signal_handler_block(self.activate_id) + self.handler_block(self.activate_id) self.set_active(checked) - self.signal_handler_unblock(self.activate_id) + self.handler_unblock(self.activate_id) def make_menu(menutree, keymap, context, accel = None): if accel is None: - accel = gtk.GtkAccelGroup() + accel = gtk.AccelGroup() stroke = () - menu = gtk.GtkMenu() - menuitem = gtk.GtkTearoffMenuItem() + menu = gtk.Menu() + menuitem = gtk.TearoffMenuItem() menuitem.show() menu.append(menuitem) last = None @@ -106,7 +105,7 @@ # a separator. Only add it if the last one wasn't a # separator too if last is not None: - menuitem = gtk.GtkMenuItem() + menuitem = gtk.MenuItem() else: continue elif isinstance(item, StringType): @@ -124,7 +123,7 @@ show = 0 else: # must be a submenu - menuitem = gtk.GtkMenuItem(item.Title()) + menuitem = gtk.MenuItem(item.Title()) menuitem.set_submenu(make_menu(item, keymap, context, accel)) last = item if show: Index: Sketch/UI/metapanel.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/metapanel.py,v retrieving revision 1.4 diff -u -r1.4 metapanel.py --- Sketch/UI/metapanel.py 13 Sep 2000 23:42:21 -0000 1.4 +++ Sketch/UI/metapanel.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 2000 by Bernhard Herzog +# Copyright (C) 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -38,19 +38,19 @@ def build_window(self): vbox = self.vbox - table = gtk.GtkTable(2, 2) + table = gtk.Table(2, 2) vbox.pack_start(table) - hadjust = gtk.GtkAdjustment() - hscrollbar = gtk.GtkHScrollbar(hadjust) + hadjust = gtk.Adjustment() + hscrollbar = gtk.HScrollbar(hadjust) table.attach(hscrollbar, 0, 1, 1, 2, EXPAND|FILL, 0) - vadjust = gtk.GtkAdjustment() - vscrollbar = gtk.GtkVScrollbar(vadjust) + vadjust = gtk.Adjustment() + vscrollbar = gtk.VScrollbar(vadjust) table.attach(vscrollbar, 1, 2, 0, 1, 0, EXPAND|FILL) - self.listbox = gtk.GtkCList(2, (_("Key"), _("Value"))) + self.listbox = gtk.CList(2, (_("Key"), _("Value"))) self.listbox.set_hadjustment(hadjust) self.listbox.set_vadjustment(vadjust) self.listbox['width'] = 150 @@ -58,34 +58,34 @@ self.listbox.connect("unselect_row", self.list_select) table.attach(self.listbox, 0, 1, 0, 1, EXPAND|FILL, EXPAND|FILL) - button = gtk.GtkButton(_("Close")) + button = gtk.Button(_("Close")) button.connect("clicked", self.close) self.action_area.pack_start(button, expand = 0, fill = 0) - table = gtk.GtkTable(2, 3) + table = gtk.Table(2, 3) vbox.pack_start(table, expand = 0, fill = 0) - label = gtk.GtkLabel(_("Key")) + label = gtk.Label(_("Key")) table.attach(label, 0, 1, 0, 1, 0, 0) - self.key_entry = gtk.GtkEntry() + self.key_entry = gtk.Entry() table.attach(self.key_entry, 1, 2, 0, 1, EXPAND|FILL, 0) - label = gtk.GtkLabel(_("Value")) + label = gtk.Label(_("Value")) table.attach(label, 0, 1, 1, 2, 0, 0) - self.value_entry = gtk.GtkEntry() + self.value_entry = gtk.Entry() table.attach(self.value_entry, 1, 2, 1, 2, EXPAND|FILL, 0) - self.eval_check = gtk.GtkCheckButton(_("Value is Python Expression")) + self.eval_check = gtk.CheckButton(_("Value is Python Expression")) table.attach(self.eval_check, 0, 2, 2, 3, EXPAND|FILL, 0) - hbox = gtk.GtkHBox(spacing = 5) + hbox = gtk.HBox(spacing = 5) hbox.set_border_width(5) self.vbox.pack_start(hbox, expand = 0, fill = 0) - button = gtk.GtkButton(_("Add/Set")) + button = gtk.Button(_("Add/Set")) button.connect("clicked", self.add_data) hbox.pack_start(button) - button = gtk.GtkButton(_("Delete")) + button = gtk.Button(_("Delete")) button.connect("clicked", self.delete_data) hbox.pack_start(button) Index: Sketch/UI/msgpanel.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/msgpanel.py,v retrieving revision 1.1 diff -u -r1.1 msgpanel.py --- Sketch/UI/msgpanel.py 19 Aug 2000 16:17:05 -0000 1.1 +++ Sketch/UI/msgpanel.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 2000 by Bernhard Herzog +# Copyright (C) 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -51,31 +51,31 @@ def build_window(self): vbox = self.vbox - table = gtk.GtkTable(2, 2) + table = gtk.Table(2, 2) table.show() vbox.pack_start(table) - hadjust = gtk.GtkAdjustment() - hscrollbar = gtk.GtkHScrollbar(hadjust) + hadjust = gtk.Adjustment() + hscrollbar = gtk.HScrollbar(hadjust) hscrollbar.show() table.attach(hscrollbar, 0, 1, 1, 2, EXPAND|FILL, 0) - vadjust = gtk.GtkAdjustment() - vscrollbar = gtk.GtkVScrollbar(vadjust) + vadjust = gtk.Adjustment() + vscrollbar = gtk.VScrollbar(vadjust) vscrollbar.show() table.attach(vscrollbar, 1, 2, 0, 1, 0, EXPAND|FILL) - self.listbox = gtk.GtkCList() + self.listbox = gtk.CList() self.listbox.set_hadjustment(hadjust) self.listbox.set_vadjustment(vadjust) self.listbox['width'] = 150 table.attach(self.listbox, 0, 1, 0, 1, EXPAND|FILL, EXPAND|FILL) - button = gtk.GtkButton(_("Close")) + button = gtk.Button(_("Close")) button.connect("clicked", self.close) self.action_area.pack_start(button, expand = 0, fill = 0) - button = gtk.GtkButton(_("Clear")) + button = gtk.Button(_("Clear")) button.connect("clicked", self.clear) self.action_area.pack_start(button, expand = 0, fill = 0) Index: Sketch/UI/objectpanel.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/objectpanel.py,v retrieving revision 1.1 diff -u -r1.1 objectpanel.py --- Sketch/UI/objectpanel.py 1 Aug 2002 13:43:44 -0000 1.1 +++ Sketch/UI/objectpanel.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1999, 2000, 2002 by Bernhard Herzog +# Copyright (C) 1999, 2000, 2002, 2003 by Bernhard Herzog # # Object Properties Panel and Line Style Dialog # Copyright (C) 2001 by Mark Rose @@ -40,7 +40,7 @@ # -import gtk, _gtk, GDK +import gtk import types import operator from math import log10 @@ -99,7 +99,7 @@ return pstack -class CommonOptionMenu(gtk.GtkOptionMenu, Publisher): +class CommonOptionMenu(gtk.OptionMenu, Publisher): """Base class for specialized option menus @@ -128,7 +128,7 @@ mode = FIXED def __init__(self, values = []): - gtk.GtkOptionMenu.__init__(self) + gtk.OptionMenu.__init__(self) self.base_values = values self.values = values self.idx = None @@ -151,14 +151,14 @@ return [], None def update(self): - self.menu = menu = gtk.GtkMenu() + self.menu = menu = gtk.Menu() options, default = self.build_options() idx = 0 for option in options: if isinstance(option, types.StringType): - item = gtk.GtkMenuItem(option) + item = gtk.MenuItem(option) else: - item = gtk.GtkMenuItem() + item = gtk.MenuItem() item.add(option) item.connect('activate', self.on_select, idx) menu.append(item) @@ -212,7 +212,7 @@ for pixmap in self.pixmaps: if isinstance(pixmap, types.StringType): pixmap = getattr(skpixmaps.pixmaps, pixmap) - options.append(apply(gtk.GtkPixmap, pixmap)) + options.append(apply(gtk.Pixmap, pixmap)) return options, 0 @@ -271,8 +271,8 @@ return maps def build_options(self): - window = self.get_window() - return map(gtk.GtkPixmap, self.GeneratePixmaps(window)), 0 + window = self.window + return map(gtk.Pixmap, self.GeneratePixmaps(window)), 0 @@ -308,10 +308,10 @@ dashes[idx] = 1 elif length > 255: dashes[idx] = 255 - gc.line_style = GDK.LINE_ON_OFF_DASH + gc.line_style = gtk.gdk.LINE_ON_OFF_DASH gc.set_dashes(0, dashes) # offset 0 else: - gc.line_style = GDK.LINE_SOLID + gc.line_style = gtk.gdk.LINE_SOLID class LineDashesMenu(CommonOptionMenu): @@ -330,22 +330,22 @@ CommonOptionMenu.__init__(self, StandardDashes()) def build_options(self): - window = self.get_window() + window = self.window w, h = self.width, self.height w = max(w, window.width - 60) # XXX this hack can cause # run-away reallocation: fixme! pixmap = gtk.create_pixmap(window, w, h, window.depth) gc = pixmap.new_gc() - _gtk.gdk_draw_rectangle(pixmap, gc, 1, 0, 0, w, h) + pixmap.draw_rectangle(gc, 1, 0, 0, w, h) options = [] for dash in self.values: bitmap = gtk.create_pixmap(None, w, h, 1) gc = bitmap.new_gc() - _gtk.gdk_draw_rectangle(bitmap, gc, 1, 0, 0, w, h) + bitmap.draw_rectangle(gc, 1, 0, 0, w, h) gc.foreground = gc.background # opaque set_width_and_dashes(gc, 3, dash) - _gtk.gdk_draw_line(bitmap, gc, 0, h / 2, w, h / 2) - options.append(gtk.GtkPixmap(pixmap, bitmap)) + bitmap.draw_line(gc, 0, h / 2, w, h / 2) + options.append(gtk.Pixmap(pixmap, bitmap)) return options, 0 @@ -378,26 +378,26 @@ CommonOptionMenu.__init__(self, values) def build_options(self): - window = self.get_window() + window = self.window w, h = self.width, self.height w = max(w, window.width - 100) # XXX this hack can cause # run-away reallocation: fixme! pixmap = gtk.create_pixmap(window, w, h, window.depth) gc = pixmap.new_gc() - _gtk.gdk_draw_rectangle(pixmap, gc, 1, 0, 0, w, h) + pixmap.draw_rectangle(gc, 1, 0, 0, w, h) format = "%%0.%df" % self.digits options = [] for width in self.values: bitmap = gtk.create_pixmap(None, w, h, 1) gc = bitmap.new_gc() - _gtk.gdk_draw_rectangle(bitmap, gc, 1, 0, 0, w, h) + bitmap.draw_rectangle(gc, 1, 0, 0, w, h) gc.foreground = gc.background # opaque gc.line_width = int(round(width)) - _gtk.gdk_draw_line(bitmap, gc, 0, h / 2, w, h / 2) - gtkpixmap = gtk.GtkPixmap(pixmap, bitmap) - hbox = gtk.GtkHBox() - label = gtk.GtkLabel(format % (width / self.scale)) - align = gtk.GtkAlignment(1, 0, 0, 1) + bitmap.draw_line(gc, 0, h / 2, w, h / 2) + gtkpixmap = gtk.Pixmap(pixmap, bitmap) + hbox = gtk.HBox() + label = gtk.Label(format % (width / self.scale)) + align = gtk.Alignment(1, 0, 0, 1) align.add(label) align.set_usize(40, 0) # XXX font size dependent hbox.pack_start(align) @@ -430,21 +430,21 @@ Sketch.UI.preferences.user_line_widths = self.order -class ObjectPropertiesFrame(gtk.GtkVBox, Publisher): +class ObjectPropertiesFrame(gtk.VBox, Publisher): """Base class for frames to be inserted into an ObjectPropertiesPanel """ def __init__(self, context): - gtk.GtkVBox.__init__(self) + gtk.VBox.__init__(self) self.context = context self.auto_update = 1 self.build_frame() def build_menu(self, items, accel = None): if accel is None: - accel = gtk.GtkAccelGroup() - factory = gtk.GtkItemFactory(gtk.GtkMenu(), '', accel) + accel = gtk.AccelGroup() + factory = gtk.ItemFactory(gtk.Menu(), '', accel) factory.create_items(items) menu = factory.get_widget('') return menu, accel, factory @@ -645,8 +645,8 @@ def build_frame(self): vbox = self # no line, color - color_hbox = gtk.GtkHBox(homogeneous = 1) - self.none = none = gtk.GtkToggleButton(_("No Line")) + color_hbox = gtk.HBox(homogeneous = 1) + self.none = none = gtk.ToggleButton(_("No Line")) none.connect('clicked', self.on_none) self.color = color = ColorButton(_("Color"), _("Line Color"), StandardColors.black) @@ -654,10 +654,10 @@ color_hbox.pack_start(none, 0, 1) color_hbox.pack_start(color, 0, 1) # width, units - label = gtk.GtkLabel(_("Width:")) - width_hbox = gtk.GtkHBox(homogeneous = 0) - adjust = gtk.GtkAdjustment(1, 0, 72, 1, 0, 0) - self.width = width = gtk.GtkSpinButton(adjust) + label = gtk.Label(_("Width:")) + width_hbox = gtk.HBox(homogeneous = 0) + adjust = gtk.Adjustment(1, 0, 72, 1, 0, 0) + self.width = width = gtk.SpinButton(adjust) width.connect('changed', self.on_width) self.unit_menu = unit_menu = UnitMenu() unit_menu.Subscribe(CHANGED, self.on_units) @@ -665,10 +665,10 @@ width_hbox.pack_start(width, 1, 1) width_hbox.pack_start(unit_menu, 0, 1) # width option menu - width_menu_hbox = gtk.GtkHBox(homogeneous = 0) + width_menu_hbox = gtk.HBox(homogeneous = 0) self.width_menu = width_menu = LineWidthMenu() width_menu.Subscribe(CHANGED, self.apply, 'line_width') - self.add_button = add_button = gtk.GtkButton(_("Add")) + self.add_button = add_button = gtk.Button(_("Add")) add_button.connect('clicked', self.on_add) width_menu_hbox.pack_start(width_menu, 1, 1) width_menu_hbox.pack_start(add_button, 0, 1) @@ -690,7 +690,7 @@ [JoinMiter, JoinRound, JoinBevel]) line_joints.Subscribe(CHANGED, self.apply, 'line_join') self.line_joints = line_joints - table = gtk.GtkTable(2, 2, homogeneous = 0) + table = gtk.Table(2, 2, homogeneous = 0) table.attach(left_arrow, 0, 1, 0, 1) table.attach(right_arrow, 1, 2, 0, 1) table.attach(line_joints, 0, 1, 1, 2) @@ -731,15 +731,15 @@ self.build_frames() self.build_menu() self.vbox.pack_start(self.menubar, 0, 1) - self.framebox = gtk.GtkFrame() + self.framebox = gtk.Frame() self.vbox.pack_start(self.framebox, 0, 1) self.vbox.show_all() - self.update_from_button = gtk.GtkButton(_('Update From...')) + self.update_from_button = gtk.Button(_('Update From...')) self.update_from_button.connect('clicked', self.on_update_from) # XXX "update from..." is not yet implemented (see notes above) self.update_from_button.set_sensitive(0) self.update_from_button.show() - self.apply_button = gtk.GtkButton(_('Apply')) + self.apply_button = gtk.Button(_('Apply')) self.apply_button.connect('clicked', self.on_apply) self.apply_button.show() self.action_area.pack_start(self.prev_button, 0, 0) # hidden @@ -780,18 +780,18 @@ self.set_frame(idx) def build_menu(self): - accel = gtk.GtkAccelGroup() - factory = gtk.GtkItemFactory(gtk.GtkMenuBar(), '', accel) + accel = gtk.AccelGroup() + factory = gtk.ItemFactory(gtk.MenuBar(), '', accel) factory.create_items(self.menu_items) # hidden buttons to act as accelerator proxies for frame # switching with page up/dn. is this the correct technique? - self.next_button = gtk.GtkButton() + self.next_button = gtk.Button() self.next_button.connect('clicked', self.next_page) - accel.add(GDK.Page_Down, 0, 0, self.next_button, 'clicked') - self.prev_button = gtk.GtkButton() + accel.add(gtk.keysyms.Page_Down, 0, 0, self.next_button, 'clicked') + self.prev_button = gtk.Button() self.prev_button.connect('clicked', self.prev_page) - accel.add(GDK.Page_Up, 0, 0, self.prev_button, 'clicked') + accel.add(gtk.keysyms.Page_Up, 0, 0, self.prev_button, 'clicked') self.add_accel_group(accel) self.menubar = factory.get_widget("") @@ -803,7 +803,7 @@ menu = factory.get_widget("/" + _("Dialogs")) for idx in range(len(self.frames)): frame, title = self.frames[idx] - item = gtk.GtkMenuItem(title) + item = gtk.MenuItem(title) item.connect('activate', self.on_frame, idx) menu.append(item) Index: Sketch/UI/palette.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/palette.py,v retrieving revision 1.1 diff -u -r1.1 palette.py --- Sketch/UI/palette.py 1 Aug 2002 13:43:44 -0000 1.1 +++ Sketch/UI/palette.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999, 2000, 2002 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003 by Bernhard Herzog # # Palette - Configurable fill palettes for Sketch # Copyright (C) 2001 by Mark Rose @@ -24,7 +24,6 @@ import os.path from glob import glob import gtk -import GDK, GTK import Sketch import Sketch.UI @@ -203,7 +202,7 @@ def layout(self, force = 0): if not hasattr(self, 'window'): return - w, h = self.window.width, self.window.height + w, h = self.window.get_size() if w > h: self.direction = self.HORIZONTAL else: self.direction = self.VERTICAL s = self.scale @@ -232,7 +231,7 @@ def realize_method(self, *args): apply(SketchDrawingArea.realize_method, (self,) + args) - self.fill_rect = Rect(0, 0, self.window.width, self.window.height) + self.fill_rect = Rect(0, 0, *self.window.get_size()) self.compute_trafo() def hit(self, x, y): @@ -274,23 +273,25 @@ self.layout(1) def get_motion_parameters(self): + width, height = selg.window.get_size() if self.direction == self.VERTICAL: direction = Point(0, 1) - dimension = self.window.height + dimension = height else: direction = Point(1, 0) - dimension = self.window.width + dimension = width return direction, dimension def Drag(self, delta): + width, height = selg.window.get_size() delta = int(delta) if self.direction == self.VERTICAL: - limit = self.window.height - self.pixsize.y + limit = height - self.pixsize.y y = self.origin.y + delta y = min(0, max(y, limit)) origin = Point(self.origin.x, y) else: - limit = self.window.width - self.pixsize.x + limit = width - self.pixsize.x x = self.origin.x + delta x = min(0, max(x, limit)) origin = Point(x, self.origin.y) @@ -305,7 +306,7 @@ gc = self.gc gc.StartDblBuffer() gc.SetFillColor(StandardColors.white) - gc.FillRectangle(0,0,win.width, win.height) + gc.FillRectangle(0, 0, *win.get_size()) x, y = self.origin.x, self.origin.y w, h = self.pixsize.x, self.pixsize.y gdk_draw_pixmap(gc.drawable, gc.gc, self.pixmap, @@ -320,10 +321,10 @@ PatternSample.RedrawMethod(self, region) -class SwatchTip(gtk.GtkWindow): +class SwatchTip(gtk.Window): def __init__(self, parent): - gtk.GtkWindow.__init__(self, GTK.WINDOW_POPUP) + gtk.Window.__init__(self, gtk.WINDOW_POPUP) self.parent = parent self.enabled = 0 self.timer_tag = None @@ -334,17 +335,17 @@ def build_window(self): self.set_policy(0, 0, 1) - self.label = gtk.GtkLabel('Tip!') + self.label = gtk.Label('Tip!') self.label.set_padding(3,3) self.label.show() self.sample = SwatchSample() self.sample.SetPattern(EmptyPattern) self.sample.size(64,64) # default (fixed) - self.vbox = gtk.GtkVBox() + self.vbox = gtk.VBox() self.vbox.show() self.vbox.add(self.label) self.vbox.add(self.sample) - self.frame = gtk.GtkFrame() + self.frame = gtk.Frame() self.frame.show() self.frame.add(self.vbox) self.add(self.frame) @@ -352,7 +353,7 @@ def Pointer(self, point): self.hide() self.set_clock() - x, y = self.parent.get_window().origin + x, y = self.parent.window.origin self.point = point + Point(x, y) def SetTip(self, tip, pattern = None): @@ -394,7 +395,7 @@ self.timer_tag = gtk.timeout_add(self.delay, self.show) def hide(self): - gtk.GtkWindow.hide(self) + gtk.Window.hide(self) self.visible = 0 # screen edge placement correction @@ -426,19 +427,19 @@ -class SwatchFrame(gtk.GtkEventBox): +class SwatchFrame(gtk.EventBox): - MASK = GDK.BUTTON_PRESS_MASK | \ - GDK.BUTTON_RELEASE_MASK | \ - GDK.POINTER_MOTION_MASK | \ - GDK.ENTER_NOTIFY_MASK | \ - GDK.LEAVE_NOTIFY_MASK | \ - GDK.KEY_PRESS_MASK | \ - GDK.KEY_RELEASE_MASK | \ - GDK.POINTER_MOTION_HINT_MASK + MASK = gtk.gdk.BUTTON_PRESS_MASK | \ + gtk.gdk.BUTTON_RELEASE_MASK | \ + gtk.gdk.POINTER_MOTION_MASK | \ + gtk.gdk.ENTER_NOTIFY_MASK | \ + gtk.gdk.LEAVE_NOTIFY_MASK | \ + gtk.gdk.KEY_PRESS_MASK | \ + gtk.gdk.KEY_RELEASE_MASK | \ + gtk.gdk.POINTER_MOTION_HINT_MASK def __init__(self): - gtk.GtkEventBox.__init__(self) + gtk.EventBox.__init__(self) self.swatch = None self.child = None self.press = 0 @@ -460,19 +461,19 @@ self.connect('focus_out_event', self.on_focus_out) self.connect_after('key_press_event', self.key_press) self.connect_after('key_release_event', self.key_release) - self.set_flags(GTK.CAN_FOCUS) + self.set_flags(gtk.CAN_FOCUS) def on_focus_in(self, *args): - self.set_flags(GTK.HAS_FOCUS) + self.set_flags(gtk.HAS_FOCUS) def on_focus_out(self, *args): - self.unset_flags(GTK.HAS_FOCUS) + self.unset_flags(gtk.HAS_FOCUS) def add(self, widget): if not isinstance(widget, SwatchWidget): raise "SwatchFrame only accepts SwatchWidgets." self.child = widget - gtk.GtkEventBox.add(self, widget) + gtk.EventBox.add(self, widget) self.swatch = widget def refresh_tip(self): @@ -545,25 +546,25 @@ def set_cursor(self, cursor): cursor = gtk.cursor_new(cursor) - self.get_window().set_cursor(cursor) + self.window.set_cursor(cursor) def update_cursor(self): pass def key_press(self, widget, event): mode = 0 - if event.keyval == GDK.Shift_L: mode = LEFT_SHIFT - elif event.keyval == GDK.Shift_R: mode = RIGHT_SHIFT - elif event.keyval == GDK.Control_L: mode = LEFT_CONTROL - elif event.keyval == GDK.Control_R: mode = RIGHT_CONTROL + if event.keyval == gtk.keysyms.Shift_L: mode = LEFT_SHIFT + elif event.keyval == gtk.keysyms.Shift_R: mode = RIGHT_SHIFT + elif event.keyval == gtk.keysyms.Control_L: mode = LEFT_CONTROL + elif event.keyval == gtk.keysyms.Control_R: mode = RIGHT_CONTROL self.state = self.state | mode def key_release(self, widget, event): mode = 0 - if event.keyval == GDK.Shift_L: mode = LEFT_SHIFT - elif event.keyval == GDK.Shift_R: mode = RIGHT_SHIFT - elif event.keyval == GDK.Control_L: mode = LEFT_CONTROL - elif event.keyval == GDK.Control_R: mode = RIGHT_CONTROL + if event.keyval == gtk.keysyms.Shift_L: mode = LEFT_SHIFT + elif event.keyval == gtk.keysyms.Shift_R: mode = RIGHT_SHIFT + elif event.keyval == gtk.keysyms.Control_L: mode = LEFT_CONTROL + elif event.keyval == gtk.keysyms.Control_R: mode = RIGHT_CONTROL self.state = self.state & ~mode # @@ -571,7 +572,7 @@ # def on_event(self, widget, event): - if event.type == GDK.BUTTON_PRESS: + if event.type == gtk.gdk.BUTTON_PRESS: if self.press: return self.pointer = Point(event.x, event.y) self.tip.Disable() @@ -579,7 +580,7 @@ self.select = self.child.hit(event.x, event.y) self.press = 1 self.press_point = self.pointer - elif event.type == GDK.MOTION_NOTIFY: + elif event.type == gtk.gdk.MOTION_NOTIFY: if event.is_hint: x, y = self.get_pointer() else: @@ -596,7 +597,7 @@ self.pointer = current_point if not self.press: # and not self.sliding: self.refresh_tip() - elif event.type == GDK.BUTTON_RELEASE: + elif event.type == gtk.gdk.BUTTON_RELEASE: if event.button == 1: if self.press and not self.sliding and \ self.select is not None and \ @@ -607,12 +608,12 @@ if self.sliding: self.sliding = 0 gtk.grab_remove(self) - elif event.type == GDK._2BUTTON_PRESS: + elif event.type == gtk.gdk._2BUTTON_PRESS: pass - elif event.type == GDK.LEAVE_NOTIFY: + elif event.type == gtk.gdk.LEAVE_NOTIFY: self.tip.Disable() self.update_cursor() - elif event.type == GDK.ENTER_NOTIFY: + elif event.type == gtk.gdk.ENTER_NOTIFY: self.grab_focus() self.update_cursor() return 0 @@ -686,10 +687,10 @@ # derived from this class can be inserted into the # notebook in the palette panel. -class PaletteFrame(gtk.GtkEventBox): +class PaletteFrame(gtk.EventBox): def __init__(self, palette): - gtk.GtkEventBox.__init__(self) + gtk.EventBox.__init__(self) self.palette = palette self.palette.Subscribe(CHANGED, self.changed) self.context = None @@ -735,9 +736,9 @@ def __init__(self, palette): PaletteFrame.__init__(self, palette) - self.list = list = gtk.GtkCList(3, ('Arrow', 'Width', 'Height')) - self.scroll = scroll = gtk.GtkScrolledWindow() - scroll.set_policy(GTK.POLICY_AUTOMATIC, GTK.POLICY_ALWAYS) + self.list = list = gtk.CList(3, ('Arrow', 'Width', 'Height')) + self.scroll = scroll = gtk.ScrolledWindow() + scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS) scroll.add_with_viewport(list) self.add(self.scroll) self.show_all() @@ -749,7 +750,7 @@ def populate_list(self): row = 0 size = 16 - pixmaps = self.palette.GeneratePixmaps(self.get_window(), size) + pixmaps = self.palette.GeneratePixmaps(self.window, size) list = self.list list.set_row_height(size) for arrow in self.palette.items: @@ -781,7 +782,7 @@ def build_window(self): self.lookup = {} - self.notebook = gtk.GtkNotebook() + self.notebook = gtk.Notebook() self.vbox.pack_start(self.notebook) self.notebook.set_show_border(0) self.notebook.set_show_tabs(0) @@ -795,33 +796,33 @@ default_palette = getattr(Sketch.UI.preferences, 'default_palette', None) default_n = 0 - menu = gtk.GtkMenu() - item = gtk.GtkTearoffMenuItem() + menu = gtk.Menu() + item = gtk.TearoffMenuItem() menu.append(item) - item = gtk.GtkRadioMenuItem(label = "Fill") + item = gtk.RadioMenuItem(label = "Fill") item.connect('activate', self.on_set_fill) menu.append(item) - item = gtk.GtkRadioMenuItem(group = item, label = "Line") + item = gtk.RadioMenuItem(group = item, label = "Line") item.connect('activate', self.on_set_line) menu.append(item) - item = gtk.GtkMenuItem() + item = gtk.MenuItem() menu.append(item) n = 0 self.pages = [] for cat in palettes.keys(): - sub = gtk.GtkMenu() - item = gtk.GtkMenuItem(cat) + sub = gtk.Menu() + item = gtk.MenuItem(cat) item.set_submenu(sub) menu.append(item) palettes[cat].sort(lambda x, y: cmp(x.Name(), y.Name())) for palette in palettes[cat]: name = palette.Name() - item = gtk.GtkMenuItem(name) + item = gtk.MenuItem(name) item.connect("activate", self.choose_palette) sub.append(item) frame = palette.NewFrame(self.context) item.set_data('frame',frame) - self.notebook.append_page(frame, gtk.GtkLabel(name)) + self.notebook.append_page(frame, gtk.Label(name)) palette.Subscribe(CHANGED, self.palette_changed, frame) title = '%s - %s' % (cat, name) self.pages.append((frame, title, name, cat)) @@ -883,7 +884,7 @@ self.menu.popup(None, None, None, event.button, event.time) def add_menu_ops(self): - menu = gtk.GtkMenu() + menu = gtk.Menu() ops = ( None, (1, _("Set as default"), self.set_as_default), (0, _("New palette"), self.new_palette), @@ -892,14 +893,14 @@ ) for op in ops: if op is None: - item = gtk.GtkMenuItem() + item = gtk.MenuItem() else: enable, op_name, op_cb = op - item = gtk.GtkMenuItem(op_name) + item = gtk.MenuItem(op_name) item.set_sensitive(enable) item.connect('activate',op_cb) menu.append(item) - item = gtk.GtkMenuItem('Palette Ops') + item = gtk.MenuItem('Palette Ops') item.set_submenu(menu) self.menu.append(item) Index: Sketch/UI/poslabel.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/poslabel.py,v retrieving revision 1.3 diff -u -r1.3 poslabel.py --- Sketch/UI/poslabel.py 15 Apr 2000 20:51:54 -0000 1.3 +++ Sketch/UI/poslabel.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1998, 1999, 2000 by Bernhard Herzog +# Copyright (C) 1998, 1999, 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -35,13 +35,13 @@ 'mm': '(%3.1fmm, %3.1fmm)', } -class PositionLabel(gtk.GtkLabel): +class PositionLabel(gtk.Label): context_menu = None def __init__(self, update = None): self.update = update - gtk.GtkLabel.__init__(self) + gtk.Label.__init__(self, "") #self.bind('', self.popup_context_menu) self.connect('destroy', self.destroy_event) self.set_unit(Sketch.UI.preferences.default_unit) @@ -86,11 +86,11 @@ -class InfoLabel(gtk.GtkLabel): +class InfoLabel(gtk.Label): def __init__(self, update = None): self.update = update - gtk.GtkLabel.__init__(self) + gtk.Label.__init__(self, "") self.connect('destroy', self.destroy_event) Sketch.UI.preferences.Subscribe(CHANGED, self.preference_changed) self.idle_added = 0 Index: Sketch/UI/properties.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/properties.py,v retrieving revision 1.8 diff -u -r1.8 properties.py --- Sketch/UI/properties.py 9 Dec 2001 19:02:33 -0000 1.8 +++ Sketch/UI/properties.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999, 2000, 2001 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -126,7 +126,7 @@ maskbitmap = None -class StyleList(gtk.GtkCList): +class StyleList(gtk.CList): def __init__(self, preview_factory): self.preview_factory = preview_factory @@ -134,14 +134,14 @@ for name, pixmap, converter in property_defs: titles.append(getattr(pixmaps, pixmap)) - gtk.GtkCList.__init__(self, len(titles)) + gtk.CList.__init__(self, len(titles)) for index in range(len(titles)): title = titles[index] if isinstance(title, StringType): self.set_column_title(index, title) else: pixmap, mask = title - pixmap = gtk.GtkPixmap(pixmap, mask) + pixmap = gtk.Pixmap(pixmap, mask) self.set_column_widget(index, pixmap) self.column_titles_show() @@ -226,27 +226,27 @@ #self.fillsample.show() #vbox.pack_start(self.fillsample) - notebook = gtk.GtkNotebook() + notebook = gtk.Notebook() vbox.pack_start(notebook) - swin = gtk.GtkScrolledWindow() + swin = gtk.ScrolledWindow() swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.current_styles = StyleList(self.preview_factory) swin.add(self.current_styles) - notebook.append_page(swin, gtk.GtkLabel(_("Current Object"))) + notebook.append_page(swin, gtk.Label(_("Current Object"))) - swin = gtk.GtkScrolledWindow() + swin = gtk.ScrolledWindow() swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.dynamic_styles = StyleList(self.preview_factory) swin.add(self.dynamic_styles) - notebook.append_page(swin, gtk.GtkLabel(_("Styles"))) + notebook.append_page(swin, gtk.Label(_("Styles"))) vbox.show_all() vbox.realize() - self.preview_factory.init_gc(vbox.get_window()) + self.preview_factory.init_gc(vbox.window) global maskbitmap - maskbitmap = gtk.create_bitmap_from_data(vbox.get_window(), '\377'*32, + maskbitmap = gtk.create_bitmap_from_data(vbox.window, '\377'*32, 16, 16) def close(self, *args): Index: Sketch/UI/reload.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/reload.py,v retrieving revision 1.1 diff -u -r1.1 reload.py --- Sketch/UI/reload.py 22 Aug 2000 22:05:33 -0000 1.1 +++ Sketch/UI/reload.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 2000 by Bernhard Herzog +# Copyright (C) 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -36,35 +36,35 @@ def build_window(self): vbox = self.vbox - table = gtk.GtkTable(2, 2) + table = gtk.Table(2, 2) table.show() vbox.pack_start(table) - hadjust = gtk.GtkAdjustment() - hscrollbar = gtk.GtkHScrollbar(hadjust) + hadjust = gtk.Adjustment() + hscrollbar = gtk.HScrollbar(hadjust) hscrollbar.show() table.attach(hscrollbar, 0, 1, 1, 2, EXPAND|FILL, 0) - vadjust = gtk.GtkAdjustment() - vscrollbar = gtk.GtkVScrollbar(vadjust) + vadjust = gtk.Adjustment() + vscrollbar = gtk.VScrollbar(vadjust) vscrollbar.show() table.attach(vscrollbar, 1, 2, 0, 1, 0, EXPAND|FILL) - self.listbox = gtk.GtkCTree(2, titles = (_("Module"), _("Filename"))) + self.listbox = gtk.CTree(2, titles = (_("Module"), _("Filename"))) self.listbox.set_hadjustment(hadjust) self.listbox.set_vadjustment(vadjust) self.listbox['width'] = 200 self.listbox['height'] = 400 table.attach(self.listbox, 0, 1, 0, 1, EXPAND|FILL, EXPAND|FILL) - button = gtk.GtkButton(_("Close")) + button = gtk.Button(_("Close")) button.connect("clicked", self.close) self.action_area.pack_start(button, expand = 0, fill = 0) - button = gtk.GtkButton(_("Update")) + button = gtk.Button(_("Update")) button.connect("clicked", self.update_list) self.action_area.pack_start(button, expand = 0, fill = 0) - button = gtk.GtkButton(_("Reload")) + button = gtk.Button(_("Reload")) button.connect("clicked", self.do_reload) self.action_area.pack_start(button, expand = 0, fill = 0) self.update_list() Index: Sketch/UI/skapp.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/skapp.py,v retrieving revision 1.20 diff -u -r1.20 skapp.py --- Sketch/UI/skapp.py 1 Aug 2002 13:43:44 -0000 1.20 +++ Sketch/UI/skapp.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -17,7 +17,7 @@ import os -import gtk, GDK +import gtk, gtk.keysyms import Sketch import Sketch.Editor @@ -33,9 +33,9 @@ main_menu = Sketch.Editor.BuildMenuTree('', Sketch.Editor.standard_menu) keymap = Sketch.Editor.Keymap(Sketch.Editor.standard_keystrokes, - special_keys = GDK.__dict__) + special_keys = gtk.keysyms.__dict__) text_keymap = Sketch.Editor.Keymap(Sketch.Editor.text_keystrokes, - special_keys = GDK.__dict__) + special_keys = gtk.keysyms.__dict__) # XXX the keymaps should be maintained by the Editor sub-package from mainwindow import SketchMainWindow @@ -176,7 +176,7 @@ self.menu = None self.accelgroup = None self.file_dialog = None - self.tooltips = gtk.GtkTooltips() + self.tooltips = gtk.Tooltips() self.context = AppContext(self) self.SetTool('SelectionTool') @@ -221,7 +221,7 @@ def load_file_dialog(self, *args): if self.file_dialog is None: - self.file_dialog = gtk.GtkFileSelection(_("Open File")) + self.file_dialog = gtk.FileSelection(_("Open File")) self.file_dialog.ok_button.connect("clicked", self.do_load_file) self.file_dialog.cancel_button.connect("clicked", self.file_dialog.hide) @@ -351,7 +351,7 @@ def Menu(self, window): self.context.SetWindow(window) if self.accelgroup is None: - self.accelgroup = gtk.GtkAccelGroup() + self.accelgroup = gtk.AccelGroup() if self.menu is None: self.menu = make_menu(main_menu, keymap, self.context, accel = self.accelgroup) Index: Sketch/UI/skpanel.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/skpanel.py,v retrieving revision 1.5 diff -u -r1.5 skpanel.py --- Sketch/UI/skpanel.py 7 Dec 2001 21:43:47 -0000 1.5 +++ Sketch/UI/skpanel.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1999, 2000, 2001 by Bernhard Herzog +# Copyright (C) 1999, 2000, 2001, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -20,14 +20,14 @@ import Sketch -class SketchPanel(gtk.GtkDialog): +class SketchPanel(gtk.Dialog): # if true, there can be multiple panels of this class, otherwise # only one. multiple = 0 def __init__(self, context, title): - gtk.GtkDialog.__init__(self) + gtk.Dialog.__init__(self) self.context = context self.set_title(title) self.build_window() Index: Sketch/UI/skpixmaps.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/skpixmaps.py,v retrieving revision 1.5 diff -u -r1.5 skpixmaps.py --- Sketch/UI/skpixmaps.py 13 Jul 2001 20:23:47 -0000 1.5 +++ Sketch/UI/skpixmaps.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999, 2000, 2001 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -39,7 +39,7 @@ x_hot, y_hot = image.info["hot_spot"] else: x_hot = y_hot = None - bitmap = gtk.create_bitmap_from_data(window, data, width, height) + bitmap = gtk.gdk.bitmap_create_from_data(window, data, width, height) return bitmap, x_hot, y_hot _bitmap_names = ['TurnTL', 'TurnTR', 'TurnBL', 'TurnBR', 'Center', @@ -48,7 +48,7 @@ class SketchBitmaps: def InitFromWidget(self, widget): - window = widget.get_window() + window = widget.window dir = config.pixmap_dir for name in _bitmap_names: file = os.path.join(dir, name) + '.xbm' @@ -77,7 +77,8 @@ dir = config.pixmap_dir for name in _pixmap_names: file = os.path.join(dir, name) + '.xpm' - setattr(self, name, gtk.create_pixmap_from_xpm(widget, None, file)) + setattr(self, name, + gtk.create_pixmap_from_xpm(widget.window, None, file)) pixmaps = SketchPixmaps() @@ -85,16 +86,16 @@ def init_cursors(widget): import cursors - window = widget.get_window() + window = widget.window cmap = widget.get_colormap() - fg = cmap.alloc('black') - bg = cmap.alloc('white') + fg = cmap.alloc_color('black') + bg = cmap.alloc_color('white') dir = config.pixmap_dir for name in _cursors: base = os.path.join(dir, name) bitmap, x_hot, y_hot = load_bitmap(window, base + '.xbm') mask = load_bitmap(window, base + '_mask.xbm')[0] - cursor = gtk.cursor_new_from_pixmap(bitmap, mask, fg, bg, x_hot, y_hot) + cursor = gtk.gdk.Cursor(bitmap, mask, fg, bg, x_hot, y_hot) setattr(cursors, name, cursor) Index: Sketch/UI/toolbox.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/toolbox.py,v retrieving revision 1.18 diff -u -r1.18 toolbox.py --- Sketch/UI/toolbox.py 1 Aug 2002 13:43:44 -0000 1.18 +++ Sketch/UI/toolbox.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999, 2000, 2002 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -18,7 +18,7 @@ import os, string import urlparse -import gtk, GDK +import gtk, gtk.gdk from Sketch import _ from Sketch.Base import Publisher @@ -48,25 +48,25 @@ 'CreateEllipse', 'CreateCurve', 'TextTool'] -class ToolButton(Publisher, gtk.GtkToggleButton): +class ToolButton(Publisher, gtk.ToggleButton): def __init__(self, toolname): - gtk.GtkToggleButton.__init__(self) + gtk.ToggleButton.__init__(self) self.toolname = toolname self.clicked_id = self.connect('clicked', self.issue_command) self.connect('button_press_event', self.button_press) def ToolChanged(self, tool): - self.signal_handler_block(self.clicked_id) + self.handler_block(self.clicked_id) self.set_active(self.toolname == tool) - self.signal_handler_unblock(self.clicked_id) + self.handler_unblock(self.clicked_id) def issue_command(self, widget): self.issue(COMMAND) self.ToolChanged(self.toolname) def button_press(self, widget, event): - if event.type == GDK._2BUTTON_PRESS: + if event.type == gtk.gdk._2BUTTON_PRESS: self.issue(OPTIONS) @@ -85,7 +85,7 @@ self.application.Exit() def build_window(self): - self.window = gtk.GtkWindow() + self.window = gtk.Window() self.window.realize() import skpixmaps skpixmaps.init_from_widget(self.window) @@ -94,17 +94,17 @@ self.window.connect("destroy", self.close) self.window.drag_dest_set(gtk.DEST_DEFAULT_ALL, dnd_targets, - GDK.ACTION_COPY | GDK.ACTION_MOVE) + gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE) self.window.connect('drag_data_received', self.dnd_drop) - self.vbox = gtk.GtkVBox() + self.vbox = gtk.VBox() self.window.add(self.vbox) - self.menubar = gtk.GtkMenuBar() + self.menubar = gtk.MenuBar() self.menubar.set_name('menubar') self.vbox.pack_start(self.menubar, expand = 0) - self.table = gtk.GtkTable(3, 3) + self.table = gtk.Table(3, 3) self.vbox.pack_start(self.table) dirname = os.path.split(__file__)[0] @@ -116,9 +116,9 @@ button = ToolButton(toolname) button.Subscribe(COMMAND, self.context.SetTool, toolname) button.Subscribe(OPTIONS, self.show_tool_options) - pixmap, mask = getattr(pixmaps, tool.icon) - pixmap = gtk.GtkPixmap(pixmap, mask) - button.add(pixmap) + image = gtk.Image() + image.set_from_pixmap(*getattr(pixmaps, tool.icon)) + button.add(image) button.set_mode(0) self.context.Subscribe(TOOL, button.ToolChanged) button.ToolChanged(self.context.tool) @@ -131,11 +131,11 @@ def build_menu(self): menubar = self.menubar - menuitem = gtk.GtkMenuItem(_("File")) + menuitem = gtk.MenuItem(_("File")) menuitem.set_submenu(self.build_file_menu()) menubar.append(menuitem) menuitem.show() - menuitem = gtk.GtkMenuItem(_("Xtns")) + menuitem = gtk.MenuItem(_("Xtns")) menuitem.set_submenu(self.build_win_menu()) menubar.append(menuitem) menuitem.show() @@ -168,7 +168,7 @@ # # This is a hack to get this effect. Maybe there should be a # smart separator class. - items = self.file_menu.children() + items = self.file_menu.get_children() if not value: items[-2].hide() else: @@ -220,17 +220,16 @@ class FreeHandOptions(OptionPanel): def __init__(self): - self.widget = box = gtk.GtkHBox() + self.widget = box = gtk.HBox() - label = gtk.GtkLabel(_("Tolerance")) + label = gtk.Label(_("Tolerance")) box.pack_start(label) label.show() value = Sketch.Editor.preferences.freehand_accuracy - self.accuracy = gtk.GtkAdjustment(value = value, - lower = 0, upper = 100, - step_incr = 1) - entry = gtk.GtkSpinButton(adj = self.accuracy, digits = 1) + self.accuracy = gtk.Adjustment(value = value, lower = 0, upper = 100, + step_incr = 1) + entry = gtk.SpinButton(adj = self.accuracy, digits = 1) box.pack_start(entry) entry.show() self.accuracy.connect("value_changed", self.entry_changed) @@ -241,7 +240,7 @@ class EmptyOptions(OptionPanel): def __init__(self): - self.widget = gtk.GtkLabel(_("This tool has no options")) + self.widget = gtk.Label(_("This tool has no options")) self.widget.set_padding(4, 4) class ToolOptions(SketchPanel): @@ -259,12 +258,12 @@ def build_window(self): vbox = self.vbox - self.label = gtk.GtkLabel("") + self.label = gtk.Label("") self.label.set_padding(2, 3) self.label.show() self.vbox.pack_start(self.label) - sep = gtk.GtkHSeparator() + sep = gtk.HSeparator() sep.show() self.vbox.pack_start(sep) @@ -274,7 +273,7 @@ self.current_panel = self.default_panel # buttons - button = gtk.GtkButton(_("Close")) + button = gtk.Button(_("Close")) button.connect("clicked", self.close) self.action_area.pack_start(button) button.show() Index: Sketch/UI/tree.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/tree.py,v retrieving revision 1.11 diff -u -r1.11 tree.py --- Sketch/UI/tree.py 9 Nov 2001 00:52:52 -0000 1.11 +++ Sketch/UI/tree.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1999, 2000, 2001 by Bernhard Herzog +# Copyright (C) 1999, 2000, 2001, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -29,11 +29,11 @@ from skpanel import SketchPanel -class SketchTree(gtk.GtkCTree): +class SketchTree(gtk.CTree): def __init__(self, context): self.context = context - gtk.GtkCTree.__init__(self) + gtk.CTree.__init__(self) self.object_to_node = {} self.context.Subscribe(const.CHANGED, self.context_changed) self.context.Subscribe(const.OBJECT_CHANGED, self.object_changed) @@ -197,18 +197,18 @@ vbox = self.vbox # tree - table = gtk.GtkTable(2, 2) + table = gtk.Table(2, 2) table.show() vbox.pack_start(table) - hadjust = gtk.GtkAdjustment() - hscrollbar = gtk.GtkHScrollbar(hadjust) + hadjust = gtk.Adjustment() + hscrollbar = gtk.HScrollbar(hadjust) #hscrollbar.set_update_policy(UPDATE_DELAYED) hscrollbar.show() table.attach(hscrollbar, 0, 1, 1, 2, EXPAND|FILL, 0) - vadjust = gtk.GtkAdjustment() - vscrollbar = gtk.GtkVScrollbar(vadjust) + vadjust = gtk.Adjustment() + vscrollbar = gtk.VScrollbar(vadjust) #vscrollbar.set_update_policy(UPDATE_DELAYED) vscrollbar.show() table.attach(vscrollbar, 1, 2, 0, 1, 0, EXPAND|FILL) @@ -222,7 +222,7 @@ table.attach(self.tree, 0, 1, 0, 1, EXPAND|FILL, EXPAND|FILL) # buttons - button = gtk.GtkButton(_("Close")) + button = gtk.Button(_("Close")) #button.set_flags(CAN_DEFAULT) button.connect("clicked", self.destroy) self.action_area.pack_start(button) Index: Sketch/UI/view.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/view.py,v retrieving revision 1.7 diff -u -r1.7 view.py --- Sketch/UI/view.py 16 Aug 2000 21:26:18 -0000 1.7 +++ Sketch/UI/view.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999, 2000 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -16,7 +16,7 @@ # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import sys -import gtk, _gtk +import gtk from Sketch import Rect, EmptyRect, IntersectRects, _skgtk from Sketch.Base import SketchInternalError, QueueingPublisher @@ -66,9 +66,6 @@ self.init_transactions() self.SetDocument(document) - def size(self, w, h): - _gtk.gtk_drawing_area_size(self._o, w, h) - def bind_events(self): SketchDrawingArea.bind_events(self) self.connect("destroy", self.destroy_event) @@ -243,10 +240,8 @@ if region: x, y, w, h = region.ClipBox() else: - window = self.get_window() x = y = 0 - w = window.width - h = window.height + w, h = self.window_size() p1 = self.WinToDoc(x - 1, y - 1) p2 = self.WinToDoc(x + w + 1, y + h + 1) rect = Rect(p1, p2) @@ -263,13 +258,12 @@ self.gc.PopClip() def redraw_libart(self, region): - window = self.get_window() + window = self.window if region: x, y, w, h = region.ClipBox() else: x = y = 0 - w = window.width - h = window.height + w, h = self.window_size() p1 = self.WinToDoc(x - 1, y - 1) p2 = self.WinToDoc(x + w + 1, y + h + 1) rect = Rect(p1, p2) @@ -313,9 +307,8 @@ def move_window_contents(self, offx, offy): # implement the method needed by Viewport.set_origin - w = self.get_window() - width = w.width - height = w.height + w = self.window + width, height = self.window_size() if abs(offx) < width and abs(offy) < height: gc = self.gc.gc if gc is not None: Index: Sketch/UI/viewport.py =================================================================== RCS file: /cvs/gnome/sketch/Sketch/UI/viewport.py,v retrieving revision 1.5 diff -u -r1.5 viewport.py --- Sketch/UI/viewport.py 27 Apr 2000 00:12:49 -0000 1.5 +++ Sketch/UI/viewport.py 14 Jan 2003 20:05:32 -0000 @@ -1,5 +1,5 @@ # Sketch - A Python-based interactive drawing program -# Copyright (C) 1997, 1998, 1999, 2000 by Bernhard Herzog +# Copyright (C) 1997, 1998, 1999, 2000, 2003 by Bernhard Herzog # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public @@ -21,7 +21,7 @@ def modify_adjustment(adjustment, **kw): - _skgtk.set_adjustment(adjustment._o, kw) + _skgtk.set_adjustment(adjustment, kw) adjustment.changed() class Viewport: @@ -46,13 +46,15 @@ self.init_viewport_ring() - class window: - width = 10 - height = 10 - self.window = window - - self.hbar = self.vbar = self.hruler = self.vruler = None + self.hruler = self.vruler = None + def window_size(self): + """Return the size of the window as a tuple (width, height)""" + if self.window is not None: + width, height = self.window.get_size() + else: + width = height = 10 + return width, height def init_resolution(self, resolution): # XXX gtk @@ -126,11 +128,11 @@ # special case: clear a guide line p, horizontal = rect x, y = self.DocToWin(p) - window = self.get_window() + width, height = self.window_size() if horizontal: - self.clear_rects.append((0, y, window.width, 1)) + self.clear_rects.append((0, y, width, 1)) else: - self.clear_rects.append((x, 0, 1, window.height)) + self.clear_rects.append((x, 0, 1, height)) self.UpdateWhenIdle() def clear_window(self, update = 1): @@ -150,7 +152,7 @@ for rect in self.clear_rects: apply(union, rect) else: - _skgtk.clear_area(self.get_window(), 0, 0, 0, 0) + _skgtk.clear_area(self.window, 0, 0, 0, 0) region = None self.clear_entire_window = 0 self.clear_rects = [] @@ -200,8 +202,9 @@ # set origin so that center (in doc-coords) is in the center of the # widget cx, cy = self.DocToWin(center) - self.set_origin(self.virtual_x + cx - self.window.width / 2, - self.virtual_y + cy - self.window.height / 2, + width, height = self.window_size() + self.set_origin(self.virtual_x + cx - width / 2, + self.virtual_y + cy - height / 2, move_contents = move_contents) def SetScale(self, scale, do_center = 1): @@ -218,8 +221,9 @@ self.virtual_width = width self.virtual_height = height if do_center: - cx = self.window.width / 2 - cy = self.window.height / 2 + window_width, window_height = self.window_size() + cx = window_width / 2 + cy = window_height / 2 center = self.WinToDoc(cx, cy) self.compute_win_to_doc() @@ -250,14 +254,16 @@ # centered and fills the window. If out is true, scale and move # so that the rectangle currently filling the viewport fits into # rect. + if self.window is None: + return + epsilon = 1e-10 rw = rect.right - rect.left rh = rect.top - rect.bottom if abs(rw) < epsilon or abs(rh) < epsilon: return - width = self.window.width - height = self.window.height + width, height = self.window_size() scalex = width / rw scaley = height / rh @@ -318,39 +324,40 @@ step = 1 if adj.upper != upper or adj.lower != lower \ or adj.page_size != page_size: - modify_adjustment(adj, lower = lower, upper = upper, - page_size = page_size, - page_increment = page_increment, - step_increment = step) + #modify_adjustment(adj, lower = lower, upper = upper, + # page_size = page_size, + # page_increment = page_increment, + # step_increment = step) + adj.set_all(value, lower, upper, step, page_increment, page_size) if adj.value != value: adj.set_value(value) def update_scrollbars(self): - window = self.get_window() - if window is None: + if self.window is None: return + width, height = self.window_size() overlap = 20 step = 20 if self.hadjust is not None: self.update_adjustment(self.hadjust, self.virtual_width, - window.width, overlap, step, + width, overlap, step, self.virtual_x) if self.vadjust is not None: self.update_adjustment(self.vadjust, self.virtual_height, - window.height, overlap, step, + height, overlap, step, self.virtual_y) start = self.WinToDoc(0, 0) - end = self.WinToDoc(window.width, window.height) + end = self.WinToDoc(width, height) if self.hruler is not None: - self.hruler["lower"] = start.x - self.hruler["upper"] = end.x - self.hruler["max_size"] = 100.0 + self.hruler.set_property("lower", start.x) + self.hruler.set_property("upper", end.x) + self.hruler.set_property("max_size", 100.0) if self.vruler is not None: - self.vruler["lower"] = start.y - self.vruler["upper"] = end.y - self.vruler["max_size"] = 100.0 + self.vruler.set_property("lower", start.y) + self.vruler.set_property("upper", end.y) + self.vruler.set_property("max_size", 100.0) #