/* GDK - The GIMP Drawing Kit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.

 */

/*

 * GTK+ DirectFB backend

 * Copyright (C) 2001-2002  convergence integrated media GmbH

 * Copyright (C) 2002-2004  convergence GmbH

 * Written by Denis Oliver Kropp <dok@convergence.de> and

 *            Sven Neumann <sven@convergence.de>

 */

#include "config.h"

#include "gdk.h"

#include "gdkdirectfb.h"

#include "gdkprivate-directfb.h"

#include "gdkinternals.h"

#include "gdkkeysyms.h"

#include "gdkinput-directfb.h"

#include <string.h>

#ifndef __GDK_X_H__

#define __GDK_X_H__

gboolean gdk_net_wm_supports (GdkAtom property);

#endif

#include "gdkalias.h"

#define EventBuffer _gdk_display->buffer

#define DirectFB _gdk_display->directfb

#include "gdkaliasdef.c"

D_DEBUG_DOMAIN (GDKDFB_Events, "GDKDFB/Events", "GDK DirectFB Events");

D_DEBUG_DOMAIN (GDKDFB_MouseEvents, "GDKDFB/Events/Mouse", "GDK DirectFB Mouse Events");

D_DEBUG_DOMAIN (GDKDFB_WindowEvents, "GDKDFB/Events/Window", "GDK DirectFB Window Events");

D_DEBUG_DOMAIN (GDKDFB_KeyEvents, "GDKDFB/Events/Key", "GDK DirectFB Key Events");

/*********************************************

 * Functions for maintaining the event queue *

 *********************************************/

static gboolean gdk_event_translate  (GdkEvent       *event,

                                      DFBWindowEvent *dfbevent,

                                      GdkWindow      *window);

/*

 * Private variable declarations

 */

static GList *client_filters;  /* Filters for client messages */

static gint

gdk_event_apply_filters (DFBWindowEvent *dfbevent,

                         GdkEvent *event,

                         GList *filters)

{

  GList *tmp_list;

  GdkFilterReturn result;

  tmp_list = filters;

  while (tmp_list)

    {

      GdkEventFilter *filter = (GdkEventFilter*) tmp_list->data;

      tmp_list = tmp_list->next;

      result = filter->function (dfbevent, event, filter->data);

      if (result !=  GDK_FILTER_CONTINUE)

        return result;

    }

  return GDK_FILTER_CONTINUE;

}

static void

dfb_events_process_window_event (DFBWindowEvent *dfbevent)

{

  GdkDisplay *display = gdk_display_get_default ();

  GdkWindow  *window;

  GdkEvent   *event;

  GList      *node;

  window = gdk_directfb_window_id_table_lookup (dfbevent->window_id);

  if (!window)

    return;

  event = gdk_event_new (GDK_NOTHING);

  event->any.window = NULL;

  ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;

  node = _gdk_event_queue_append (display, event);

  if (gdk_event_translate (event, dfbevent, window))

    {

      ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;

      _gdk_windowing_got_event (display, node, event, 0);

    }

  else

    {

      _gdk_event_queue_remove_link (display, node);

      g_list_free_1 (node);

      gdk_event_free (event);

    }

}

static gboolean

gdk_event_send_client_message_by_window (GdkEvent *event,

                                         GdkWindow *window)

{

  DFBUserEvent evt;

  g_return_val_if_fail(event != NULL, FALSE);

  g_return_val_if_fail(GDK_IS_WINDOW(window), FALSE);

  evt.clazz = DFEC_USER;

  evt.type = GPOINTER_TO_UINT (GDK_ATOM_TO_POINTER (event->client.message_type));

  evt.data = (void *) event->client.data.l[0];

  _gdk_display->buffer->PostEvent (_gdk_display->buffer, DFB_EVENT (&evt));

  return TRUE;

}

static void

dfb_events_dispatch (void)

{

  GdkDisplay *display = gdk_display_get_default ();

  GdkEvent   *event;

  GDK_THREADS_ENTER ();

  while ((event = _gdk_event_unqueue (display)) != NULL)

    {

      if (_gdk_event_func)

        (*_gdk_event_func) (event, _gdk_event_data);

      gdk_event_free (event);

    }

  GDK_THREADS_LEAVE ();

}

static gboolean

dfb_events_io_func (GIOChannel   *channel,

                    GIOCondition  condition,

                    gpointer      data)

{

  gsize      i;

  gsize      read;

  GIOStatus  result;

  DFBEvent   buf[23];

  DFBEvent  *event;

  result = g_io_channel_read_chars (channel,

                                    (gchar *) buf, sizeof (buf), &read, NULL);

  if (result == G_IO_STATUS_ERROR)

    {

      g_warning ("%s: GIOError occured", G_STRFUNC);

      return TRUE;

    }

  read /= sizeof (DFBEvent);

  for (i = 0, event = buf; i < read; i++, event++)

    {

      switch (event->clazz)

        {

        case DFEC_WINDOW:

          /* TODO workaround to prevent two DWET_ENTER in a row from being delivered */

          if (event->window.type == DWET_ENTER) {

            if (i > 0 && buf[i - 1].window.type != DWET_ENTER)

              dfb_events_process_window_event (&event->window);

          }

          else

            dfb_events_process_window_event (&event->window);

          break;

        case DFEC_USER:

          {

            GList *list;

            GDK_NOTE (EVENTS, g_print (" client_message"));

            for (list = client_filters; list; list = list->next)

              {

                GdkClientFilter *filter     = list->data;

                DFBUserEvent    *user_event = (DFBUserEvent *) event;

                GdkAtom          type;

                type = GDK_POINTER_TO_ATOM (GUINT_TO_POINTER (user_event->type));

                if (filter->type == type)

                  {

                    if (filter->function (user_event,

                                          NULL,

                                          filter->data) != GDK_FILTER_CONTINUE)

                      break;

                  }

              }

          }

          break;

        default:

          break;

        }

    }

  EventBuffer->Reset (EventBuffer);

  dfb_events_dispatch ();

  return TRUE;

}

void

_gdk_events_init (void)

{

  GIOChannel *channel;

  GSource    *source;

  DFBResult   ret;

  gint        fd;

  ret = DirectFB->CreateEventBuffer (DirectFB, &EventBuffer);

  if (ret)

    {

      DirectFBError ("_gdk_events_init: "

                     "IDirectFB::CreateEventBuffer() failed", ret);

      return;

    }

  ret = EventBuffer->CreateFileDescriptor (EventBuffer, &fd;;

  if (ret)

    {

      DirectFBError ("_gdk_events_init: "

                     "IDirectFBEventBuffer::CreateFileDescriptor() failed",

                     ret);

      return;

    }

  channel = g_io_channel_unix_new (fd);

  g_io_channel_set_encoding (channel, NULL, NULL);

  g_io_channel_set_buffered (channel, FALSE);

  source = g_io_create_watch (channel, G_IO_IN);

  g_source_set_priority (source, G_PRIORITY_DEFAULT);

  g_source_set_can_recurse (source, TRUE);

  g_source_set_callback (source, (GSourceFunc) dfb_events_io_func, NULL, NULL);

  g_source_attach (source, NULL);

  g_source_unref (source);

}

gboolean

gdk_events_pending (void)

{

  GdkDisplay *display = gdk_display_get_default ();

  return _gdk_event_queue_find_first (display) ? TRUE : FALSE;

}

GdkEvent *

gdk_event_get_graphics_expose (GdkWindow *window)

{

  GdkDisplay *display;

  GList      *list;

  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);

  display = gdk_drawable_get_display (GDK_DRAWABLE (window));

  for (list = _gdk_event_queue_find_first (display); list; list = list->next)

    {

      GdkEvent *event = list->data;

      if (event->type == GDK_EXPOSE && event->expose.window == window)

        break;

    }

  if (list)

    {

      GdkEvent *retval = list->data;

      _gdk_event_queue_remove_link (display, list);

      g_list_free_1 (list);

      return retval;

    }

  return NULL;

}

void

_gdk_events_queue (GdkDisplay *display)

{

}

void

gdk_flush (void)

{

  gdk_display_flush (GDK_DISPLAY_OBJECT (_gdk_display));

}

/* Sends a ClientMessage to all toplevel client windows */

gboolean

gdk_event_send_client_message_for_display (GdkDisplay *display,

                                           GdkEvent   *event,

                                           guint32     xid)

{

  GdkWindow *win = NULL;

  gboolean ret = TRUE;

  g_return_val_if_fail (event != NULL, FALSE);

  win = gdk_window_lookup_for_display (display, (GdkNativeWindow) xid);

  g_return_val_if_fail (win != NULL, FALSE);

  if ((GDK_WINDOW_OBJECT (win)->window_type != GDK_WINDOW_CHILD) &&

      (g_object_get_data (G_OBJECT (win), "gdk-window-child-handler")))

    {

      /* Managed window, check children */

      GList *ltmp = NULL;

      for (ltmp = GDK_WINDOW_OBJECT (win)->children; ltmp; ltmp = ltmp->next)

        {

          ret &= gdk_event_send_client_message_by_window (event,

                                                          GDK_WINDOW(ltmp->data));

        }

    }

  else

    {

      ret &= gdk_event_send_client_message_by_window (event, win);

    }

  return ret;

}

/*****/

guint32

gdk_directfb_get_time (void)

{

  GTimeVal tv;

  g_get_current_time (&tv;;

  return (guint32) tv.tv_sec * 1000 + tv.tv_usec / 1000;

}

void

gdk_directfb_event_windows_add (GdkWindow *window)

{

  GdkWindowImplDirectFB *impl;

  g_return_if_fail (GDK_IS_WINDOW (window));

  impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);

  if (!impl->window)

    return;

  if (EventBuffer)

    impl->window->AttachEventBuffer (impl->window, EventBuffer);

  else

    impl->window->CreateEventBuffer (impl->window, &EventBuffer);

}

void

gdk_directfb_event_windows_remove (GdkWindow *window)

{

  GdkWindowImplDirectFB *impl;

  g_return_if_fail (GDK_IS_WINDOW (window));

  impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);

  if (!impl->window)

    return;

  if (EventBuffer)

    impl->window->DetachEventBuffer (impl->window, EventBuffer);

  /* FIXME: should we warn if (! EventBuffer) ? */

}

GdkWindow *

gdk_directfb_child_at (GdkWindow *window,

                       gint      *winx,

                       gint      *winy)

{

  GdkWindowObject *private;

  GList           *list;

  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);

  private = GDK_WINDOW_OBJECT (window);

  for (list = private->children; list; list = list->next)

    {

      GdkWindowObject *win = list->data;

      gint wx, wy, ww, wh;

      gdk_window_get_geometry (GDK_WINDOW (win), &wx, &wy, &ww, &wh, NULL);

      if (GDK_WINDOW_IS_MAPPED (win) &&

          *winx >= wx  && *winx <  wx + ww  &&

          *winy >= wy  && *winy <  wy + wh)

        {

          *winx -= win->x;

          *winy -= win->y;

          return gdk_directfb_child_at (GDK_WINDOW (win), winx, winy);

        }

    }

  return window;

}

static gboolean

gdk_event_translate (GdkEvent       *event,

                     DFBWindowEvent *dfbevent,

                     GdkWindow      *window)

{

  GdkWindowObject *private;

  GdkDisplay      *display;

  /* GdkEvent        *event    = NULL; */

  gboolean return_val = FALSE;

  g_return_val_if_fail (event != NULL, FALSE);

  g_return_val_if_fail (dfbevent != NULL, FALSE);

  g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);

  D_DEBUG_AT (GDKDFB_Events, "%s( %p, %p, %p )\n", G_STRFUNC,

              event, dfbevent, window);

  private = GDK_WINDOW_OBJECT (window);

  g_object_ref (G_OBJECT (window));

  event->any.window = NULL;

  event->any.send_event = FALSE;

  /*

   * Apply global filters

   *

   * If result is GDK_FILTER_CONTINUE, we continue as if nothing

   * happened. If it is GDK_FILTER_REMOVE or GDK_FILTER_TRANSLATE,

   * we return TRUE and won't dispatch the event.

   */

  if (_gdk_default_filters)

    {

      GdkFilterReturn result;

      result = gdk_event_apply_filters (dfbevent, event, _gdk_default_filters);

      if (result != GDK_FILTER_CONTINUE)

        {

          return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;

          goto done;

        }

    }

  /* Apply per-window filters */

  if (GDK_IS_WINDOW (window))

    {

      GdkFilterReturn result;

      if (private->filters)

	{

	  result = gdk_event_apply_filters (dfbevent, event, private->filters);

	  if (result != GDK_FILTER_CONTINUE)

	    {

	      return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;

	      goto done;

	    }

	}

    }

  display = gdk_drawable_get_display (GDK_DRAWABLE (window));

  return_val = TRUE;

  switch (dfbevent->type)

    {

    case DWET_BUTTONDOWN:

    case DWET_BUTTONUP:

      /* Backend store */

      _gdk_directfb_mouse_x = dfbevent->cx;

      _gdk_directfb_mouse_y = dfbevent->cy;

      /* Event translation */

      gdk_directfb_event_fill (event, window,

                               dfbevent->type == DWET_BUTTONDOWN ?

                               GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);

      switch (dfbevent->button)

        {

        case DIBI_LEFT:

          event->button.button = 1;

          break;

        case DIBI_MIDDLE:

            event->button.button = 2;

            break;

        case DIBI_RIGHT:

          event->button.button = 3;

          break;

          default:

            event->button.button = dfbevent->button + 1;

            break;

        }

      event->button.window = window;

      event->button.x_root = dfbevent->cx;

      event->button.y_root = dfbevent->cy;

      event->button.x      = dfbevent->x;

      event->button.y      = dfbevent->y;

      event->button.state  = _gdk_directfb_modifiers;

      event->button.device = display->core_pointer;

      gdk_event_set_screen (event, _gdk_screen);

      D_DEBUG_AT (GDKDFB_MouseEvents, "  -> %s at %ix%i\n",

                  event->type == GDK_BUTTON_PRESS ? "buttonpress" : "buttonrelease",

                  (gint) event->button.x, (gint) event->button.y);

      break;

    case DWET_MOTION:

      /* Backend store */

      _gdk_directfb_mouse_x = dfbevent->cx;

      _gdk_directfb_mouse_y = dfbevent->cy;

      /* Event translation */

      gdk_directfb_event_fill (event, window, GDK_MOTION_NOTIFY);

      event->motion.x_root  = dfbevent->cx;

      event->motion.y_root  = dfbevent->cy;

      event->motion.x       = dfbevent->x;

      event->motion.y       = dfbevent->y;

      event->motion.axes    = NULL;

      event->motion.state   = _gdk_directfb_modifiers;

      event->motion.is_hint = FALSE;

      event->motion.device  = display->core_pointer;

      gdk_event_set_screen (event, _gdk_screen);

      D_DEBUG_AT (GDKDFB_MouseEvents, "  -> move pointer to %ix%i\n",

                  (gint) event->button.x, (gint) event->button.y);

      break;

    case DWET_GOTFOCUS:

      gdk_directfb_event_fill (event, window, GDK_FOCUS_CHANGE);

      event->focus_change.window = window;

      event->focus_change.in     = TRUE;

      break;

    case DWET_LOSTFOCUS:

      gdk_directfb_event_fill (event, window, GDK_FOCUS_CHANGE);

      event->focus_change.window = window;

      event->focus_change.in     = FALSE;

      break;

    case DWET_POSITION:

      gdk_directfb_event_fill (event, window, GDK_CONFIGURE);

      event->configure.x      = dfbevent->x;

      event->configure.y      = dfbevent->y;

      event->configure.width  = private->width;

      event->configure.height = private->height;

      break;

    case DWET_POSITION_SIZE:

      event->configure.x = dfbevent->x;

      event->configure.y = dfbevent->y;

      /* fallthru */

    case DWET_SIZE:

      gdk_directfb_event_fill (event, window, GDK_CONFIGURE);

      event->configure.window = window;

      event->configure.width  = dfbevent->w;

      event->configure.height = dfbevent->h;

      D_DEBUG_AT (GDKDFB_WindowEvents,

                  "  -> configure window %p at %ix%i-%ix%i\n",

                  window, event->configure.x, event->configure.y,

                  event->configure.width, event->configure.height);

      break;

    case DWET_KEYDOWN:

    case DWET_KEYUP:

      gdk_directfb_event_fill (event, window,

                               dfbevent->type == DWET_KEYUP ?

                               GDK_KEY_RELEASE : GDK_KEY_PRESS);

      event->key.window = window;

      gdk_directfb_translate_key_event (dfbevent, (GdkEventKey *) event);

      D_DEBUG_AT (GDKDFB_KeyEvents, "  -> key window=%p val=%x code=%x str=%s\n",

                  window,  event->key.keyval, event->key.hardware_keycode,

                  event->key.string);

      break;

    case DWET_ENTER:

    case DWET_LEAVE:

      /* Backend store */

      _gdk_directfb_mouse_x = dfbevent->cx;

      _gdk_directfb_mouse_y = dfbevent->cy;

      /* Event translation */

      gdk_directfb_event_fill (event, window,

                               dfbevent->type == DWET_ENTER ?

                               GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY);

      event->crossing.window    = g_object_ref (window);

      event->crossing.subwindow = NULL;

      event->crossing.time      = GDK_CURRENT_TIME;

      event->crossing.x         = dfbevent->x;

      event->crossing.y         = dfbevent->y;

      event->crossing.x_root    = dfbevent->cx;

      event->crossing.y_root    = dfbevent->cy;

      event->crossing.mode      = GDK_CROSSING_NORMAL;

      event->crossing.detail    = GDK_NOTIFY_ANCESTOR;

      event->crossing.state     = 0;

      /**/

      if (gdk_directfb_apply_focus_opacity)

        {

          if (dfbevent->type == DWET_ENTER)

            {

              if (GDK_WINDOW_IS_MAPPED (window))

                GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window->SetOpacity

                  (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window,

                   (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity >> 1) +

                   (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity >> 2));

            }

          else

            {

              GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window->SetOpacity

                (GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window,

                 GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity);

            }

        }

      D_DEBUG_AT (GDKDFB_WindowEvents, "  -> %s window %p at relative=%ix%i absolute=%ix%i\n",

                  dfbevent->type == DWET_ENTER ? "enter" : "leave",

                  window, (gint) event->crossing.x, (gint) event->crossing.y,

                  (gint) event->crossing.x_root, (gint) event->crossing.y_root);

      break;

    case DWET_CLOSE:

      gdk_directfb_event_fill (event, window, GDK_DELETE);

      break;

    case DWET_DESTROYED:

      gdk_directfb_event_fill (event, window, GDK_DESTROY);

      gdk_window_destroy_notify (window);

      break;

    case DWET_WHEEL:

      /* Backend store */

      _gdk_directfb_mouse_x = dfbevent->cx;

      _gdk_directfb_mouse_y = dfbevent->cy;

      /* Event translation */

      gdk_directfb_event_fill (event, window, GDK_SCROLL);

      event->scroll.direction = (dfbevent->step > 0 ?

                                 GDK_SCROLL_UP : GDK_SCROLL_DOWN);

      event->scroll.x_root    = dfbevent->cx;

      event->scroll.y_root    = dfbevent->cy;

      event->scroll.x         = dfbevent->x;

      event->scroll.y         = dfbevent->y;

      event->scroll.state     = _gdk_directfb_modifiers;

      event->scroll.device    = display->core_pointer;

      D_DEBUG_AT (GDKDFB_MouseEvents, "  -> mouse scroll %s at %ix%i\n",

                  event->scroll.direction == GDK_SCROLL_UP ? "up" : "down",

                  (gint) event->scroll.x, (gint) event->scroll.y);

      break;

    default:

      g_message ("unhandled DirectFB windowing event 0x%08x", dfbevent->type);

    }

 done:

  g_object_unref (G_OBJECT (window));

  return return_val;

}

gboolean

gdk_screen_get_setting (GdkScreen   *screen,

                        const gchar *name,

                        GValue      *value)

{

  return FALSE;

}

void

gdk_display_add_client_message_filter (GdkDisplay   *display,

                                       GdkAtom       message_type,

                                       GdkFilterFunc func,

                                       gpointer      data)

{

  /* XXX: display should be used */

  GdkClientFilter *filter = g_new (GdkClientFilter, 1);

  filter->type = message_type;

  filter->function = func;

  filter->data = data;

  client_filters = g_list_append (client_filters, filter);

}

void

gdk_add_client_message_filter (GdkAtom       message_type,

                               GdkFilterFunc func,

                               gpointer      data)

{

  gdk_display_add_client_message_filter (gdk_display_get_default (),

                                         message_type, func, data);

}

void

gdk_screen_broadcast_client_message (GdkScreen *screen,

				     GdkEvent  *sev)

{

  GdkWindow       *root_window;

  GdkWindowObject *private;

  GList           *top_level = NULL;

  g_return_if_fail (GDK_IS_SCREEN (screen));

  g_return_if_fail (sev != NULL);

  root_window = gdk_screen_get_root_window (screen);

  g_return_if_fail (GDK_IS_WINDOW (root_window));

  private = GDK_WINDOW_OBJECT (root_window);

  for (top_level = private->children; top_level; top_level = top_level->next)

    {

      gdk_event_send_client_message_for_display (gdk_drawable_get_display (GDK_DRAWABLE (root_window)),

                                                 sev,

                                                 (guint32)(GDK_WINDOW_DFB_ID (GDK_WINDOW (top_level->data))));

    }

}

/**

 * gdk_net_wm_supports:

 * @property: a property atom.

 *

 * This function is specific to the X11 backend of GDK, and indicates

 * whether the window manager for the default screen supports a certain

 * hint from the Extended Window Manager Hints Specification. See

 * gdk_x11_screen_supports_net_wm_hint() for complete details.

 *

 * Return value: %TRUE if the window manager supports @property

 **/

gboolean

gdk_net_wm_supports (GdkAtom property)

{

  return FALSE;

}

void

_gdk_windowing_event_data_copy (const GdkEvent *src,

                                GdkEvent       *dst)

{

}

void

_gdk_windowing_event_data_free (GdkEvent *event)

{

}

#define __GDK_EVENTS_X11_C__

#include "gdkaliasdef.c"