Pileus Git - ~andy/gtk/blob - gdk/directfb/gdkdisplay-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.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include <config.h>
  28
  29 #include <glib.h>
  30 #include "gdk.h"
  31 #include "gdkdirectfb.h"
  32 #include "gdkprivate-directfb.h"
  33 #include "gdkscreen.h"
  34 #include "gdkdisplaymanager.h"
  35 #include "gdkintl.h"
  36 #include "gdkalias.h"
  37
  38
  39
  40 extern void _gdk_visual_init (void);
  41 extern void _gdk_events_init (void);
  42 extern void _gdk_input_init (void);
  43 extern void _gdk_dnd_init (void);
  44 extern void _gdk_windowing_window_init (void);
  45 extern void _gdk_windowing_image_init (void);
  46 extern void _gdk_directfb_keyboard_init      (void);
  47
  48 static gboolean   gdk_directfb_argb_font           = FALSE;
  49 static gint       gdk_directfb_glyph_surface_cache = 8;
  50 static gchar     *directfb_args;
  51
  52
  53 const GOptionEntry _gdk_windowing_args[] =
  54 {
  55   { "dfb",0,0,G_OPTION_ARG_STRING,&directfb_args,N_("directfb arg"),N_("sdl|system")},
  56   { "dfb-help",0,0,G_OPTION_ARG_NONE, NULL,NULL},
  57   { "disable-aa-fonts",0,0,G_OPTION_ARG_INT,&gdk_directfb_monochrome_fonts,NULL,NULL    },
  58   { "argb-font",0,0, G_OPTION_ARG_INT, &gdk_directfb_argb_font,NULL,NULL},
  59   { "transparent-unfocused",0,0, G_OPTION_ARG_INT, &gdk_directfb_apply_focus_opacity,NULL,NULL },
  60   { "glyph-surface-cache",0,0,G_OPTION_ARG_INT,&gdk_directfb_glyph_surface_cache,NULL,NULL },
  61   { "enable-color-keying",0,0,G_OPTION_ARG_INT,&gdk_directfb_enable_color_keying,NULL,NULL },
  62   { NULL}
  63 };
  64
  65 /**
  66   Main entry point for gdk in 2.6 args are parsed
  67 **/
  68 GdkDisplay * gdk_display_open (const gchar *display_name)
  69 {
  70
  71   if (_gdk_display) {
  72     return GDK_DISPLAY_OBJECT(_gdk_display); /* single display only */
  73   }
  74   DFBResult  ret;
  75   IDirectFB              *directfb;
  76   IDirectFBDisplayLayer  *layer;
  77   IDirectFBInputDevice   *keyboard;
  78
  79   int argc=0;
  80   char **argv=NULL;
  81
  82 #if 0  /* arg hack arg support broken*/
  83   if(directfb_args ) {
  84         argc=2;
  85         argv = (char **)g_malloc(sizeof(char *)*argc);
  86         argv[0] = "simple";
  87         argv[1] = "--dfb:system=SDL";
  88   }
  89 #endif
  90
  91   ret = DirectFBInit (&argc,&argv);
  92   if (ret != DFB_OK)
  93 {
  94       DirectFBError ("gdk_display_open: DirectFBInit", ret);
  95       return NULL;
  96     }
  97
  98     ret = DirectFBCreate (&directfb);
  99
 100   if (ret != DFB_OK)
 101     {
 102       DirectFBError ("gdk_display_open: DirectFBCreate", ret);
 103       return NULL;
 104     }
 105   _gdk_display = g_object_new(GDK_TYPE_DISPLAY_DFB,NULL);
 106   _gdk_display->directfb=directfb;
 107
 108   ret = directfb->GetDisplayLayer (directfb, DLID_PRIMARY, &layer);
 109   if (ret != DFB_OK)
 110     {
 111       DirectFBError ("gdk_display_open: GetDisplayLayer", ret);
 112       directfb->Release (directfb);
 113           directfb = NULL;
 114       return NULL;
 115     }
 116
 117
 118   ret=directfb->GetInputDevice (directfb, DIDID_KEYBOARD, &keyboard);
 119
 120   if (ret != DFB_OK){
 121       DirectFBError ("gdk_display_open: GetDisplayLayer", ret);
 122         return NULL;
 123   }
 124
 125   _gdk_display->layer=layer;
 126   _gdk_display->keyboard=keyboard;
 127
 128     _gdk_directfb_keyboard_init ();
 129
 130   _gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
 131
 132   _gdk_visual_init ();
 133
 134   gdk_screen_set_default_colormap (_gdk_screen,
 135                                    gdk_screen_get_system_colormap (_gdk_screen));
 136   _gdk_windowing_window_init ();
 137   _gdk_windowing_image_init ();
 138
 139   _gdk_input_init ();
 140   _gdk_dnd_init ();
 141
 142   _gdk_events_init ();
 143   layer->EnableCursor (layer, 1);
 144
 145   g_signal_emit_by_name (gdk_display_manager_get (),
 146                          "display_opened", _gdk_display);
 147
 148   return GDK_DISPLAY_OBJECT(_gdk_display);
 149 }
 150
 151 GType
 152 gdk_display_dfb_get_type (void)
 153 {
 154   static GType object_type = 0;
 155
 156   if (!object_type)
 157     {
 158       static const GTypeInfo object_info =
 159         {
 160           sizeof (GdkDisplayDFBClass),
 161           (GBaseInitFunc) NULL,
 162           (GBaseFinalizeFunc) NULL,
 163           (GClassInitFunc) NULL,
 164           NULL,                 /* class_finalize */
 165           NULL,                 /* class_data */
 166           sizeof (GdkDisplayDFB),
 167           0,                    /* n_preallocs */
 168           (GInstanceInitFunc) NULL,
 169         };
 170
 171       object_type = g_type_register_static (GDK_TYPE_DISPLAY,
 172                                             "GdkDisplayDFB",
 173                                             &object_info, 0);
 174     }
 175
 176   return object_type;
 177 }
 178
 179 IDirectFBSurface * gdk_display_dfb_create_surface (GdkDisplayDFB *display,int format,int width, int height) {
 180         DFBResult              ret;
 181         IDirectFBSurface      *temp;
 182         DFBSurfaceDescription  dsc;
 183         dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT;
 184         dsc.width       = width;
 185         dsc.height      = height;
 186         dsc.pixelformat = format;
 187         ret = display->directfb->CreateSurface (display->directfb, &dsc, &temp);
 188         if (ret)
 189         {
 190           DirectFBError ("gdk_display_dfb_create_surface ", ret);
 191           return NULL;
 192         }
 193         return temp;
 194
 195 }
 196
 197
 198
 199 void
 200 _gdk_windowing_set_default_display (GdkDisplay *display)
 201 {
 202         _gdk_display=GDK_DISPLAY_DFB(display);
 203 }
 204
 205 G_CONST_RETURN gchar *
 206 gdk_display_get_name (GdkDisplay *display)
 207 {
 208   return gdk_get_display_arg_name ();
 209 }
 210
 211 int
 212 gdk_display_get_n_screens (GdkDisplay *display)
 213 {
 214   return 1;
 215 }
 216
 217 GdkScreen *
 218 gdk_display_get_screen (GdkDisplay *display,
 219                         gint        screen_num)
 220 {
 221   return _gdk_screen;
 222 }
 223
 224 GdkScreen *
 225 gdk_display_get_default_screen (GdkDisplay *display)
 226 {
 227   return _gdk_screen;
 228 }
 229
 230 gboolean
 231 gdk_display_supports_selection_notification (GdkDisplay *display)
 232 {
 233         return FALSE;
 234 }
 235
 236 gboolean gdk_display_request_selection_notification  (GdkDisplay *display,
 237                                                       GdkAtom     selection)
 238
 239 {
 240
 241         g_warning("gdk_display_request_selection_notification Unimplemented function \n");
 242         return FALSE;
 243 }
 244
 245 gboolean
 246 gdk_display_supports_clipboard_persistence (GdkDisplay *display)
 247 {
 248         g_warning("gdk_display_supports_clipboard_persistence Unimplemented function \n");
 249         return FALSE;
 250 }
 251
 252 void
 253 gdk_display_store_clipboard (GdkDisplay *display,
 254                              GdkWindow  *clipboard_window,
 255                              guint32     time_,
 256                              GdkAtom    *targets,
 257                              gint        n_targets)
 258 {
 259
 260         g_warning("gdk_display_store_clipboard Unimplemented function \n");
 261
 262 }
 263
 264
 265 gboolean
 266 gdk_display_supports_shapes (GdkDisplay *display)
 267 {
 268        return FALSE;
 269 }
 270
 271
 272 gboolean
 273 gdk_display_supports_input_shapes (GdkDisplay *display)
 274 {
 275        return FALSE;
 276 }
 277
 278
 279 GdkWindow *gdk_display_get_default_group (GdkDisplay *display)
 280 {
 281   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 282   return  _gdk_parent_root;
 283 }
 284
 285
 286
 287
 288 static gboolean _gdk_directfb_pointer_implicit_grab = FALSE;
 289
 290 GdkGrabStatus
 291 gdk_directfb_pointer_grab (GdkWindow    *window,
 292                            gint          owner_events,
 293                            GdkEventMask  event_mask,
 294                            GdkWindow    *confine_to,
 295                            GdkCursor    *cursor,
 296                            guint32       time,
 297                            gboolean      implicit_grab)
 298 {
 299   GdkWindow             *toplevel;
 300   GdkWindowImplDirectFB *impl;
 301   if (_gdk_directfb_pointer_grab_window)
 302     {
 303       if (implicit_grab && !_gdk_directfb_pointer_implicit_grab)
 304         return GDK_GRAB_ALREADY_GRABBED;
 305
 306       gdk_pointer_ungrab (time);
 307     }
 308
 309   toplevel = gdk_directfb_window_find_toplevel (window);
 310   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (toplevel)->impl);
 311
 312   if (impl->window)
 313     {
 314       if (impl->window->GrabPointer (impl->window) == DFB_LOCKED)
 315         return GDK_GRAB_ALREADY_GRABBED;
 316     }
 317
 318   if (event_mask & GDK_BUTTON_MOTION_MASK)
 319     event_mask |= (GDK_BUTTON1_MOTION_MASK |
 320                    GDK_BUTTON2_MOTION_MASK |
 321                    GDK_BUTTON3_MOTION_MASK);
 322
 323   _gdk_directfb_pointer_implicit_grab     = implicit_grab;
 324   _gdk_directfb_pointer_grab_window       = g_object_ref (window);
 325   _gdk_directfb_pointer_grab_owner_events = owner_events;
 326
 327   _gdk_directfb_pointer_grab_confine      = (confine_to ?
 328                                              g_object_ref (confine_to) : NULL);
 329   _gdk_directfb_pointer_grab_events       = event_mask;
 330   _gdk_directfb_pointer_grab_cursor       = (cursor ?
 331                                              gdk_cursor_ref (cursor) : NULL);
 332
 333
 334   gdk_directfb_window_send_crossing_events (NULL,
 335                                             window,
 336                                             GDK_CROSSING_GRAB);
 337
 338   return GDK_GRAB_SUCCESS;
 339 }
 340
 341
 342
 343
 344 void
 345 gdk_directfb_pointer_ungrab (guint32  time,
 346                              gboolean implicit_grab)
 347 {
 348   GdkWindow             *toplevel;
 349   GdkWindow             *mousewin;
 350   GdkWindow             *old_grab_window;
 351   GdkWindowImplDirectFB *impl;
 352
 353   if (implicit_grab && !_gdk_directfb_pointer_implicit_grab)
 354     return;
 355
 356   if (!_gdk_directfb_pointer_grab_window)
 357     return;
 358
 359   toplevel =
 360     gdk_directfb_window_find_toplevel (_gdk_directfb_pointer_grab_window);
 361   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (toplevel)->impl);
 362
 363   if (impl->window)
 364     impl->window->UngrabPointer (impl->window);
 365
 366   if (_gdk_directfb_pointer_grab_confine)
 367     {
 368       g_object_unref (_gdk_directfb_pointer_grab_confine);
 369       _gdk_directfb_pointer_grab_confine = NULL;
 370     }
 371
 372   if (_gdk_directfb_pointer_grab_cursor)
 373     {
 374       gdk_cursor_unref (_gdk_directfb_pointer_grab_cursor);
 375       _gdk_directfb_pointer_grab_cursor = NULL;
 376     }
 377
 378   old_grab_window = _gdk_directfb_pointer_grab_window;
 379
 380   _gdk_directfb_pointer_grab_window   = NULL;
 381   _gdk_directfb_pointer_implicit_grab = FALSE;
 382
 383   mousewin = gdk_window_at_pointer (NULL, NULL);
 384   gdk_directfb_window_send_crossing_events (old_grab_window,
 385                                             mousewin,
 386                                             GDK_CROSSING_UNGRAB);
 387   g_object_unref (old_grab_window);
 388 }
 389
 390
 391
 392
 393 /*
 394  *--------------------------------------------------------------
 395  * gdk_keyboard_grab
 396  *
 397  *   Grabs the keyboard to a specific window
 398  *
 399  * Arguments:
 400  *   "window" is the window which will receive the grab
 401  *   "owner_events" specifies whether events will be reported as is,
 402  *     or relative to "window"
 403  *   "time" specifies the time
 404  *
 405  * Results:
 406  *
 407  * Side effects:
 408  *   requires a corresponding call to gdk_keyboard_ungrab
 409  *
 410  *--------------------------------------------------------------
 411  */
 412
 413 GdkGrabStatus
 414 gdk_display_keyboard_grab (GdkDisplay *display,GdkWindow *window,
 415                    gint       owner_events,
 416                    guint32    time)
 417 {
 418   GdkWindow             *toplevel;
 419   GdkWindowImplDirectFB *impl;
 420
 421   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
 422
 423   if (_gdk_directfb_keyboard_grab_window)
 424     gdk_keyboard_ungrab (time);
 425
 426   toplevel = gdk_directfb_window_find_toplevel (window);
 427   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (toplevel)->impl);
 428
 429   if (impl->window)
 430     {
 431       if (impl->window->GrabKeyboard (impl->window) == DFB_LOCKED)
 432         return GDK_GRAB_ALREADY_GRABBED;
 433     }
 434
 435   _gdk_directfb_keyboard_grab_window = g_object_ref (window);
 436   _gdk_directfb_keyboard_grab_owner_events = owner_events;
 437   return GDK_GRAB_SUCCESS;
 438 }
 439
 440 void
 441 gdk_display_keyboard_ungrab (GdkDisplay *display,guint32 time)
 442 {
 443   GdkWindow             *toplevel;
 444   GdkWindowImplDirectFB *impl;
 445
 446   if (!_gdk_directfb_keyboard_grab_window)
 447     return;
 448
 449   toplevel =
 450     gdk_directfb_window_find_toplevel (_gdk_directfb_keyboard_grab_window);
 451   impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (toplevel)->impl);
 452
 453   if (impl->window)
 454     impl->window->UngrabKeyboard (impl->window);
 455
 456   g_object_unref (_gdk_directfb_keyboard_grab_window);
 457   _gdk_directfb_keyboard_grab_window = NULL;
 458 }
 459
 460 gint
 461 gdk_display_pointer_is_grabbed (GdkDisplay *display)
 462 {
 463   return _gdk_directfb_pointer_grab_window != NULL;
 464 }
 465
 466 void
 467 gdk_display_pointer_ungrab (GdkDisplay *display,guint32 time)
 468 {
 469   gdk_directfb_pointer_ungrab (time, _gdk_directfb_pointer_implicit_grab);
 470 }
 471
 472 void
 473 gdk_display_beep (GdkDisplay *display)
 474 {
 475 }
 476
 477 void
 478 gdk_display_sync (GdkDisplay *display)
 479 {
 480 }
 481
 482 void
 483 gdk_display_flush (GdkDisplay *display)
 484 {
 485 }
 486
 487
 488
 489 void
 490 gdk_notify_startup_complete (void)
 491 {
 492 }
 493
 494 /**
 495  * gdk_notify_startup_complete_with_id:
 496  * @startup_id: a startup-notification identifier, for which notification
 497  *              process should be completed
 498  *
 499  * Indicates to the GUI environment that the application has finished
 500  * loading, using a given identifier.
 501  *
 502  * GTK+ will call this function automatically for #GtkWindow with custom
 503  * startup-notification identifier unless
 504  * gtk_window_set_auto_startup_notification() is called to disable
 505  * that feature.
 506  *
 507  * Since: 2.12
 508  **/
 509 void
 510 gdk_notify_startup_complete_with_id (const gchar* startup_id)
 511 {
 512 }
 513
 514
 515 gboolean
 516 gdk_display_supports_composite (GdkDisplay *display)
 517 {
 518     return FALSE;
 519 }
 520
 521 #define __GDK_DISPLAY_X11_C__
 522 #include "gdkaliasdef.c"
 523