Pileus Git - ~andy/gtk/blob - gdk/directfb/gdkgc-directfb.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 Lesser 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  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser 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
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.
  23  */
  24
  25 /*
  26  * GTK+ DirectFB backend
  27  * Copyright (C) 2001-2002  convergence integrated media GmbH
  28  * Copyright (C) 2002-2004  convergence GmbH
  29  * Written by Denis Oliver Kropp <dok@convergence.de> and
  30  *            Sven Neumann <sven@convergence.de>
  31  */
  32
  33 #undef GDK_DISABLE_DEPRECATED
  34
  35 #include "config.h"
  36 #include "gdk.h"
  37
  38 #include <string.h>
  39
  40 #include "gdkdirectfb.h"
  41 #include "gdkprivate-directfb.h"
  42
  43 #include "gdkgc.h"
  44 #include "gdkfont.h"
  45 #include "gdkpixmap.h"
  46 #include "gdkregion-generic.h"
  47
  48 #include "gdkalias.h"
  49
  50 static void gdk_directfb_gc_get_values (GdkGC           *gc,
  51                                         GdkGCValues     *values);
  52 static void gdk_directfb_gc_set_values (GdkGC           *gc,
  53                                         GdkGCValues     *values,
  54                                         GdkGCValuesMask  values_mask);
  55 static void gdk_directfb_gc_set_dashes (GdkGC           *gc,
  56                                         gint             dash_offset,
  57                                         gint8            dash_list[],
  58                                         gint             n);
  59
  60 static void gdk_gc_directfb_class_init (GdkGCDirectFBClass *klass);
  61 static void gdk_gc_directfb_finalize   (GObject            *object);
  62
  63
  64 static gpointer parent_class = NULL;
  65
  66
  67 GType
  68 gdk_gc_directfb_get_type (void)
  69 {
  70   static GType object_type = 0;
  71
  72   if (!object_type)
  73     {
  74       static const GTypeInfo object_info =
  75       {
  76         sizeof (GdkGCDirectFBClass),
  77         (GBaseInitFunc) NULL,
  78         (GBaseFinalizeFunc) NULL,
  79         (GClassInitFunc) gdk_gc_directfb_class_init,
  80         NULL,           /* class_finalize */
  81         NULL,           /* class_data */
  82         sizeof (GdkGCDirectFB),
  83         0,              /* n_preallocs */
  84         (GInstanceInitFunc) NULL,
  85       };
  86
  87       object_type = g_type_register_static (GDK_TYPE_GC,
  88                                             "GdkGCDirectFB",
  89                                             &object_info, 0);
  90     }
  91
  92   return object_type;
  93 }
  94
  95 static void
  96 gdk_gc_directfb_class_init (GdkGCDirectFBClass *klass)
  97 {
  98   GObjectClass *object_class = G_OBJECT_CLASS (klass);
  99   GdkGCClass   *gc_class     = GDK_GC_CLASS (klass);
 100
 101   parent_class = g_type_class_peek_parent (klass);
 102
 103   object_class->finalize = gdk_gc_directfb_finalize;
 104
 105   gc_class->get_values = gdk_directfb_gc_get_values;
 106   gc_class->set_values = gdk_directfb_gc_set_values;
 107   gc_class->set_dashes = gdk_directfb_gc_set_dashes;
 108 }
 109
 110 static void
 111 gdk_gc_directfb_finalize (GObject *object)
 112 {
 113   GdkGC         *gc      = GDK_GC (object);
 114   GdkGCDirectFB *private = GDK_GC_DIRECTFB (gc);
 115
 116   if (private->clip_region.numRects)
 117     temp_region_deinit (&private->clip_region);
 118   if (private->values.clip_mask)
 119     g_object_unref (private->values.clip_mask);
 120   if (private->values.stipple)
 121     g_object_unref (private->values.stipple);
 122   if (private->values.tile)
 123     g_object_unref (private->values.tile);
 124
 125   if (G_OBJECT_CLASS (parent_class)->finalize)
 126     G_OBJECT_CLASS (parent_class)->finalize (object);
 127 }
 128
 129 GdkGC*
 130 _gdk_directfb_gc_new (GdkDrawable     *drawable,
 131                       GdkGCValues     *values,
 132                       GdkGCValuesMask  values_mask)
 133 {
 134   GdkGC         *gc;
 135   GdkGCDirectFB *private;
 136
 137   g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_DIRECTFB (drawable), NULL);
 138
 139   gc = GDK_GC (g_object_new (gdk_gc_directfb_get_type (), NULL));
 140
 141   _gdk_gc_init (gc, drawable, values, values_mask);
 142
 143   private = GDK_GC_DIRECTFB (gc);
 144 #if 0
 145   private->values.background.pixel = 0;
 146   private->values.background.red   =
 147   private->values.background.green =
 148   private->values.background.blue  = 0;
 149
 150   private->values.foreground.pixel = 0;
 151   private->values.foreground.red   =
 152   private->values.foreground.green =
 153   private->values.foreground.blue  = 0;
 154 #endif
 155
 156   private->values.cap_style = GDK_CAP_BUTT;
 157
 158   gdk_directfb_gc_set_values (gc, values, values_mask);
 159
 160   return gc;
 161 }
 162
 163 static void
 164 gdk_directfb_gc_get_values (GdkGC       *gc,
 165                             GdkGCValues *values)
 166 {
 167   *values = GDK_GC_DIRECTFB (gc)->values;
 168 }
 169
 170 #if 0
 171 void
 172 _gdk_windowing_gc_get_foreground (GdkGC    *gc,
 173                                   GdkColor *color)
 174 {
 175   GdkGCDirectFB *private;
 176   private = GDK_GC_DIRECTFB (gc);
 177   *color =private->values.foreground;
 178
 179
 180 }
 181 #endif
 182
 183 static void
 184 gdk_directfb_gc_set_values (GdkGC           *gc,
 185                             GdkGCValues     *values,
 186                             GdkGCValuesMask  values_mask)
 187 {
 188   GdkGCDirectFB *private = GDK_GC_DIRECTFB (gc);
 189
 190   if (values_mask & GDK_GC_FOREGROUND)
 191     {
 192       private->values.foreground = values->foreground;
 193       private->values_mask |= GDK_GC_FOREGROUND;
 194     }
 195
 196   if (values_mask & GDK_GC_BACKGROUND)
 197     {
 198       private->values.background = values->background;
 199       private->values_mask |= GDK_GC_BACKGROUND;
 200     }
 201
 202   if (values_mask & GDK_GC_FONT)
 203     {
 204       GdkFont *oldf = private->values.font;
 205
 206       private->values.font = gdk_font_ref (values->font);
 207       private->values_mask |= GDK_GC_FONT;
 208
 209       if (oldf)
 210         gdk_font_unref (oldf);
 211     }
 212
 213   if (values_mask & GDK_GC_FUNCTION)
 214     {
 215       private->values.function = values->function;
 216       private->values_mask |= GDK_GC_FUNCTION;
 217     }
 218
 219   if (values_mask & GDK_GC_FILL)
 220     {
 221       private->values.fill = values->fill;
 222       private->values_mask |= GDK_GC_FILL;
 223     }
 224
 225   if (values_mask & GDK_GC_TILE)
 226     {
 227       GdkPixmap *oldpm = private->values.tile;
 228
 229       if (values->tile)
 230         g_assert (GDK_PIXMAP_OBJECT (values->tile)->depth > 1);
 231
 232       private->values.tile = values->tile ? g_object_ref (values->tile) : NULL;
 233       private->values_mask |= GDK_GC_TILE;
 234
 235       if (oldpm)
 236         g_object_unref (oldpm);
 237     }
 238
 239   if (values_mask & GDK_GC_STIPPLE)
 240     {
 241       GdkPixmap *oldpm = private->values.stipple;
 242
 243       if (values->stipple)
 244         g_assert (GDK_PIXMAP_OBJECT (values->stipple)->depth == 1);
 245
 246       private->values.stipple = (values->stipple ?
 247                                  g_object_ref (values->stipple) : NULL);
 248       private->values_mask |= GDK_GC_STIPPLE;
 249
 250       if (oldpm)
 251         g_object_unref (oldpm);
 252     }
 253
 254   if (values_mask & GDK_GC_CLIP_MASK)
 255     {
 256       GdkPixmap *oldpm = private->values.clip_mask;
 257
 258       private->values.clip_mask = (values->clip_mask ?
 259                                    g_object_ref (values->clip_mask) : NULL);
 260       private->values_mask |= GDK_GC_CLIP_MASK;
 261
 262       if (oldpm)
 263         g_object_unref (oldpm);
 264
 265       temp_region_reset (&private->clip_region);
 266     }
 267
 268   if (values_mask & GDK_GC_SUBWINDOW)
 269     {
 270       private->values.subwindow_mode = values->subwindow_mode;
 271       private->values_mask |= GDK_GC_SUBWINDOW;
 272     }
 273
 274   if (values_mask & GDK_GC_TS_X_ORIGIN)
 275     {
 276       private->values.ts_x_origin = values->ts_x_origin;
 277       private->values_mask |= GDK_GC_TS_X_ORIGIN;
 278     }
 279
 280   if (values_mask & GDK_GC_TS_Y_ORIGIN)
 281     {
 282       private->values.ts_y_origin = values->ts_y_origin;
 283       private->values_mask |= GDK_GC_TS_Y_ORIGIN;
 284     }
 285
 286   if (values_mask & GDK_GC_CLIP_X_ORIGIN)
 287     {
 288       private->values.clip_x_origin = GDK_GC (gc)->clip_x_origin = values->clip_x_origin;
 289       private->values_mask |= GDK_GC_CLIP_X_ORIGIN;
 290     }
 291
 292   if (values_mask & GDK_GC_CLIP_Y_ORIGIN)
 293     {
 294       private->values.clip_y_origin = GDK_GC (gc)->clip_y_origin = values->clip_y_origin;
 295       private->values_mask |= GDK_GC_CLIP_Y_ORIGIN;
 296     }
 297
 298   if (values_mask & GDK_GC_EXPOSURES)
 299     {
 300       private->values.graphics_exposures = values->graphics_exposures;
 301       private->values_mask |= GDK_GC_EXPOSURES;
 302     }
 303
 304   if (values_mask & GDK_GC_LINE_WIDTH)
 305     {
 306       private->values.line_width = values->line_width;
 307       private->values_mask |= GDK_GC_LINE_WIDTH;
 308     }
 309
 310   if (values_mask & GDK_GC_LINE_STYLE)
 311     {
 312       private->values.line_style = values->line_style;
 313       private->values_mask |= GDK_GC_LINE_STYLE;
 314     }
 315
 316   if (values_mask & GDK_GC_CAP_STYLE)
 317     {
 318       private->values.cap_style = values->cap_style;
 319       private->values_mask |= GDK_GC_CAP_STYLE;
 320     }
 321
 322   if (values_mask & GDK_GC_JOIN_STYLE)
 323     {
 324       private->values.join_style = values->join_style;
 325       private->values_mask |= GDK_GC_JOIN_STYLE;
 326     }
 327 }
 328
 329 static void
 330 gdk_directfb_gc_set_dashes (GdkGC *gc,
 331                             gint   dash_offset,
 332                             gint8  dash_list[],
 333                             gint   n)
 334 {
 335   g_warning ("gdk_directfb_gc_set_dashes not implemented");
 336 }
 337
 338 static void
 339 gc_unset_clip_mask (GdkGC *gc)
 340 {
 341   GdkGCDirectFB *data = GDK_GC_DIRECTFB (gc);
 342
 343   if (data->values.clip_mask)
 344     {
 345       g_object_unref (data->values.clip_mask);
 346       data->values.clip_mask = NULL;
 347       data->values_mask &= ~ GDK_GC_CLIP_MASK;
 348     }
 349 }
 350
 351
 352 void
 353 _gdk_windowing_gc_set_clip_region (GdkGC           *gc,
 354                                    const GdkRegion *region,
 355                                    gboolean         reset_origin)
 356 {
 357   GdkGCDirectFB *data;
 358
 359   g_return_if_fail (gc != NULL);
 360
 361   data = GDK_GC_DIRECTFB (gc);
 362
 363   if (region == &data->clip_region)
 364     return;
 365
 366   if (region)
 367     temp_region_init_copy (&data->clip_region, region);
 368   else
 369     temp_region_reset (&data->clip_region);
 370
 371   if (reset_origin)
 372     {
 373       gc->clip_x_origin = 0;
 374       gc->clip_y_origin = 0;
 375       data->values.clip_x_origin = 0;
 376       data->values.clip_y_origin = 0;
 377     }
 378
 379   gc_unset_clip_mask (gc);
 380 }
 381
 382 void
 383 _gdk_windowing_gc_copy (GdkGC *dst_gc,
 384              GdkGC *src_gc)
 385 {
 386   GdkGCDirectFB *dst_private;
 387
 388   g_return_if_fail (dst_gc != NULL);
 389   g_return_if_fail (src_gc != NULL);
 390
 391   dst_private = GDK_GC_DIRECTFB (dst_gc);
 392
 393   temp_region_reset(&dst_private->clip_region);
 394
 395   if (dst_private->values_mask & GDK_GC_FONT)
 396     gdk_font_unref (dst_private->values.font);
 397   if (dst_private->values_mask & GDK_GC_TILE)
 398     g_object_unref (dst_private->values.tile);
 399   if (dst_private->values_mask & GDK_GC_STIPPLE)
 400     g_object_unref (dst_private->values.stipple);
 401   if (dst_private->values_mask & GDK_GC_CLIP_MASK)
 402     g_object_unref (dst_private->values.clip_mask);
 403
 404   *dst_gc = *src_gc;
 405   if (dst_private->values_mask & GDK_GC_FONT)
 406     gdk_font_ref (dst_private->values.font);
 407   if (dst_private->values_mask & GDK_GC_TILE)
 408     g_object_ref (dst_private->values.tile);
 409   if (dst_private->values_mask & GDK_GC_STIPPLE)
 410     g_object_ref (dst_private->values.stipple);
 411   if (dst_private->values_mask & GDK_GC_CLIP_MASK)
 412     g_object_ref (dst_private->values.clip_mask);
 413 }
 414
 415 /**
 416  * gdk_gc_get_screen:
 417  * @gc: a #GdkGC.
 418  *
 419  * Gets the #GdkScreen for which @gc was created
 420  *
 421  * Returns: the #GdkScreen for @gc.
 422  *
 423  * Since: 2.2
 424  */
 425 GdkScreen *
 426 gdk_gc_get_screen (GdkGC *gc)
 427 {
 428   g_return_val_if_fail (GDK_IS_GC_DIRECTFB (gc), NULL);
 429
 430   return _gdk_screen;
 431 }
 432 #define __GDK_GC_X11_C__
 433 #include "gdkaliasdef.c"