Pileus Git - ~andy/gtk/blob - gdk/gdkdraw.c

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 #include <X11/Xlib.h>
  20 #include <X11/Xos.h>
  21 #include "gdk.h"
  22 #include "gdkprivate.h"
  23
  24
  25 void
  26 gdk_draw_point (GdkDrawable *drawable,
  27                 GdkGC       *gc,
  28                 gint         x,
  29                 gint         y)
  30 {
  31   GdkWindowPrivate *drawable_private;
  32   GdkGCPrivate *gc_private;
  33
  34   g_return_if_fail (drawable != NULL);
  35   g_return_if_fail (gc != NULL);
  36
  37   drawable_private = (GdkWindowPrivate*) drawable;
  38   if (drawable_private->destroyed)
  39     return;
  40   gc_private = (GdkGCPrivate*) gc;
  41
  42   XDrawPoint (drawable_private->xdisplay, drawable_private->xwindow,
  43               gc_private->xgc, x, y);
  44 }
  45
  46 void
  47 gdk_draw_line (GdkDrawable *drawable,
  48                GdkGC       *gc,
  49                gint         x1,
  50                gint         y1,
  51                gint         x2,
  52                gint         y2)
  53 {
  54   GdkWindowPrivate *drawable_private;
  55   GdkGCPrivate *gc_private;
  56
  57   g_return_if_fail (drawable != NULL);
  58   g_return_if_fail (gc != NULL);
  59
  60   drawable_private = (GdkWindowPrivate*) drawable;
  61   if (drawable_private->destroyed)
  62     return;
  63   gc_private = (GdkGCPrivate*) gc;
  64
  65   XDrawLine (drawable_private->xdisplay, drawable_private->xwindow,
  66              gc_private->xgc, x1, y1, x2, y2);
  67 }
  68
  69 void
  70 gdk_draw_rectangle (GdkDrawable *drawable,
  71                     GdkGC       *gc,
  72                     gint         filled,
  73                     gint         x,
  74                     gint         y,
  75                     gint         width,
  76                     gint         height)
  77 {
  78   GdkWindowPrivate *drawable_private;
  79   GdkGCPrivate *gc_private;
  80
  81   g_return_if_fail (drawable != NULL);
  82   g_return_if_fail (gc != NULL);
  83
  84   drawable_private = (GdkWindowPrivate*) drawable;
  85   if (drawable_private->destroyed)
  86     return;
  87   gc_private = (GdkGCPrivate*) gc;
  88
  89   if (width == -1)
  90     width = drawable_private->width;
  91   if (height == -1)
  92     height = drawable_private->height;
  93
  94   if (filled)
  95     XFillRectangle (drawable_private->xdisplay, drawable_private->xwindow,
  96                     gc_private->xgc, x, y, width, height);
  97   else
  98     XDrawRectangle (drawable_private->xdisplay, drawable_private->xwindow,
  99                     gc_private->xgc, x, y, width, height);
 100 }
 101
 102 void
 103 gdk_draw_arc (GdkDrawable *drawable,
 104               GdkGC       *gc,
 105               gint         filled,
 106               gint         x,
 107               gint         y,
 108               gint         width,
 109               gint         height,
 110               gint         angle1,
 111               gint         angle2)
 112 {
 113   GdkWindowPrivate *drawable_private;
 114   GdkGCPrivate *gc_private;
 115
 116   g_return_if_fail (drawable != NULL);
 117   g_return_if_fail (gc != NULL);
 118
 119   drawable_private = (GdkWindowPrivate*) drawable;
 120   if (drawable_private->destroyed)
 121     return;
 122   gc_private = (GdkGCPrivate*) gc;
 123
 124   if (width == -1)
 125     width = drawable_private->width;
 126   if (height == -1)
 127     height = drawable_private->height;
 128
 129   if (filled)
 130     XFillArc (drawable_private->xdisplay, drawable_private->xwindow,
 131               gc_private->xgc, x, y, width, height, angle1, angle2);
 132   else
 133     XDrawArc (drawable_private->xdisplay, drawable_private->xwindow,
 134               gc_private->xgc, x, y, width, height, angle1, angle2);
 135 }
 136
 137 void
 138 gdk_draw_polygon (GdkDrawable *drawable,
 139                   GdkGC       *gc,
 140                   gint         filled,
 141                   GdkPoint    *points,
 142                   gint         npoints)
 143 {
 144   GdkWindowPrivate *drawable_private;
 145   GdkGCPrivate *gc_private;
 146   GdkPoint *local_points = points;
 147   gint local_npoints = npoints;
 148   gint local_alloc = 0;
 149
 150   g_return_if_fail (drawable != NULL);
 151   g_return_if_fail (gc != NULL);
 152
 153   drawable_private = (GdkWindowPrivate*) drawable;
 154   if (drawable_private->destroyed)
 155     return;
 156   gc_private = (GdkGCPrivate*) gc;
 157
 158   if (filled)
 159     {
 160       XFillPolygon (drawable_private->xdisplay, drawable_private->xwindow,
 161                     gc_private->xgc, (XPoint*) points, npoints, Complex, CoordModeOrigin);
 162     }
 163   else
 164     {
 165       if ((points[0].x != points[npoints-1].x) ||
 166         (points[0].y != points[npoints-1].y))
 167         {
 168           local_alloc = 1;
 169           ++local_npoints;
 170           local_points = (GdkPoint*) g_malloc (local_npoints * sizeof(GdkPoint));
 171           memcpy (local_points, points, npoints * sizeof(GdkPoint));
 172           local_points[npoints].x = points[0].x;
 173           local_points[npoints].y = points[0].y;
 174       }
 175
 176       XDrawLines (drawable_private->xdisplay, drawable_private->xwindow,
 177                  gc_private->xgc,
 178                  (XPoint*) local_points, local_npoints,
 179                  CoordModeOrigin);
 180
 181        if (local_alloc)
 182        g_free (local_points);
 183     }
 184 }
 185
 186 /* gdk_draw_string
 187  *
 188  * Modified by Li-Da Lho to draw 16 bits and Multibyte strings
 189  *
 190  * Interface changed: add "GdkFont *font" to specify font or fontset explicitely
 191  */
 192 void
 193 gdk_draw_string (GdkDrawable *drawable,
 194                  GdkFont     *font,
 195                  GdkGC       *gc,
 196                  gint         x,
 197                  gint         y,
 198                  const gchar *string)
 199 {
 200   GdkWindowPrivate *drawable_private;
 201   GdkFontPrivate *font_private;
 202   GdkGCPrivate *gc_private;
 203
 204   g_return_if_fail (drawable != NULL);
 205   g_return_if_fail (font != NULL);
 206   g_return_if_fail (gc != NULL);
 207   g_return_if_fail (string != NULL);
 208
 209   drawable_private = (GdkWindowPrivate*) drawable;
 210   if (drawable_private->destroyed)
 211     return;
 212   gc_private = (GdkGCPrivate*) gc;
 213   font_private = (GdkFontPrivate*) font;
 214
 215   if (font->type == GDK_FONT_FONT)
 216     {
 217       XFontStruct *xfont = (XFontStruct *) font_private->xfont;
 218       XSetFont(drawable_private->xdisplay, gc_private->xgc, xfont->fid);
 219       if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
 220         {
 221           XDrawString (drawable_private->xdisplay, drawable_private->xwindow,
 222                        gc_private->xgc, x, y, string, strlen (string));
 223         }
 224       else
 225         {
 226           XDrawString16 (drawable_private->xdisplay, drawable_private->xwindow,
 227                          gc_private->xgc, x, y, (XChar2b *) string,
 228                          strlen (string) / 2);
 229         }
 230     }
 231   else if (font->type == GDK_FONT_FONTSET)
 232     {
 233       XFontSet fontset = (XFontSet) font_private->xfont;
 234       XmbDrawString (drawable_private->xdisplay, drawable_private->xwindow,
 235                      fontset, gc_private->xgc, x, y, string, strlen (string));
 236     }
 237   else
 238     g_error("undefined font type\n");
 239 }
 240
 241 /* gdk_draw_text
 242  *
 243  * Modified by Li-Da Lho to draw 16 bits and Multibyte strings
 244  *
 245  * Interface changed: add "GdkFont *font" to specify font or fontset explicitely
 246  */
 247 void
 248 gdk_draw_text (GdkDrawable *drawable,
 249                GdkFont     *font,
 250                GdkGC       *gc,
 251                gint         x,
 252                gint         y,
 253                const gchar *text,
 254                gint         text_length)
 255 {
 256   GdkWindowPrivate *drawable_private;
 257   GdkFontPrivate *font_private;
 258   GdkGCPrivate *gc_private;
 259
 260   g_return_if_fail (drawable != NULL);
 261   g_return_if_fail (font != NULL);
 262   g_return_if_fail (gc != NULL);
 263   g_return_if_fail (text != NULL);
 264
 265   drawable_private = (GdkWindowPrivate*) drawable;
 266   if (drawable_private->destroyed)
 267     return;
 268   gc_private = (GdkGCPrivate*) gc;
 269   font_private = (GdkFontPrivate*) font;
 270
 271   if (font->type == GDK_FONT_FONT)
 272     {
 273       XFontStruct *xfont = (XFontStruct *) font_private->xfont;
 274       XSetFont(drawable_private->xdisplay, gc_private->xgc, xfont->fid);
 275       if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
 276         {
 277           XDrawString (drawable_private->xdisplay, drawable_private->xwindow,
 278                        gc_private->xgc, x, y, text, text_length);
 279         }
 280       else
 281         {
 282           XDrawString16 (drawable_private->xdisplay, drawable_private->xwindow,
 283                          gc_private->xgc, x, y, (XChar2b *) text, text_length / 2);
 284         }
 285     }
 286   else if (font->type == GDK_FONT_FONTSET)
 287     {
 288       XFontSet fontset = (XFontSet) font_private->xfont;
 289       XmbDrawString (drawable_private->xdisplay, drawable_private->xwindow,
 290                      fontset, gc_private->xgc, x, y, text, text_length);
 291     }
 292   else
 293     g_error("undefined font type\n");
 294 }
 295
 296 void
 297 gdk_draw_pixmap (GdkDrawable *drawable,
 298                  GdkGC       *gc,
 299                  GdkPixmap   *src,
 300                  gint         xsrc,
 301                  gint         ysrc,
 302                  gint         xdest,
 303                  gint         ydest,
 304                  gint         width,
 305                  gint         height)
 306 {
 307   GdkWindowPrivate *drawable_private;
 308   GdkWindowPrivate *src_private;
 309   GdkGCPrivate *gc_private;
 310
 311   g_return_if_fail (drawable != NULL);
 312   g_return_if_fail (src != NULL);
 313   g_return_if_fail (gc != NULL);
 314
 315   drawable_private = (GdkWindowPrivate*) drawable;
 316   src_private = (GdkWindowPrivate*) src;
 317   if (drawable_private->destroyed || src_private->destroyed)
 318     return;
 319   gc_private = (GdkGCPrivate*) gc;
 320
 321   if (width == -1)
 322     width = src_private->width;
 323   if (height == -1)
 324     height = src_private->height;
 325
 326   XCopyArea (drawable_private->xdisplay,
 327              src_private->xwindow,
 328              drawable_private->xwindow,
 329              gc_private->xgc,
 330              xsrc, ysrc,
 331              width, height,
 332              xdest, ydest);
 333 }
 334
 335 void
 336 gdk_draw_image (GdkDrawable *drawable,
 337                 GdkGC       *gc,
 338                 GdkImage    *image,
 339                 gint         xsrc,
 340                 gint         ysrc,
 341                 gint         xdest,
 342                 gint         ydest,
 343                 gint         width,
 344                 gint         height)
 345 {
 346   GdkImagePrivate *image_private;
 347
 348   g_return_if_fail (drawable != NULL);
 349   g_return_if_fail (image != NULL);
 350   g_return_if_fail (gc != NULL);
 351
 352   image_private = (GdkImagePrivate*) image;
 353
 354   g_return_if_fail (image_private->image_put != NULL);
 355
 356   if (width == -1)
 357     width = image->width;
 358   if (height == -1)
 359     height = image->height;
 360
 361   (* image_private->image_put) (drawable, gc, image, xsrc, ysrc,
 362                                 xdest, ydest, width, height);
 363 }
 364
 365 void
 366 gdk_draw_points (GdkDrawable *drawable,
 367                  GdkGC       *gc,
 368                  GdkPoint    *points,
 369                  gint         npoints)
 370 {
 371   GdkWindowPrivate *drawable_private;
 372   GdkGCPrivate *gc_private;
 373
 374   g_return_if_fail (drawable != NULL);
 375   g_return_if_fail ((points != NULL) && (npoints > 0));
 376   g_return_if_fail (gc != NULL);
 377
 378   drawable_private = (GdkWindowPrivate*) drawable;
 379   if (drawable_private->destroyed)
 380     return;
 381   gc_private = (GdkGCPrivate*) gc;
 382
 383   XDrawPoints (drawable_private->xdisplay,
 384                drawable_private->xwindow,
 385                gc_private->xgc,
 386                (XPoint *) points,
 387                npoints,
 388                CoordModeOrigin);
 389 }
 390
 391 void
 392 gdk_draw_segments (GdkDrawable *drawable,
 393                    GdkGC       *gc,
 394                    GdkSegment  *segs,
 395                    gint         nsegs)
 396 {
 397   GdkWindowPrivate *drawable_private;
 398   GdkGCPrivate *gc_private;
 399
 400   if (nsegs <= 0)
 401     return;
 402
 403   g_return_if_fail (drawable != NULL);
 404   g_return_if_fail (segs != NULL);
 405   g_return_if_fail (gc != NULL);
 406
 407   drawable_private = (GdkWindowPrivate*) drawable;
 408   if (drawable_private->destroyed)
 409     return;
 410   gc_private = (GdkGCPrivate*) gc;
 411
 412   XDrawSegments (drawable_private->xdisplay,
 413                  drawable_private->xwindow,
 414                  gc_private->xgc,
 415                  (XSegment *) segs,
 416                  nsegs);
 417 }
 418
 419 void
 420 gdk_draw_lines (GdkDrawable *drawable,
 421               GdkGC       *gc,
 422               GdkPoint    *points,
 423               gint         npoints)
 424 {
 425   GdkWindowPrivate *drawable_private;
 426   GdkGCPrivate *gc_private;
 427
 428   if (npoints <= 0)
 429     return;
 430
 431   g_return_if_fail (drawable != NULL);
 432   g_return_if_fail (points != NULL);
 433   g_return_if_fail (gc != NULL);
 434
 435   drawable_private = (GdkWindowPrivate*) drawable;
 436   gc_private = (GdkGCPrivate*) gc;
 437
 438   XDrawLines (drawable_private->xdisplay,
 439             drawable_private->xwindow,
 440             gc_private->xgc,
 441             (XPoint *) points,
 442             npoints,
 443             CoordModeOrigin);
 444 }