Pileus Git - ~andy/gtk/blob - gdk/linux-fb/gdkmain-fb.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 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <sys/types.h>
  31 #include <sys/mman.h>
  32 #include <sys/ioctl.h>
  33 #include <ctype.h>
  34 #include <stdio.h>
  35 #include <time.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <sys/vt.h>
  39 #include <sys/kd.h>
  40 #include <errno.h>
  41 #include <signal.h>
  42
  43 #include <sys/socket.h>
  44 #include <sys/un.h>
  45
  46 #include "gdk.h"
  47
  48 #include "gdkprivate-fb.h"
  49 #include "gdkinternals.h"
  50 #include "gdkfbmanager.h"
  51
  52 /* Private variable declarations
  53  */
  54 static int gdk_initialized = 0;                     /* 1 if the library is initialized,
  55                                                      * 0 otherwise.
  56                                                      */
  57
  58 #ifdef G_ENABLE_DEBUG
  59 static const GDebugKey gdk_debug_keys[] = {
  60   {"misc",          GDK_DEBUG_MISC},
  61   {"events",        GDK_DEBUG_EVENTS},
  62 };
  63
  64 static const int gdk_ndebug_keys = sizeof(gdk_debug_keys)/sizeof(GDebugKey);
  65
  66 #endif /* G_ENABLE_DEBUG */
  67
  68 GdkArgDesc _gdk_windowing_args[] = {
  69   { NULL }
  70 };
  71
  72 static const GScannerConfig     fb_modes_scanner_config =
  73 {
  74   (
  75    " \t\n"
  76    )                    /* cset_skip_characters */,
  77   (
  78    G_CSET_a_2_z
  79    G_CSET_A_2_Z
  80    )                    /* cset_identifier_first */,
  81   (
  82    G_CSET_a_2_z
  83    "_-0123456789"
  84    G_CSET_A_2_Z
  85    )                    /* cset_identifier_nth */,
  86   ( "#\n" )             /* cpair_comment_single */,
  87
  88   FALSE                  /* case_sensitive */,
  89
  90   FALSE                 /* skip_comment_multi */,
  91   TRUE                  /* skip_comment_single */,
  92   FALSE                 /* scan_comment_multi */,
  93   TRUE                  /* scan_identifier */,
  94   TRUE                  /* scan_identifier_1char */,
  95   FALSE                 /* scan_identifier_NULL */,
  96   TRUE                  /* scan_symbols */,
  97   FALSE                 /* scan_binary */,
  98   FALSE                 /* scan_octal */,
  99   FALSE                  /* scan_float */,
 100   FALSE                  /* scan_hex */,
 101   FALSE                 /* scan_hex_dollar */,
 102   FALSE                 /* scan_string_sq */,
 103   TRUE                  /* scan_string_dq */,
 104   TRUE                  /* numbers_2_int */,
 105   FALSE                 /* int_2_float */,
 106   FALSE                 /* identifier_2_string */,
 107   TRUE                  /* char_2_token */,
 108   FALSE                 /* symbol_2_token */,
 109   FALSE                 /* scope_0_fallback */,
 110 };
 111
 112 enum {
 113   FB_MODE,
 114   FB_ENDMODE,
 115   FB_GEOMETRY,
 116   FB_TIMINGS,
 117   FB_LACED,
 118   FB_HSYNC,
 119   FB_VSYNC,
 120   FB_CSYNC,
 121   FB_EXTSYNC,
 122   FB_DOUBLE,
 123   FB_ACCEL
 124 };
 125
 126 char *fb_modes_keywords[] =
 127 {
 128   "mode",
 129   "endmode",
 130   "geometry",
 131   "timings",
 132   "laced",
 133   "hsync",
 134   "vsync",
 135   "csync",
 136   "extsync",
 137   "double",
 138   "accel"
 139 };
 140
 141 static int
 142 fb_modes_parse_mode (GScanner *scanner,
 143                      struct fb_var_screeninfo *modeinfo,
 144                      char *specified_modename)
 145 {
 146   guint token;
 147   int keyword;
 148   int i;
 149   char *modename;
 150   int geometry[5];
 151   int timings[7];
 152   int vsync=0, hsync=0, csync=0, extsync=0, doublescan=0, laced=0, accel=1;
 153   int found_geometry = 0;
 154   int found_timings = 0;
 155
 156   token = g_scanner_get_next_token (scanner);
 157   if (token != G_TOKEN_SYMBOL)
 158     return -1;
 159
 160   keyword = GPOINTER_TO_INT (scanner->value.v_symbol);
 161   if (keyword != FB_MODE)
 162     return -1;
 163
 164   token = g_scanner_get_next_token (scanner);
 165   if (token != G_TOKEN_STRING)
 166     return -1;
 167
 168   modename = g_strdup (scanner->value.v_string);
 169
 170   token = g_scanner_get_next_token (scanner);
 171   if (token != G_TOKEN_SYMBOL)
 172     {
 173       g_free (modename);
 174       return -1; /* Not a valid keyword */
 175     }
 176   keyword = GPOINTER_TO_INT (scanner->value.v_symbol);
 177   while ( keyword != FB_ENDMODE )
 178     {
 179
 180       switch (GPOINTER_TO_INT (scanner->value.v_symbol))
 181         {
 182         case FB_GEOMETRY:
 183           for (i = 0; i < 5;i++) {
 184             token = g_scanner_get_next_token (scanner);
 185             if (token != G_TOKEN_INT)
 186               {
 187                 g_free (modename);
 188                 return -1; /* need a integer */
 189               }
 190             geometry[i] = scanner->value.v_int;
 191           }
 192           found_geometry = TRUE;
 193           break;
 194         case FB_TIMINGS:
 195           for (i = 0; i < 7; i++) {
 196             token = g_scanner_get_next_token (scanner);
 197             if (token != G_TOKEN_INT)
 198               {
 199                 g_free (modename);
 200                 return -1; /* need a integer */
 201               }
 202             timings[i] = scanner->value.v_int;
 203           }
 204           found_timings = TRUE;
 205           break;
 206         case FB_LACED:
 207           token = g_scanner_get_next_token (scanner);
 208           if (token != G_TOKEN_IDENTIFIER)
 209               {
 210                 g_free (modename);
 211                 return -1;
 212               }
 213           if (g_ascii_strcasecmp (scanner->value.v_identifier, "true")==0)
 214             laced = 1;
 215           else if (g_ascii_strcasecmp (scanner->value.v_identifier, "false")==0)
 216             laced = 0;
 217           else
 218             {
 219               g_free (modename);
 220               return -1;
 221             }
 222           break;
 223         case FB_EXTSYNC:
 224           token = g_scanner_get_next_token (scanner);
 225           if (token != G_TOKEN_IDENTIFIER)
 226               {
 227                 g_free (modename);
 228                 return -1;
 229               }
 230           if (g_ascii_strcasecmp (scanner->value.v_identifier, "true")==0)
 231             extsync = 1;
 232           else if (g_ascii_strcasecmp (scanner->value.v_identifier, "false")==0)
 233             extsync = 0;
 234           else
 235             {
 236               g_free (modename);
 237               return -1;
 238             }
 239           break;
 240         case FB_DOUBLE:
 241           token = g_scanner_get_next_token (scanner);
 242           if (token != G_TOKEN_IDENTIFIER)
 243               {
 244                 g_free (modename);
 245                 return -1;
 246               }
 247           if (g_ascii_strcasecmp (scanner->value.v_identifier, "true")==0)
 248             doublescan = 1;
 249           else if (g_ascii_strcasecmp (scanner->value.v_identifier, "false")==0)
 250             doublescan = 0;
 251           else
 252             {
 253               g_free (modename);
 254               return -1;
 255             }
 256           break;
 257         case FB_VSYNC:
 258           token = g_scanner_get_next_token (scanner);
 259           if (token != G_TOKEN_IDENTIFIER)
 260               {
 261                 g_free (modename);
 262                 return -1;
 263               }
 264           if (g_ascii_strcasecmp (scanner->value.v_identifier, "high")==0)
 265             vsync = 1;
 266           else if (g_ascii_strcasecmp (scanner->value.v_identifier, "low")==0)
 267             vsync = 0;
 268           else
 269             {
 270               g_free (modename);
 271               return -1;
 272             }
 273           break;
 274         case FB_HSYNC:
 275           token = g_scanner_get_next_token (scanner);
 276           if (token != G_TOKEN_IDENTIFIER)
 277             {
 278               g_free (modename);
 279               return -1;
 280             }
 281           if (g_ascii_strcasecmp (scanner->value.v_identifier, "high")==0)
 282             hsync = 1;
 283           else if (g_ascii_strcasecmp (scanner->value.v_identifier, "low")==0)
 284             hsync = 0;
 285           else
 286             {
 287               g_free (modename);
 288               return -1;
 289             }
 290           break;
 291         case FB_CSYNC:
 292           token = g_scanner_get_next_token (scanner);
 293           if (token != G_TOKEN_IDENTIFIER)
 294             {
 295               g_free (modename);
 296               return -1;
 297             }
 298           if (g_ascii_strcasecmp (scanner->value.v_identifier, "high")==0)
 299             csync = 1;
 300           else if (g_ascii_strcasecmp (scanner->value.v_identifier, "low")==0)
 301             csync = 0;
 302           else
 303             {
 304               g_free (modename);
 305               return -1;
 306             }
 307           break;
 308         case FB_ACCEL:
 309           token = g_scanner_get_next_token (scanner);
 310           if (token != G_TOKEN_IDENTIFIER)
 311             {
 312               g_free (modename);
 313               return -1;
 314             }
 315           if (g_ascii_strcasecmp (scanner->value.v_identifier, "false")==0)
 316             accel = 0;
 317           else if (g_ascii_strcasecmp (scanner->value.v_identifier, "true")==0)
 318             accel = 1;
 319           else
 320             {
 321               g_free (modename);
 322               return -1;
 323             }
 324           break;
 325         }
 326
 327       token = g_scanner_get_next_token (scanner);
 328       if (token != G_TOKEN_SYMBOL)
 329         {
 330           g_free (modename);
 331           return -1; /* Not a valid keyword */
 332         }
 333       keyword = GPOINTER_TO_INT (scanner->value.v_symbol);
 334     }
 335
 336   if (strcmp (modename, specified_modename)== 0) {
 337     /* we really should be parsing for rgba. regardless, if rgba isn't found,
 338      * we can't assume that the original colors are valid for the new mode */
 339     memset (&modeinfo->red, 0, sizeof (modeinfo->red));
 340     memset (&modeinfo->green, 0, sizeof (modeinfo->green));
 341     memset (&modeinfo->blue, 0, sizeof (modeinfo->blue));
 342     memset (&modeinfo->transp, 0, sizeof (modeinfo->transp));
 343
 344     if (!found_geometry)
 345       g_warning ("Geometry not specified");
 346
 347     if (found_geometry)
 348       {
 349         modeinfo->xres = geometry[0];
 350         modeinfo->yres = geometry[1];
 351         modeinfo->xres_virtual = geometry[2];
 352         modeinfo->yres_virtual = geometry[3];
 353         modeinfo->bits_per_pixel = geometry[4];
 354       }
 355
 356     if (!found_timings)
 357       g_warning ("Timing not specified");
 358
 359     if (found_timings)
 360       {
 361         modeinfo->pixclock = timings[0];
 362         modeinfo->left_margin = timings[1];
 363         modeinfo->right_margin = timings[2];
 364         modeinfo->upper_margin = timings[3];
 365         modeinfo->lower_margin = timings[4];
 366         modeinfo->hsync_len = timings[5];
 367         modeinfo->vsync_len = timings[6];
 368
 369         modeinfo->vmode = 0;
 370         if (laced)
 371           modeinfo->vmode |= FB_VMODE_INTERLACED;
 372         if (doublescan)
 373           modeinfo->vmode |= FB_VMODE_DOUBLE;
 374
 375         modeinfo->sync = 0;
 376         if (hsync)
 377           modeinfo->sync |= FB_SYNC_HOR_HIGH_ACT;
 378         if (vsync)
 379           modeinfo->sync |= FB_SYNC_VERT_HIGH_ACT;
 380         if (accel)
 381           modeinfo->accel_flags = FB_ACCELF_TEXT;
 382         else
 383           modeinfo->accel_flags = 0;
 384       }
 385
 386     g_free (modename);
 387     return 1;
 388   }
 389
 390   g_free (modename);
 391
 392   return 0;
 393 }
 394
 395 static int
 396 gdk_fb_setup_mode_from_name (struct fb_var_screeninfo *modeinfo,
 397                              char *modename)
 398 {
 399   GScanner *scanner;
 400   char *filename;
 401   gint result;
 402   int fd, i;
 403   int retval;
 404
 405   retval = 0;
 406
 407   filename = "/etc/fb.modes";
 408
 409   fd = open (filename, O_RDONLY);
 410   if (fd < 0)
 411     {
 412       g_warning ("Cannot read %s", filename);
 413       return retval;
 414     }
 415
 416   scanner = g_scanner_new ((GScannerConfig *) &fb_modes_scanner_config);
 417   scanner->input_name = filename;
 418
 419   for (i = 0; i < sizeof(fb_modes_keywords)/sizeof(fb_modes_keywords[0]); i++)
 420     g_scanner_scope_add_symbol (scanner, 0, fb_modes_keywords[i], GINT_TO_POINTER (i));
 421
 422   g_scanner_input_file (scanner, fd);
 423
 424   while (1) {
 425     if (g_scanner_peek_next_token (scanner) == G_TOKEN_EOF) {
 426       break;
 427     }
 428     result = fb_modes_parse_mode (scanner, modeinfo, modename);
 429
 430     if (result < 0) {
 431       g_warning ("parse error in %s at line %d", filename, scanner->line);
 432       break;
 433     }
 434     if (result > 0)
 435       {
 436         retval = 1;
 437         break;
 438       }
 439   }
 440
 441   g_scanner_destroy (scanner);
 442
 443   close (fd);
 444
 445   return retval;
 446 }
 447
 448
 449 static int
 450 gdk_fb_set_mode (GdkFBDisplay *display)
 451 {
 452   char *env, *end;
 453   int depth, height, width;
 454   gboolean changed;
 455
 456   if (ioctl (display->fb_fd, FBIOGET_VSCREENINFO, &display->modeinfo) < 0)
 457     return -1;
 458
 459   display->orig_modeinfo = display->modeinfo;
 460
 461   changed = FALSE;
 462
 463   env = getenv ("GDK_DISPLAY_MODE");
 464   if (env)
 465     {
 466       if (gdk_fb_setup_mode_from_name (&display->modeinfo, env))
 467         changed = TRUE;
 468       else
 469         g_warning ("Couldn't find mode named '%s'", env);
 470     }
 471
 472   env = getenv ("GDK_DISPLAY_DEPTH");
 473   if (env)
 474     {
 475       depth = strtol (env, &end, 10);
 476       if (env != end)
 477         {
 478           changed = TRUE;
 479           display->modeinfo.bits_per_pixel = depth;
 480         }
 481     }
 482
 483   env = getenv ("GDK_DISPLAY_WIDTH");
 484   if (env)
 485     {
 486       width = strtol (env, &end, 10);
 487       if (env != end)
 488         {
 489           changed = TRUE;
 490           display->modeinfo.xres = width;
 491           display->modeinfo.xres_virtual = width;
 492         }
 493     }
 494
 495   env = getenv ("GDK_DISPLAY_HEIGHT");
 496   if (env)
 497     {
 498       height = strtol (env, &end, 10);
 499       if (env != end)
 500         {
 501           changed = TRUE;
 502           display->modeinfo.yres = height;
 503           display->modeinfo.yres_virtual = height;
 504         }
 505     }
 506
 507   if (changed &&
 508       (ioctl (display->fb_fd, FBIOPUT_VSCREENINFO, &display->modeinfo) < 0))
 509     {
 510       g_warning ("Couldn't set specified mode");
 511       return -1;
 512     }
 513
 514   /* ask for info back to make sure of what we got */
 515   if (ioctl (display->fb_fd, FBIOGET_VSCREENINFO, &display->modeinfo) < 0)
 516     {
 517       g_warning ("Error getting var screen info");
 518       return -1;
 519     }
 520
 521   if (ioctl (display->fb_fd, FBIOGET_FSCREENINFO, &display->sinfo) < 0)
 522     {
 523       g_warning ("Error getting fixed screen info");
 524       return -1;
 525     }
 526   return 0;
 527 }
 528
 529 #ifdef ENABLE_FB_MANAGER
 530 static void
 531 gdk_fb_switch_from (void)
 532 {
 533   g_print ("Switch from\n");
 534   gdk_shadow_fb_stop_updates ();
 535   gdk_fb_mouse_close ();
 536   gdk_fb_keyboard_close ();
 537 }
 538
 539 static void
 540 gdk_fb_switch_to (void)
 541 {
 542   g_print ("switch_to\n");
 543   gdk_shadow_fb_update (0, 0,
 544                         gdk_display->fb_width,
 545                         gdk_display->fb_height);
 546
 547   if (!gdk_fb_keyboard_open ())
 548     g_warning ("Failed to re-initialize keyboard");
 549
 550   if (!gdk_fb_mouse_open ())
 551     g_warning ("Failed to re-initialize mouse");
 552
 553 }
 554
 555
 556 static gboolean
 557 gdk_fb_manager_callback (GIOChannel *gioc,
 558                          GIOCondition cond,
 559                          gpointer data)
 560 {
 561   struct FBManagerMessage msg;
 562   GdkFBDisplay *display;
 563   int res;
 564
 565   display = data;
 566
 567   res = recv (display->manager_fd, &msg, sizeof (msg), 0);
 568
 569   if (res==0)
 570     {
 571       g_source_remove (gdk_display->manager_tag);
 572       /*g_io_channel_unref (kb->io);*/
 573       close (gdk_display->manager_fd);
 574
 575     }
 576
 577   if (res != sizeof (msg))
 578     {
 579       g_warning ("Got wrong size message");
 580       return TRUE;
 581     }
 582
 583   switch (msg.msg_type)
 584     {
 585     case FB_MANAGER_SWITCH_FROM:
 586       g_print ("Got switch from message\n");
 587       display->manager_blocked = TRUE;
 588       gdk_fb_switch_from ();
 589       msg.msg_type = FB_MANAGER_ACK;
 590       send (display->manager_fd, &msg, sizeof (msg), 0);
 591       break;
 592     case FB_MANAGER_SWITCH_TO:
 593       g_print ("Got switch to message\n");
 594       display->manager_blocked = FALSE;
 595       gdk_fb_switch_to ();
 596       break;
 597     default:
 598       g_warning ("Got unknown message");
 599     }
 600   return TRUE;
 601 }
 602
 603 #endif /* ENABLE_FB_MANAGER */
 604
 605 static void
 606 gdk_fb_manager_connect (GdkFBDisplay *display)
 607 {
 608 #ifdef ENABLE_FB_MANAGER
 609   int fd;
 610   struct sockaddr_un addr;
 611   struct msghdr msg = {0};
 612   struct cmsghdr *cmsg;
 613   struct ucred credentials;
 614   struct FBManagerMessage init_msg;
 615   struct iovec iov;
 616   char buf[CMSG_SPACE (sizeof (credentials))];  /* ancillary data buffer */
 617   int *fdptr;
 618   int res;
 619
 620   display->manager_blocked = FALSE;
 621   display->manager_fd = -1;
 622
 623   fd = socket (PF_UNIX, SOCK_STREAM, 0);
 624
 625   g_print ("socket: %d\n", fd);
 626
 627   if (fd < 0)
 628     return;
 629
 630   addr.sun_family = AF_UNIX;
 631   strcpy (addr.sun_path, "/tmp/.fb.manager");
 632
 633   if (connect(fd, (struct sockaddr *)&addr, sizeof (addr)) < 0)
 634     {
 635       g_print ("connect failed\n");
 636       close (fd);
 637       return;
 638     }
 639
 640   credentials.pid = getpid ();
 641   credentials.uid = geteuid ();
 642   credentials.gid = getegid ();
 643
 644   init_msg.msg_type = FB_MANAGER_NEW_CLIENT;
 645   iov.iov_base = &init_msg;
 646   iov.iov_len = sizeof (init_msg);
 647
 648   msg.msg_name = NULL;
 649   msg.msg_namelen = 0;
 650   msg.msg_iov = &iov;
 651   msg.msg_iovlen = 1;
 652   msg.msg_control = buf;
 653   msg.msg_controllen = sizeof buf;
 654   cmsg = CMSG_FIRSTHDR(&msg);
 655   cmsg->cmsg_level = SOL_SOCKET;
 656   cmsg->cmsg_type = SCM_CREDENTIALS;
 657   cmsg->cmsg_len = CMSG_LEN (sizeof (credentials));
 658   /* Initialize the payload: */
 659   fdptr = (int *)CMSG_DATA (cmsg);
 660   memcpy (fdptr, &credentials, sizeof (credentials));
 661   /* Sum of the length of all control messages in the buffer: */
 662   msg.msg_controllen = cmsg->cmsg_len;
 663
 664   res = sendmsg (fd, &msg, 0);
 665
 666   display->manager_fd = fd;
 667   display->manager_blocked = TRUE;
 668
 669   display->manager_tag = g_io_add_watch (g_io_channel_unix_new (fd),
 670                                          G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
 671                                          gdk_fb_manager_callback,
 672                                          display);
 673
 674   init_msg.msg_type = FB_MANAGER_REQUEST_SWITCH_TO_PID;
 675   init_msg.data = getpid ();
 676
 677   /* Request a switch-to */
 678   send (fd, &init_msg, sizeof (init_msg), 0);
 679 #endif
 680 }
 681
 682 static GdkFBDisplay *
 683 gdk_fb_display_new ()
 684 {
 685   GdkFBDisplay *display;
 686   gchar *fb_filename;
 687   struct vt_stat vs;
 688   int vt, n;
 689   gchar *s, *send;
 690   char buf[32];
 691
 692   display = g_new0 (GdkFBDisplay, 1);
 693
 694   display->console_fd = open ("/dev/console", O_RDWR);
 695   if (display->console_fd < 0)
 696     {
 697       g_warning ("Can't open /dev/console: %s", strerror (errno));
 698       g_free (display);
 699       return NULL;
 700     }
 701
 702   ioctl (display->console_fd, VT_GETSTATE, &vs);
 703   display->start_vt = vs.v_active;
 704
 705   vt = display->start_vt;
 706   s = getenv("GDK_VT");
 707   if (s)
 708     {
 709       if (g_ascii_strcasecmp ("new", s)==0)
 710         {
 711           n = ioctl (display->console_fd, VT_OPENQRY, &vt);
 712           if (n < 0 || vt == -1)
 713             g_error("Cannot allocate new VT");
 714         }
 715       else
 716         {
 717           vt = strtol (s, &send, 10);
 718           if (s==send)
 719             {
 720               g_warning ("Cannot parse GDK_VT");
 721               vt = display->start_vt;
 722             }
 723         }
 724
 725     }
 726
 727   display->vt = vt;
 728
 729   /* Switch to the new VT */
 730   if (vt != display->start_vt)
 731     {
 732       ioctl (display->console_fd, VT_ACTIVATE, vt);
 733       ioctl (display->console_fd, VT_WAITACTIVE, vt);
 734     }
 735
 736   /* Open the tty */
 737   g_snprintf (buf, sizeof(buf), "/dev/tty%d", vt);
 738   display->tty_fd = open (buf, O_RDWR|O_NONBLOCK);
 739   if (display->tty_fd < 0)
 740     {
 741       g_warning ("Can't open %s: %s", buf, strerror (errno));
 742       close (display->console_fd);
 743       g_free (display);
 744       return NULL;
 745     }
 746
 747   /* Set controlling tty */
 748   ioctl (0, TIOCNOTTY, 0);
 749   ioctl (display->tty_fd, TIOCSCTTY, 0);
 750
 751   fb_filename = gdk_get_display ();
 752   display->fb_fd = open (fb_filename, O_RDWR);
 753   if (display->fb_fd < 0)
 754     {
 755       g_warning ("Can't open %s: %s", fb_filename, strerror (errno));
 756       g_free (fb_filename);
 757       close (display->tty_fd);
 758       close (display->console_fd);
 759       g_free (display);
 760       return NULL;
 761     }
 762   g_free (fb_filename);
 763
 764   if (gdk_fb_set_mode (display) < 0)
 765     {
 766       close (display->fb_fd);
 767       close (display->tty_fd);
 768       close (display->console_fd);
 769       g_free (display);
 770       return NULL;
 771     }
 772
 773   /* Disable normal text on the console */
 774   ioctl (display->fb_fd, KDSETMODE, KD_GRAPHICS);
 775
 776   ioctl (display->fb_fd, FBIOBLANK, 0);
 777
 778   /* We used to use sinfo.smem_len, but that seemed to be broken in many cases */
 779   display->fb_mmap = mmap (NULL,
 780                            display->modeinfo.yres * display->sinfo.line_length,
 781                            PROT_READ|PROT_WRITE,
 782                            MAP_SHARED,
 783                            display->fb_fd,
 784                            0);
 785   g_assert (display->fb_mmap != MAP_FAILED);
 786
 787   if (display->sinfo.visual == FB_VISUAL_TRUECOLOR)
 788     {
 789       display->red_byte = display->modeinfo.red.offset >> 3;
 790       display->green_byte = display->modeinfo.green.offset >> 3;
 791       display->blue_byte = display->modeinfo.blue.offset >> 3;
 792     }
 793
 794 #ifdef ENABLE_SHADOW_FB
 795   if (_gdk_fb_screen_angle % 2 == 0)
 796     {
 797       display->fb_width = display->modeinfo.xres;
 798       display->fb_height = display->modeinfo.yres;
 799     }
 800   else
 801     {
 802       display->fb_width = display->modeinfo.yres;
 803       display->fb_height = display->modeinfo.xres;
 804     }
 805   display->fb_stride =
 806     display->fb_width * (display->modeinfo.bits_per_pixel / 8);
 807   display->fb_mem = g_malloc(display->fb_height * display->fb_stride);
 808 #else
 809   display->fb_mem = display->fb_mmap;
 810   display->fb_width = display->modeinfo.xres;
 811   display->fb_height = display->modeinfo.yres;
 812   display->fb_stride = display->sinfo.line_length;
 813 #endif
 814
 815   return display;
 816 }
 817
 818 static void
 819 gdk_fb_display_destroy (GdkFBDisplay *display)
 820 {
 821   /* Restore old framebuffer mode */
 822   ioctl (display->fb_fd, FBIOPUT_VSCREENINFO, &display->orig_modeinfo);
 823
 824   /* Enable normal text on the console */
 825   ioctl (display->fb_fd, KDSETMODE, KD_TEXT);
 826
 827   munmap (display->fb_mmap, display->modeinfo.yres * display->sinfo.line_length);
 828   close (display->fb_fd);
 829
 830   ioctl (display->console_fd, VT_ACTIVATE, display->start_vt);
 831   ioctl (display->console_fd, VT_WAITACTIVE, display->start_vt);
 832   if (display->vt != display->start_vt)
 833     ioctl (display->console_fd, VT_DISALLOCATE, display->vt);
 834
 835   close (display->tty_fd);
 836   close (display->console_fd);
 837   g_free (display);
 838 }
 839
 840 void
 841 _gdk_windowing_init (int *argc, char ***argv)
 842 {
 843   if (gdk_initialized)
 844     return;
 845
 846   /* Create new session and become session leader */
 847   setsid();
 848
 849   gdk_display = gdk_fb_display_new ();
 850
 851   if (!gdk_display)
 852     return;
 853
 854   gdk_shadow_fb_init ();
 855
 856   gdk_fb_manager_connect (gdk_display);
 857
 858   if (!gdk_fb_keyboard_init (!gdk_display->manager_blocked))
 859     {
 860       g_warning ("Failed to initialize keyboard");
 861       gdk_fb_display_destroy (gdk_display);
 862       gdk_display = NULL;
 863       return;
 864     }
 865
 866   if (!gdk_fb_mouse_init (!gdk_display->manager_blocked))
 867     {
 868       g_warning ("Failed to initialize mouse");
 869       gdk_fb_keyboard_close ();
 870       gdk_fb_display_destroy (gdk_display);
 871       gdk_display = NULL;
 872       return;
 873     }
 874
 875   /* Although atexit is evil, we need it here because otherwise the
 876    * keyboard is left in a bad state. you can still run 'reset' but
 877    * that gets annoying after running testgtk for the 20th time.
 878    */
 879   g_atexit(_gdk_windowing_exit);
 880
 881   gdk_initialized = TRUE;
 882
 883   _gdk_selection_property = gdk_atom_intern ("GDK_SELECTION", FALSE);
 884
 885 }
 886
 887 void
 888 _gdk_windowing_set_default_display (GdkDisplay *display)
 889 {
 890 }
 891
 892 /*
 893  *--------------------------------------------------------------
 894  * gdk_pointer_grab
 895  *
 896  *   Grabs the pointer to a specific window
 897  *
 898  * Arguments:
 899  *   "window" is the window which will receive the grab
 900  *   "owner_events" specifies whether events will be reported as is,
 901  *     or relative to "window"
 902  *   "event_mask" masks only interesting events
 903  *   "confine_to" limits the cursor movement to the specified window
 904  *   "cursor" changes the cursor for the duration of the grab
 905  *   "time" specifies the time
 906  *
 907  * Results:
 908  *
 909  * Side effects:
 910  *   requires a corresponding call to gdk_pointer_ungrab
 911  *
 912  *--------------------------------------------------------------
 913  */
 914
 915 GdkGrabStatus
 916 gdk_pointer_grab (GdkWindow *     window,
 917                   gint            owner_events,
 918                   GdkEventMask    event_mask,
 919                   GdkWindow *     confine_to,
 920                   GdkCursor *     cursor,
 921                   guint32         time)
 922 {
 923   return gdk_fb_pointer_grab (window,
 924                               owner_events,
 925                               event_mask,
 926                               confine_to,
 927                               cursor,
 928                               time, FALSE);
 929 }
 930
 931 static gboolean _gdk_fb_pointer_implicit_grab = FALSE;
 932
 933 GdkGrabStatus
 934 gdk_fb_pointer_grab (GdkWindow *          window,
 935                      gint                 owner_events,
 936                      GdkEventMask         event_mask,
 937                      GdkWindow *          confine_to,
 938                      GdkCursor *          cursor,
 939                      guint32              time,
 940                      gboolean             implicit_grab)
 941 {
 942   g_return_val_if_fail (window != NULL, 0);
 943   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
 944   g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
 945
 946   if (_gdk_fb_pointer_grab_window)
 947     {
 948       if (implicit_grab && !_gdk_fb_pointer_implicit_grab)
 949         return GDK_GRAB_ALREADY_GRABBED;
 950
 951       gdk_pointer_ungrab (time);
 952     }
 953
 954   gdk_fb_window_send_crossing_events (NULL,
 955                                       window,
 956                                       GDK_CROSSING_GRAB);
 957
 958   if (event_mask & GDK_BUTTON_MOTION_MASK)
 959       event_mask |=
 960         GDK_BUTTON1_MOTION_MASK |
 961         GDK_BUTTON2_MOTION_MASK |
 962         GDK_BUTTON3_MOTION_MASK;
 963
 964   _gdk_fb_pointer_implicit_grab = implicit_grab;
 965
 966   _gdk_fb_pointer_grab_window = gdk_window_ref (window);
 967   _gdk_fb_pointer_grab_owner_events = owner_events;
 968
 969   _gdk_fb_pointer_grab_confine = confine_to ? gdk_window_ref (confine_to) : NULL;
 970   _gdk_fb_pointer_grab_events = event_mask;
 971   _gdk_fb_pointer_grab_cursor = cursor ? gdk_cursor_ref (cursor) : NULL;
 972
 973
 974
 975   if (cursor)
 976     gdk_fb_cursor_reset ();
 977
 978   return GDK_GRAB_SUCCESS;
 979 }
 980
 981 /*
 982  *--------------------------------------------------------------
 983  * gdk_display_pointer_ungrab
 984  *
 985  *   Releases any pointer grab
 986  *
 987  * Arguments:
 988  *
 989  * Results:
 990  *
 991  * Side effects:
 992  *
 993  *--------------------------------------------------------------
 994  */
 995
 996 void
 997 gdk_display_pointer_ungrab (GdkDisplay *display,
 998                             guint32     time)
 999 {
1000   gdk_fb_pointer_ungrab (time, FALSE);
1001 }
1002
1003 void
1004 gdk_fb_pointer_ungrab (guint32 time, gboolean implicit_grab)
1005 {
1006   gboolean have_grab_cursor = _gdk_fb_pointer_grab_cursor && 1;
1007   GdkWindow *mousewin;
1008   GdkWindow *old_grab_window;
1009
1010   if (!_gdk_fb_pointer_grab_window)
1011     return;
1012
1013   if (implicit_grab && !_gdk_fb_pointer_implicit_grab)
1014     return;
1015
1016   if (_gdk_fb_pointer_grab_confine)
1017     gdk_window_unref (_gdk_fb_pointer_grab_confine);
1018   _gdk_fb_pointer_grab_confine = NULL;
1019
1020   if (_gdk_fb_pointer_grab_cursor)
1021     gdk_cursor_unref (_gdk_fb_pointer_grab_cursor);
1022   _gdk_fb_pointer_grab_cursor = NULL;
1023
1024   if (have_grab_cursor)
1025     gdk_fb_cursor_reset ();
1026
1027   old_grab_window = _gdk_fb_pointer_grab_window;
1028
1029   _gdk_fb_pointer_grab_window = NULL;
1030
1031   _gdk_fb_pointer_implicit_grab = FALSE;
1032
1033   mousewin = gdk_window_at_pointer (NULL, NULL);
1034   gdk_fb_window_send_crossing_events (old_grab_window,
1035                                       mousewin,
1036                                       GDK_CROSSING_UNGRAB);
1037
1038   if (old_grab_window)
1039     gdk_window_unref (old_grab_window);
1040 }
1041
1042 /*
1043  *--------------------------------------------------------------
1044  * gdk_display_pointer_is_grabbed
1045  *
1046  *   Tell wether there is an active x pointer grab in effect
1047  *
1048  * Arguments:
1049  *
1050  * Results:
1051  *
1052  * Side effects:
1053  *
1054  *--------------------------------------------------------------
1055  */
1056
1057 gint
1058 gdk_display_pointer_is_grabbed (GdkDisplay *display)
1059 {
1060   return _gdk_fb_pointer_grab_window != NULL;
1061 }
1062
1063 /*
1064  *--------------------------------------------------------------
1065  * gdk_keyboard_grab
1066  *
1067  *   Grabs the keyboard to a specific window
1068  *
1069  * Arguments:
1070  *   "window" is the window which will receive the grab
1071  *   "owner_events" specifies whether events will be reported as is,
1072  *     or relative to "window"
1073  *   "time" specifies the time
1074  *
1075  * Results:
1076  *
1077  * Side effects:
1078  *   requires a corresponding call to gdk_keyboard_ungrab
1079  *
1080  *--------------------------------------------------------------
1081  */
1082
1083 GdkGrabStatus
1084 gdk_keyboard_grab (GdkWindow  *window,
1085                    gint        owner_events,
1086                    guint32     time)
1087 {
1088   g_return_val_if_fail (window != NULL, 0);
1089   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
1090
1091   if (_gdk_fb_pointer_grab_window)
1092     gdk_keyboard_ungrab (time);
1093
1094   _gdk_fb_keyboard_grab_window = gdk_window_ref (window);
1095   _gdk_fb_keyboard_grab_owner_events = owner_events;
1096
1097   return GDK_GRAB_SUCCESS;
1098 }
1099
1100 /*
1101  *--------------------------------------------------------------
1102  * gdk_display_keyboard_ungrab
1103  *
1104  *   Releases any keyboard grab
1105  *
1106  * Arguments:
1107  *
1108  * Results:
1109  *
1110  * Side effects:
1111  *
1112  *--------------------------------------------------------------
1113  */
1114
1115 void
1116 gdk_display_keyboard_ungrab (GdkDisplay *display,
1117                              guint32     time)
1118 {
1119   if (_gdk_fb_keyboard_grab_window)
1120     gdk_window_unref (_gdk_fb_keyboard_grab_window);
1121   _gdk_fb_keyboard_grab_window = NULL;
1122 }
1123
1124 gboolean
1125 gdk_pointer_grab_info_libgtk_only (GdkDisplay *display,
1126                                    GdkWindow **grab_window,
1127                                    gboolean   *owner_events)
1128 {
1129   if (_gdk_fb_pointer_grab_window)
1130     {
1131       if (grab_window)
1132         *grab_window = (GdkWindow *)_gdk_fb_pointer_grab_window;
1133       if (owner_events)
1134         *owner_events = _gdk_fb_pointer_grab_owner_events;
1135
1136       return TRUE;
1137     }
1138   else
1139     return FALSE;
1140 }
1141
1142 gboolean
1143 gdk_keyboard_grab_info_libgtk_only (GdkDisplay *display,
1144                                     GdkWindow **grab_window,
1145                                     gboolean   *owner_events)
1146 {
1147   if (_gdk_fb_keyboard_grab_window)
1148     {
1149       if (grab_window)
1150         *grab_window = (GdkWindow *)_gdk_fb_keyboard_grab_window;
1151       if (owner_events)
1152         *owner_events = _gdk_fb_keyboard_grab_owner_events;
1153
1154       return TRUE;
1155     }
1156   else
1157     return FALSE;
1158 }
1159
1160
1161 /*
1162  *--------------------------------------------------------------
1163  * gdk_screen_get_width
1164  *
1165  *   Return the width of the screen.
1166  *
1167  * Arguments:
1168  *
1169  * Results:
1170  *
1171  * Side effects:
1172  *
1173  *--------------------------------------------------------------
1174  */
1175
1176 gint
1177 gdk_screen_get_width (GdkScreen *screen)
1178 {
1179   return gdk_display->fb_width;
1180 }
1181
1182 /*
1183  *--------------------------------------------------------------
1184  * gdk_screen_get_height
1185  *
1186  *   Return the height of the screen.
1187  *
1188  * Arguments:
1189  *
1190  * Results:
1191  *
1192  * Side effects:
1193  *
1194  *--------------------------------------------------------------
1195  */
1196
1197 gint
1198 gdk_screen_get_height (GdkScreen *screen)
1199 {
1200   return gdk_display->fb_height;
1201 }
1202
1203 /*
1204  *--------------------------------------------------------------
1205  * gdk_screen_get_width_mm
1206  *
1207  *   Return the width of the screen in millimeters.
1208  *
1209  * Arguments:
1210  *
1211  * Results:
1212  *
1213  * Side effects:
1214  *
1215  *--------------------------------------------------------------
1216  */
1217
1218 gint
1219 gdk_screen_get_width_mm (GdkScreen *screen)
1220 {
1221   return 0.5 + gdk_screen_width () * (25.4 / 72.);
1222 }
1223
1224 /*
1225  *--------------------------------------------------------------
1226  * gdk_screen_get_height_mm
1227  *
1228  *   Return the height of the screen in millimeters.
1229  *
1230  * Arguments:
1231  *
1232  * Results:
1233  *
1234  * Side effects:
1235  *
1236  *--------------------------------------------------------------
1237  */
1238
1239 gint
1240 gdk_screen_get_height_mm (GdkScreen *screen)
1241 {
1242   return 0.5 + gdk_screen_height () * (25.4 / 72.);
1243 }
1244
1245 void
1246 _gdk_windowing_display_set_sm_client_id (GdkDisplay*  display,
1247                                          const gchar* sm_client_id)
1248 {
1249 }
1250
1251 extern void keyboard_shutdown(void);
1252
1253 void
1254 _gdk_windowing_exit (void)
1255 {
1256   struct sigaction action;
1257
1258   /* don't get interrupted while exiting
1259    * (cf. gdkrender-fb.c:gdk_shadow_fb_init) */
1260   action.sa_handler = SIG_IGN;
1261   sigemptyset (&action.sa_mask);
1262   action.sa_flags = 0;
1263
1264   gdk_fb_mouse_close ();
1265   /*leak  g_free (gdk_fb_mouse);*/
1266
1267   gdk_fb_keyboard_close ();
1268   /*leak g_free (gdk_fb_keyboard);*/
1269
1270   gdk_fb_display_destroy (gdk_display);
1271
1272   gdk_display = NULL;
1273 }
1274
1275 gchar *
1276 gdk_get_display(void)
1277 {
1278   gchar *s;
1279
1280   s = getenv ("GDK_DISPLAY");
1281   if (s==0)
1282     s = "/dev/fb0";
1283
1284   return g_strdup (s);
1285 }
1286
1287 void
1288 gdk_display_beep (GdkDisplay *display)
1289 {
1290   static int pitch = 600, duration = 100;
1291   gulong arg;
1292
1293   /* Thank you XFree86 */
1294   arg = ((1193190 / pitch) & 0xffff) |
1295     (((unsigned long)duration) << 16);
1296
1297   ioctl (gdk_display->tty_fd, KDMKTONE, arg);
1298 }
1299
1300 /* utils */
1301 static const guint type_masks[] = {
1302   GDK_SUBSTRUCTURE_MASK, /* GDK_DELETE          = 0, */
1303   GDK_STRUCTURE_MASK, /* GDK_DESTROY            = 1, */
1304   GDK_EXPOSURE_MASK, /* GDK_EXPOSE              = 2, */
1305   GDK_POINTER_MOTION_MASK, /* GDK_MOTION_NOTIFY = 3, */
1306   GDK_BUTTON_PRESS_MASK, /* GDK_BUTTON_PRESS    = 4, */
1307   GDK_BUTTON_PRESS_MASK, /* GDK_2BUTTON_PRESS   = 5, */
1308   GDK_BUTTON_PRESS_MASK, /* GDK_3BUTTON_PRESS   = 6, */
1309   GDK_BUTTON_RELEASE_MASK, /* GDK_BUTTON_RELEASE        = 7, */
1310   GDK_KEY_PRESS_MASK, /* GDK_KEY_PRESS  = 8, */
1311   GDK_KEY_RELEASE_MASK, /* GDK_KEY_RELEASE      = 9, */
1312   GDK_ENTER_NOTIFY_MASK, /* GDK_ENTER_NOTIFY    = 10, */
1313   GDK_LEAVE_NOTIFY_MASK, /* GDK_LEAVE_NOTIFY    = 11, */
1314   GDK_FOCUS_CHANGE_MASK, /* GDK_FOCUS_CHANGE    = 12, */
1315   GDK_STRUCTURE_MASK, /* GDK_CONFIGURE          = 13, */
1316   GDK_VISIBILITY_NOTIFY_MASK, /* GDK_MAP                = 14, */
1317   GDK_VISIBILITY_NOTIFY_MASK, /* GDK_UNMAP              = 15, */
1318   GDK_PROPERTY_CHANGE_MASK, /* GDK_PROPERTY_NOTIFY      = 16, */
1319   GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_CLEAR      = 17, */
1320   GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_REQUEST = 18, */
1321   GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_NOTIFY     = 19, */
1322   GDK_PROXIMITY_IN_MASK, /* GDK_PROXIMITY_IN    = 20, */
1323   GDK_PROXIMITY_OUT_MASK, /* GDK_PROXIMITY_OUT  = 21, */
1324   GDK_ALL_EVENTS_MASK, /* GDK_DRAG_ENTER        = 22, */
1325   GDK_ALL_EVENTS_MASK, /* GDK_DRAG_LEAVE        = 23, */
1326   GDK_ALL_EVENTS_MASK, /* GDK_DRAG_MOTION       = 24, */
1327   GDK_ALL_EVENTS_MASK, /* GDK_DRAG_STATUS       = 25, */
1328   GDK_ALL_EVENTS_MASK, /* GDK_DROP_START        = 26, */
1329   GDK_ALL_EVENTS_MASK, /* GDK_DROP_FINISHED     = 27, */
1330   GDK_ALL_EVENTS_MASK, /* GDK_CLIENT_EVENT      = 28, */
1331   GDK_VISIBILITY_NOTIFY_MASK, /* GDK_VISIBILITY_NOTIFY = 29, */
1332   GDK_EXPOSURE_MASK, /* GDK_NO_EXPOSE           = 30, */
1333   GDK_SCROLL_MASK /* GDK_SCROLL            = 31 */
1334 };
1335
1336 GdkWindow *
1337 gdk_fb_other_event_window (GdkWindow *window,
1338                            GdkEventType type)
1339 {
1340   guint32 evmask;
1341   GdkWindow *w;
1342
1343   w = window;
1344   while (w != _gdk_parent_root)
1345     {
1346       /* Huge hack, so that we don't propagate events to GtkWindow->frame */
1347       if ((w != window) &&
1348           (GDK_WINDOW_P (w)->window_type != GDK_WINDOW_CHILD) &&
1349           (g_object_get_data (G_OBJECT (w), "gdk-window-child-handler")))
1350           break;
1351
1352       evmask = GDK_WINDOW_OBJECT(window)->event_mask;
1353
1354       if (evmask & type_masks[type])
1355         return w;
1356
1357       w = gdk_window_get_parent (w);
1358     }
1359
1360   return NULL;
1361 }
1362
1363 GdkWindow *
1364 gdk_fb_pointer_event_window (GdkWindow *window,
1365                              GdkEventType type)
1366 {
1367   guint evmask;
1368   GdkModifierType mask;
1369   GdkWindow *w;
1370
1371   gdk_fb_mouse_get_info (NULL, NULL, &mask);
1372
1373   if (_gdk_fb_pointer_grab_window &&
1374       !_gdk_fb_pointer_grab_owner_events)
1375     {
1376       evmask = _gdk_fb_pointer_grab_events;
1377
1378       if (evmask & (GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK | GDK_BUTTON3_MOTION_MASK))
1379         {
1380           if (((mask & GDK_BUTTON1_MASK) && (evmask & GDK_BUTTON1_MOTION_MASK)) ||
1381               ((mask & GDK_BUTTON2_MASK) && (evmask & GDK_BUTTON2_MOTION_MASK)) ||
1382               ((mask & GDK_BUTTON3_MASK) && (evmask & GDK_BUTTON3_MOTION_MASK)))
1383             evmask |= GDK_POINTER_MOTION_MASK;
1384         }
1385
1386       if (evmask & type_masks[type])
1387         return _gdk_fb_pointer_grab_window;
1388       else
1389         return NULL;
1390     }
1391
1392   w = window;
1393   while (w != _gdk_parent_root)
1394     {
1395       /* Huge hack, so that we don't propagate events to GtkWindow->frame */
1396       if ((w != window) &&
1397           (GDK_WINDOW_P (w)->window_type != GDK_WINDOW_CHILD) &&
1398           (g_object_get_data (G_OBJECT (w), "gdk-window-child-handler")))
1399           break;
1400
1401       evmask = GDK_WINDOW_OBJECT(window)->event_mask;
1402
1403       if (evmask & (GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK | GDK_BUTTON3_MOTION_MASK))
1404         {
1405           if (((mask & GDK_BUTTON1_MASK) && (evmask & GDK_BUTTON1_MOTION_MASK)) ||
1406               ((mask & GDK_BUTTON2_MASK) && (evmask & GDK_BUTTON2_MOTION_MASK)) ||
1407               ((mask & GDK_BUTTON3_MASK) && (evmask & GDK_BUTTON3_MOTION_MASK)))
1408             evmask |= GDK_POINTER_MOTION_MASK;
1409         }
1410
1411       if (evmask & type_masks[type])
1412         return w;
1413
1414       w = gdk_window_get_parent (w);
1415     }
1416
1417   if (_gdk_fb_pointer_grab_window &&
1418       _gdk_fb_pointer_grab_owner_events)
1419     {
1420       evmask = _gdk_fb_pointer_grab_events;
1421
1422       if (evmask & (GDK_BUTTON1_MOTION_MASK | GDK_BUTTON2_MOTION_MASK | GDK_BUTTON3_MOTION_MASK))
1423         {
1424           if (((mask & GDK_BUTTON1_MASK) && (evmask & GDK_BUTTON1_MOTION_MASK)) ||
1425               ((mask & GDK_BUTTON2_MASK) && (evmask & GDK_BUTTON2_MOTION_MASK)) ||
1426               ((mask & GDK_BUTTON3_MASK) && (evmask & GDK_BUTTON3_MOTION_MASK)))
1427             evmask |= GDK_POINTER_MOTION_MASK;
1428         }
1429
1430       if (evmask & type_masks[type])
1431         return _gdk_fb_pointer_grab_window;
1432     }
1433
1434   return NULL;
1435 }
1436
1437 GdkWindow *
1438 gdk_fb_keyboard_event_window (GdkWindow *window,
1439                               GdkEventType type)
1440 {
1441   guint32 evmask;
1442   GdkWindow *w;
1443
1444   if (_gdk_fb_keyboard_grab_window &&
1445       !_gdk_fb_keyboard_grab_owner_events)
1446     {
1447       return _gdk_fb_keyboard_grab_window;
1448     }
1449
1450   w = window;
1451   while (w != _gdk_parent_root)
1452     {
1453       /* Huge hack, so that we don't propagate events to GtkWindow->frame */
1454       if ((w != window) &&
1455           (GDK_WINDOW_P (w)->window_type != GDK_WINDOW_CHILD) &&
1456           (g_object_get_data (G_OBJECT (w), "gdk-window-child-handler")))
1457           break;
1458
1459       evmask = GDK_WINDOW_OBJECT(window)->event_mask;
1460
1461       if (evmask & type_masks[type])
1462         return w;
1463
1464       w = gdk_window_get_parent (w);
1465     }
1466
1467   if (_gdk_fb_keyboard_grab_window &&
1468       _gdk_fb_keyboard_grab_owner_events)
1469     {
1470       return _gdk_fb_keyboard_grab_window;
1471     }
1472
1473   return NULL;
1474 }
1475
1476 GdkEvent *
1477 gdk_event_make (GdkWindow *window,
1478                 GdkEventType type,
1479                 gboolean append_to_queue)
1480 {
1481   GdkEvent *event = gdk_event_new (type);
1482   guint32 the_time;
1483
1484   the_time = gdk_fb_get_time ();
1485
1486   event->any.window = gdk_window_ref (window);
1487   event->any.send_event = FALSE;
1488   switch (type)
1489     {
1490     case GDK_MOTION_NOTIFY:
1491       event->motion.time = the_time;
1492       event->motion.axes = NULL;
1493       break;
1494     case GDK_BUTTON_PRESS:
1495     case GDK_2BUTTON_PRESS:
1496     case GDK_3BUTTON_PRESS:
1497     case GDK_BUTTON_RELEASE:
1498       event->button.time = the_time;
1499       event->button.axes = NULL;
1500       break;
1501     case GDK_KEY_PRESS:
1502     case GDK_KEY_RELEASE:
1503       event->key.time = the_time;
1504       break;
1505     case GDK_ENTER_NOTIFY:
1506     case GDK_LEAVE_NOTIFY:
1507       event->crossing.time = the_time;
1508       break;
1509
1510     case GDK_PROPERTY_NOTIFY:
1511       event->property.time = the_time;
1512       break;
1513
1514     case GDK_SELECTION_CLEAR:
1515     case GDK_SELECTION_REQUEST:
1516     case GDK_SELECTION_NOTIFY:
1517       event->selection.time = the_time;
1518       break;
1519     case GDK_PROXIMITY_IN:
1520     case GDK_PROXIMITY_OUT:
1521       event->proximity.time = the_time;
1522       break;
1523     case GDK_DRAG_ENTER:
1524     case GDK_DRAG_LEAVE:
1525     case GDK_DRAG_MOTION:
1526     case GDK_DRAG_STATUS:
1527     case GDK_DROP_START:
1528     case GDK_DROP_FINISHED:
1529       event->dnd.time = the_time;
1530       break;
1531
1532     case GDK_FOCUS_CHANGE:
1533     case GDK_CONFIGURE:
1534     case GDK_MAP:
1535     case GDK_UNMAP:
1536     case GDK_CLIENT_EVENT:
1537     case GDK_VISIBILITY_NOTIFY:
1538     case GDK_NO_EXPOSE:
1539     case GDK_SCROLL:
1540     case GDK_DELETE:
1541     case GDK_DESTROY:
1542     case GDK_EXPOSE:
1543     default:
1544       break;
1545     }
1546
1547   if (append_to_queue)
1548     _gdk_event_queue_append (gdk_display_get_default (), event);
1549
1550   return event;
1551 }
1552
1553 void
1554 gdk_fb_set_rotation (GdkFBAngle angle)
1555 {
1556   if (angle == _gdk_fb_screen_angle)
1557     return;
1558
1559 #ifdef ENABLE_SHADOW_FB
1560   if (gdk_display)
1561     {
1562       gdk_shadow_fb_stop_updates ();
1563
1564       gdk_fb_cursor_hide ();
1565
1566       _gdk_fb_screen_angle = angle;
1567
1568       if (angle % 2 == 0)
1569         {
1570           gdk_display->fb_width = gdk_display->modeinfo.xres;
1571           gdk_display->fb_height = gdk_display->modeinfo.yres;
1572         }
1573       else
1574         {
1575           gdk_display->fb_width = gdk_display->modeinfo.yres;
1576           gdk_display->fb_height = gdk_display->modeinfo.xres;
1577         }
1578       gdk_display->fb_stride =
1579         gdk_display->fb_width * (gdk_display->modeinfo.bits_per_pixel / 8);
1580
1581       gdk_fb_recompute_all();
1582       gdk_fb_redraw_all ();
1583
1584       gdk_fb_cursor_unhide ();
1585     }
1586   else
1587     _gdk_fb_screen_angle = angle;
1588 #else
1589   g_warning ("Screen rotation without shadow fb not supported.");
1590 #endif
1591 }
1592
1593 void
1594 gdk_error_trap_push (void)
1595 {
1596 }
1597
1598 gint
1599 gdk_error_trap_pop (void)
1600 {
1601   return 0;
1602 }
1603
1604 void
1605 gdk_notify_startup_complete (void)
1606 {
1607 }