AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

directfb: Remove

Browse Source 
As announced by email and on IRC, this backend is removed from GTK 3.
It has been broken for over a year with no one fixing it.
This commit is contained in:
Benjamin Otte 2010-08-23 12:44:58 +02:00
parent 7eabb8fd3c
commit 8856bfc60e
45 changed files with 10 additions and 14104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
configure.ac
View File

@ -257,13 +257,13 @@ else
gdktarget=x11
fi
AC_ARG_WITH(gdktarget, [ --with-gdktarget=[[x11/win32/quartz/directfb]] select non-default GDK target],
AC_ARG_WITH(gdktarget, [ --with-gdktarget=[[x11/win32/quartz]] select non-default GDK target],
gdktarget=$with_gdktarget)
AC_SUBST(gdktarget)
case $gdktarget in
x11|win32|quartz|directfb) ;;
*) AC_MSG_ERROR([Invalid target for GDK: use x11, quartz, directfb or win32.]);;
x11|win32|quartz) ;;
*) AC_MSG_ERROR([Invalid target for GDK: use x11, quartz or win32.]);;
esac
gdktargetlib=libgdk-$gdktarget-$GTK_API_VERSION.la
@ -1248,17 +1248,6 @@ else
AM_CONDITIONAL(USE_QUARTZ, false)
fi
if test "x$gdktarget" = "xdirectfb"; then
DIRECTFB_REQUIRED_VERSION=1.0.0
AC_MSG_CHECKING(for DirectFB)
PKG_CHECK_MODULES(DIRECTFB, [directfb >= $DIRECTFB_REQUIRED_VERSION])
AM_CONDITIONAL(USE_DIRECTFB, true)
else
AM_CONDITIONAL(USE_DIRECTFB, false)
fi
# Check for Pango flags
if test "x$gdktarget" = "xwin32"; then
@ -1652,9 +1641,6 @@ elif test "x$gdktarget" = "xwin32" ; then
elif test "x$gdktarget" = "xquartz" ; then
gdk_windowing='
#define GDK_WINDOWING_QUARTZ'
elif test "x$gdktarget" = "xdirectfb" ; then
gdk_windowing='
#define GDK_WINDOWING_DIRECTFB'
fi
if test x$gdk_wchar_h = xyes; then
@ -1730,7 +1716,6 @@ gdk/win32/Makefile
gdk/win32/rc/Makefile
gdk/win32/rc/gdk.rc
gdk/quartz/Makefile
gdk/directfb/Makefile
gdk/tests/Makefile
gtk/Makefile
gtk/makefile.msc

1
docs/reference/gdk/Makefile.am
View File

@ -29,7 +29,6 @@ IGNORE_HFILES= \
gdkpoly-generic.h \
keyname-table.h \
win32 \
directfb \
x11 \
quartz

1
docs/reference/gdk/gdk3-sections.txt
View File

@ -52,7 +52,6 @@ gdk_error_trap_pop
GDK_WINDOWING_X11
GDK_WINDOWING_WIN32
GDK_WINDOWING_QUARTZ
GDK_WINDOWING_DIRECTFB
<SUBSECTION Standard>
GDK_TYPE_GRAB_STATUS

1
docs/reference/gtk/Makefile.am
View File

@ -117,7 +117,6 @@ content_files = \
running.sgml \
building.sgml \
compiling.sgml \
directfb.sgml \
drawing-model.xml \
glossary.xml \
migrating-2to3.xml \

5
docs/reference/gtk/building.sgml
View File

@ -361,7 +361,7 @@ How to compile GTK+ itself
<arg>--with-xinput=[no|yes]</arg>
</group>
<group>
<arg>--with-gdktarget=[x11|win32|quartz|directfb]</arg>
<arg>--with-gdktarget=[x11|win32|quartz]</arg>
</group>
<group>
<arg>--disable-introspection</arg>
@ -551,8 +551,7 @@ How to compile GTK+ itself
Toggles between the supported backends for GDK.
The default is x11, unless the platform is Windows, in which
case the default is win32. Other supported backends are
the quartz backend for OS X, and the DirectFB backend
for the Linux framebuffer.
the quartz backend for OS X.
</para>
</formalpara>
<formalpara>

44
docs/reference/gtk/directfb.sgml
View File

@ -1,44 +0,0 @@
<?xml version="1.0"?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
"http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
]>
<refentry id="gtk-directfb">
<refmeta>
<refentrytitle>Using GTK+ on DirectFB</refentrytitle>
<manvolnum>3</manvolnum>
<refmiscinfo>GTK Library</refmiscinfo>
</refmeta>
<refnamediv>
<refname>Using GTK+ on DirectFB</refname>
<refpurpose>
DirectFB-specific aspects of using GTK+
</refpurpose>
</refnamediv>
<refsect1>
<title>Using GTK+ on DirectFB</title>
<para>
The DirectFB port of GTK+ is an implementation of GDK (and therefore GTK+)
on top of the <ulink url="http://www.directfb.org">DirectFB</ulink>
libraries.
</para>
<para>
Like the obsolete linux-fb port of GTK+, it runs on the Linux framebuffer,
but the DirectFB libraries provide additional features like hardware graphics
acceleration, input device handling and abstraction and an integrated windowing
system.
</para>
<refsect2><title>Build requirements</title>
<para>
Beyond the usual GTK+ build requirements, the DirectFB backend (obviously)
needs the DirectFB libraries (at least 0.9.21) and cairo compiled with
DirectFB support.
</para>
</refsect2>
</refsect1>
</refentry>

1
docs/reference/gtk/gtk-docs.sgml
View File

@ -119,7 +119,6 @@ that is, GUI components such as #GtkButton or #GtkTextView.
<xi:include href="x11.sgml" />
<xi:include href="windows.sgml" />
<xi:include href="osx.sgml" />
<xi:include href="directfb.sgml" />
<xi:include href="resources.sgml" />
<xi:include href="xml/question_index.sgml" />
<xi:include href="drawing-model.xml" />

8
gdk/Makefile.am
View File

@ -9,7 +9,7 @@ INTROSPECTION_COMPILER_ARGS = \
--includedir=.
SUBDIRS = $(gdktarget) . tests
DIST_SUBDIRS = win32 x11 quartz directfb tests
DIST_SUBDIRS = win32 x11 quartz tests
CLEANFILES =
@ -155,10 +155,6 @@ common_sources = \
gdkmarshalers.c \
gdkmarshalers.h
libgdk_directfb_3_0_la_SOURCES = $(common_sources)
libgdk_directfb_3_0_la_LIBADD = directfb/libgdk-directfb.la $(GDK_DEP_LIBS)
libgdk_directfb_3_0_la_LDFLAGS = $(LDADD)
libgdk_x11_3_0_la_SOURCES = $(common_sources)
libgdk_x11_3_0_la_LIBADD = x11/libgdk-x11.la $(GDK_DEP_LIBS)
libgdk_x11_3_0_la_LDFLAGS = $(LDADD)
@ -286,7 +282,7 @@ endif
lib_LTLIBRARIES = $(gdktargetlib)
EXTRA_LTLIBRARIES = libgdk-x11-3.0.la libgdk-win32-3.0.la libgdk-quartz-3.0.la libgdk-directfb-3.0.la
EXTRA_LTLIBRARIES = libgdk-x11-3.0.la libgdk-win32-3.0.la libgdk-quartz-3.0.la
MAINTAINERCLEANFILES = $(gdk_built_sources) stamp-gdkenumtypes.h
EXTRA_DIST += $(gdk_built_sources)

28
gdk/directfb/AUTHORS
View File

@ -1,28 +0,0 @@
The GDK DirectFB backend was written by
Denis Oliver Kropp <dok@directfb.org>
Sven Neumann <neo@directfb.org>
Large parts of the code are based on other GDK backends
especially the linuxfb backend which was written mainly
by Alex Larsson <alexl@redhat.com>.
The upgrade to gtk 2.8.x was done by
Michael Emmel <mike.emmel@gmail.com>
Extensive help and support and code was recieved from the Debian
community especially the Debian installer team who bravely chose to
use the gdk directfb port for the graphical debian installer. In
particular
Attilio Fiandrotti <fiandro@tiscalinet.it>
Davide Viti <zinosat@tiscali.it>
for there tireless work bringing the backend from a small project to
stability.
And finally thanks to the Extremadura goverment for bringing the
directfb developers and debian installer team together for a workshop.

57
gdk/directfb/Makefile.am
View File

@ -1,57 +0,0 @@
## Makefile.am for gtk+/gdk/gdk-directfb
include $(top_srcdir)/Makefile.decl
libgdkincludedir = $(includedir)/gtk-3.0/gdk
INCLUDES = \
-DG_LOG_DOMAIN=\"Gdk-DirectFB\" \
-DGDK_COMPILATION \
-I$(top_srcdir) \
-I$(top_srcdir)/gdk \
-I$(top_builddir)/gdk \
-DG_DISABLE_DEPRECATED \
@GTK_DEBUG_FLAGS@ \
@GDK_DEP_CFLAGS@
LDADDS = \
@GDK_DEP_LIBS@
noinst_LTLIBRARIES = libgdk-directfb.la
libgdk_directfb_la_SOURCES = \
gdkapplaunchcontext-directfb.c \
gdkcolor-directfb.c \
gdkcursor-directfb.c \
gdkdnd-directfb.c \
gdkdisplay-directfb.c \
gdkdisplay-directfb.h \
gdkdrawable-directfb.c \
gdkevents-directfb.c \
gdkgeometry-directfb.c \
gdkglobals-directfb.c \
gdkim-directfb.c \
gdkinput-directfb.c \
gdkinput-directfb.h \
gdkkeys-directfb.c \
gdkmain-directfb.c \
gdkpixmap-directfb.c \
gdkprivate-directfb.h \
gdkproperty-directfb.c \
gdkscreen-directfb.c \
gdkselection-directfb.c \
gdkspawn-directfb.c \
gdktestutils-directfb.c \
gdkvisual-directfb.c \
gdkdirectfb.h \
gdkwindow-directfb.c \
gdkwindowid.c \
x-cursors.xbm
libgdkinclude_HEADERS = \
gdkdirectfb.h \
gdkprivate-directfb.h
EXTRA_DIST += AUTHORS README TODO
-include $(top_srcdir)/git.mk

106
gdk/directfb/README
View File

@ -1,106 +0,0 @@
README for GDK-DirectFB
------------------------
This is the GDK backend that allows GTK to work on top of DirectFB.
Important:
The current code does not pass through directfb passed on the gtk
apps command line on to directfb you need to set the environment variable
DFBARGS.
Example:
export DFBARGS=system=sdl
DirectFB is a hardware abstraction layer on top of the Linux
frame buffer that provides drawing functions, a window stack and
support for input devices. The code you find here is a backend for
GDK, the drawing kit used by GTK+.
As DirectFB provides drawing functions, a windowing stack and manages
input devices, this is a lightweight GDK port. Some parts of GDK
require higher level drawing functions that are supported by
cairo on DirectFB.
GDK also uses some feature like bitmaps that do not map well to
modern graphics hardware and are for that reason not yet supported in
this snapshot. See the file TODO for a list of missing features.
If you want GTK+ to draw window decorations for you, edit the file
gtk/gtkwindow-decorate.c and uncomment the line that says
#define DECORATE_WINDOWS.
GTK+ application compiled with this version of GTK+ understand some
additional command-line options special to the DirectFB GDK backend:
--transparent-unfocused Makes unfocused windows translucent.
--argb-font Use ARGB surfaces for fonts, needed for some
broken hardware.
--glyph-surface-cache Lets you tune the size of the glyph cache,
the default is to cache glyphs from 8 faces.
--enable-color-keying This option turns on a hack that does the
following:
(1) It overrides the color used to draw the window background to
gdk_directfb_bg_color as defined in gdkprivate-directfb.h.
Note that the alpha value only takes effect if the window has
an alpha channel.
(2) It also draws all rectangles that are drawn in
gdk_directfb_bg_color_key in this color (gdk_directfb_bg_color).
This feature can be used to create windows with translucent background.
Additionally all DirectFB command-line options as described in the
directfbrc man-page are supported.
This version of GTK+ also introduces two new functions that are special
to the DirectFB version. You need to include gdk/gdkdirectfb.h to be
able to use them.
gdk_directfb_window_set_opacity (GdkWindow *window, guchar opacity));
This function sets the overall opacity for toplevel GDK windows.
gdk_directfb_visual_by_format (DFBSurfacePixelFormat pixel_format);
This function returns a GdkVisual for a DirectFB pixelformat and
thus gives you control over the window surface. If for example
you want to create a window with alpha channel you can use some
code like the following:
visual = gdk_directfb_visual_by_format (DSPF_ARGB);
cmap = gdk_colormap_new (visual, FALSE);
gtk_widget_push_colormap (cmap);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_pop_colormap ();
g_object_unref (cmap);
Don't use these functions if you want to be able to compile your
application against GTK+-X11 or other GTK+ versions.
If you are developing a GTK+ application for GTK+-DirectFB make sure
you use the gtk+-directfb-2.0.pc file when calling pkg-config to get
the correct compiler and linker flags for GTK+-DirectFB:
pkg-config --cflags gtk+-directfb-2.0
pkg-config --libs gtk+-directfb-2.0
See the file TODO for a list of unimplemented features.
Detailed and up-to-date instructions on how to build a complete
set of GTK-DFB libraries is avalable in the WIKI of the DirectFB project
at the address
http://www.directfb.org/wiki/index.php/Projects:GTK_on_DirectFB
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.

56
gdk/directfb/TODO
View File

@ -1,56 +0,0 @@
A list of missing things and known bugs in the DirectFB GDK backend:
- Implement more GDK drawing functions. The most important ones
(including XOR) do work now. Other drawing functions are rarely
used and would need support from DirectFB.
- Implemenent extended input devices. Shouldn't be too hard.
- Look into DND and selections. DND seems to work inside one
application at least.
- Consider using the recently added glyph cache in PangoFT2 to
implement our glyph surface cache. Probably limit the number
of cached glyphs or the size of the surface cache instead of
keeping all glyphs from a number of fonts in the cache.
Some things that will probably never happen:
- Line styles, joining and related stuff. We could use code from the
LinuxFB backend but it seems to be bloat for most applications.
Implementing dashed lines would probably make sense and shouldn't
be too hard.
- Bitmaps (they are partly supported) and masks. This stuff should
be entirely deprecated. Use real alpha channels instead!
This is a simple list of unimplemented function stubs and there file
to see the implementation check the x11 dir.
Its not started yet.
gdkcolor-directfb.c
gdkcursor-directfb.c
gdkdisplay-directfb.c
gdkdnd-directfb.c
gdkdrawable-directfb.c
gdkevents-directfb.c
gdkgc-directfb.c
gdkgeometry-directfb.c
gdkglobals-directfb.c
gdkim-directfb.c
gdkinput-directfb.c
gdkkeys-directfb.c
gdk_keymap_lookup_key
gdk_keyval_convert_case
gdkmain-directfb.c
gdkpixmap-directfb.c
gdkproperty-directfb.c
gdkscreen-directfb.c
gdkselection-directfb.c
gdkspawn-directfb.c
gdkvisual-directfb.c
gdkwindow-directfb.c
gdkwindowid.c
glyphsurfacecache.c
NOTES:
event filter callbacks missing see the x11 impl

42
gdk/directfb/gdkapplaunchcontext-directfb.c
View File

@ -1,42 +0,0 @@
/* gdkapplaunchcontext-directfb.c - Gtk+ implementation for GAppLaunchContext
Copyright (C) 2007 Red Hat, Inc.
The Gnome Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The Gnome 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the Gnome Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
Author: Matthias Clasen <mclasen@redhat.com>
*/
#include "config.h"
#include "gdkapplaunchcontext.h"
char *
_gdk_windowing_get_startup_notify_id (GAppLaunchContext *context,
GAppInfo *info,
GList *files)
{
return NULL;
}
void
_gdk_windowing_launch_failed (GAppLaunchContext *context,
const char *startup_notify_id)
{
}

463
gdk/directfb/gdkcolor-directfb.c
View File

@ -1,463 +0,0 @@
/* 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 convergence GmbH
* Written by Denis Oliver Kropp <dok@convergence.de> and
* Sven Neumann <sven@convergence.de>
*/
#include "config.h"
#include "gdk.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "gdkcolor.h"
#include "gdkinternals.h"
#include "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
typedef struct {
GdkColorInfo *info;
IDirectFBPalette *palette;
} GdkColormapPrivateDirectFB;
static void gdk_colormap_finalize (GObject *object);
static gint gdk_colormap_alloc_pseudocolors (GdkColormap *colormap,
GdkColor *colors,
gint ncolors,
gboolean writeable,
gboolean best_match,
gboolean *success);
static void gdk_directfb_allocate_color_key (GdkColormap *colormap);
G_DEFINE_TYPE (GdkColormap, gdk_colormap, G_TYPE_OBJECT)
static void
gdk_colormap_init (GdkColormap *colormap)
{
colormap->size = 0;
colormap->colors = NULL;
colormap->windowing_data = NULL;
}
static void
gdk_colormap_class_init (GdkColormapClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gdk_colormap_finalize;
}
static void
gdk_colormap_finalize (GObject *object)
{
GdkColormap *colormap = GDK_COLORMAP (object);
GdkColormapPrivateDirectFB *private = colormap->windowing_data;
g_free (colormap->colors);
if (private)
{
g_free (private->info);
if (private->palette)
private->palette->Release (private->palette);
g_free (private);
colormap->windowing_data = NULL;
}
G_OBJECT_CLASS (gdk_colormap_parent_class)->finalize (object);
}
GdkColormap*
gdk_colormap_new (GdkVisual *visual,
gboolean private_cmap)
{
GdkColormap *colormap;
gint i;
g_return_val_if_fail (visual != NULL, NULL);
colormap = g_object_new (gdk_colormap_get_type (), NULL);
colormap->visual = visual;
colormap->size = visual->colormap_size;
switch (visual->type)
{
case GDK_VISUAL_PSEUDO_COLOR:
{
IDirectFB *dfb = _gdk_display->directfb;
IDirectFBPalette *palette;
GdkColormapPrivateDirectFB *private;
DFBPaletteDescription dsc;
dsc.flags = DPDESC_SIZE;
dsc.size = colormap->size;
if (!dfb->CreatePalette (dfb, &dsc, &palette))
return NULL;
colormap->colors = g_new0 (GdkColor, colormap->size);
private = g_new0 (GdkColormapPrivateDirectFB, 1);
private->info = g_new0 (GdkColorInfo, colormap->size);
if (visual == gdk_visual_get_system())
{
/* save the first (transparent) palette entry */
private->info[0].ref_count++;
}
private->palette = palette;
colormap->windowing_data = private;
gdk_directfb_allocate_color_key (colormap);
}
break;
case GDK_VISUAL_STATIC_COLOR:
colormap->colors = g_new0 (GdkColor, colormap->size);
for (i = 0; i < colormap->size; i++)
{
GdkColor *color = colormap->colors + i;
color->pixel = i;
color->red = (i & 0xE0) << 8 | (i & 0xE0);
color->green = (i & 0x1C) << 11 | (i & 0x1C) << 3;
color->blue = (i & 0x03) << 14 | (i & 0x03) << 6;
}
break;
default:
break;
}
return colormap;
}
GdkScreen*
gdk_colormap_get_screen (GdkColormap *cmap)
{
return _gdk_screen;
}
GdkColormap*
gdk_screen_get_system_colormap (GdkScreen *screen)
{
static GdkColormap *colormap = NULL;
if (!colormap)
{
GdkVisual *visual = gdk_visual_get_system();
/* special case PSEUDO_COLOR to use the system palette */
if (visual->type == GDK_VISUAL_PSEUDO_COLOR)
{
GdkColormapPrivateDirectFB *private;
IDirectFBSurface *surface;
colormap = g_object_new (gdk_colormap_get_type (), NULL);
colormap->visual = visual;
colormap->size = visual->colormap_size;
colormap->colors = g_new0 (GdkColor, colormap->size);
private = g_new0 (GdkColormapPrivateDirectFB, 1);
private->info = g_new0 (GdkColorInfo, colormap->size);
surface=GDK_WINDOW_IMPL_DIRECTFB (
GDK_WINDOW_OBJECT (_gdk_parent_root)->impl)->drawable.surface;
surface->GetPalette (surface, &private->palette);
colormap->windowing_data = private;
/* save the first (transparent) palette entry */
private->info[0].ref_count++;
gdk_directfb_allocate_color_key (colormap);
}
else
{
colormap = gdk_colormap_new (visual, FALSE);
}
}
return colormap;
}
void
gdk_colormap_free_colors (GdkColormap *colormap,
const GdkColor *colors,
gint ncolors)
{
GdkColormapPrivateDirectFB *private;
gint i;
g_return_if_fail (GDK_IS_COLORMAP (colormap));
g_return_if_fail (colors != NULL);
private = colormap->windowing_data;
if (!private)
return;
for (i = 0; i < ncolors; i++)
{
gint index = colors[i].pixel;
if (index < 0 || index >= colormap->size)
continue;
if (private->info[index].ref_count)
private->info[index].ref_count--;
}
}
gint
gdk_colormap_alloc_colors (GdkColormap *colormap,
GdkColor *colors,
gint ncolors,
gboolean writeable,
gboolean best_match,
gboolean *success)
{
GdkVisual *visual;
gint i;
g_return_val_if_fail (GDK_IS_COLORMAP (colormap), 0);
g_return_val_if_fail (colors != NULL, 0);
g_return_val_if_fail (success != NULL, 0);
switch (colormap->visual->type)
{
case GDK_VISUAL_TRUE_COLOR:
visual = colormap->visual;
for (i = 0; i < ncolors; i++)
{
colors[i].pixel =
(((colors[i].red
>> (16 - visual->red_prec)) << visual->red_shift) +
((colors[i].green
>> (16 - visual->green_prec)) << visual->green_shift) +
((colors[i].blue
>> (16 - visual->blue_prec)) << visual->blue_shift));
success[i] = TRUE;
}
break;
case GDK_VISUAL_PSEUDO_COLOR:
return gdk_colormap_alloc_pseudocolors (colormap,
colors, ncolors,
writeable, best_match,
success);
break;
case GDK_VISUAL_STATIC_COLOR:
for (i = 0; i < ncolors; i++)
{
colors[i].pixel = (((colors[i].red & 0xE000) >> 8) |
((colors[i].green & 0xE000) >> 11) |
((colors[i].blue & 0xC000) >> 14));
success[i] = TRUE;
}
break;
default:
for (i = 0; i < ncolors; i++)
success[i] = FALSE;
break;
}
return 0;
}
IDirectFBPalette *
gdk_directfb_colormap_get_palette (GdkColormap *colormap)
{
GdkColormapPrivateDirectFB *private;
g_return_val_if_fail (GDK_IS_COLORMAP (colormap), NULL);
private = colormap->windowing_data;
if (private && private->palette)
return private->palette;
else
return NULL;
}
static gint
gdk_colormap_alloc_pseudocolors (GdkColormap *colormap,
GdkColor *colors,
gint ncolors,
gboolean writeable,
gboolean best_match,
gboolean *success)
{
GdkColormapPrivateDirectFB *private = colormap->windowing_data;
IDirectFBPalette *palette;
gint i, j;
gint remaining = ncolors;
palette = private->palette;
for (i = 0; i < ncolors; i++)
{
guint index;
DFBColor lookup = { 0xFF,
colors[i].red >> 8,
colors[i].green >> 8,
colors[i].blue >> 8 };
success[i] = FALSE;
if (writeable)
{
/* look for an empty slot and allocate a new color */
for (j = 0; j < colormap->size; j++)
if (private->info[j].ref_count == 0)
{
index = j;
palette->SetEntries (palette, &lookup, 1, index);
private->info[index].flags = GDK_COLOR_WRITEABLE;
colors[i].pixel = index;
colormap->colors[index] = colors[i];
goto allocated;
}
}
else
{
palette->FindBestMatch (palette,
lookup.r, lookup.g, lookup.b, lookup.a,
&index);
if (index < 0 || index > colormap->size)
continue;
/* check if we have an exact (non-writeable) match */
if (private->info[index].ref_count &&
!(private->info[index].flags & GDK_COLOR_WRITEABLE))
{
DFBColor entry;
palette->GetEntries (palette, &entry, 1, index);
if (entry.a == 0xFF &&
entry.r == lookup.r && entry.g == lookup.g && entry.b == lookup.b)
{
colors[i].pixel = index;
goto allocated;
}
}
/* look for an empty slot and allocate a new color */
for (j = 0; j < colormap->size; j++)
if (private->info[j].ref_count == 0)
{
index = j;
palette->SetEntries (palette, &lookup, 1, index);
private->info[index].flags = 0;
colors[i].pixel = index;
colormap->colors[index] = colors[i];
goto allocated;
}
/* if that failed, use the best match */
if (best_match &&
!(private->info[index].flags & GDK_COLOR_WRITEABLE))
{
#if 0
g_print ("best match for (%d %d %d) ",
colormap->colors[index].red,
colormap->colors[index].green,
colormap->colors[index].blue);
#endif
colors[i].pixel = index;
goto allocated;
}
}
/* if we got here, all attempts failed */
continue;
allocated:
private->info[index].ref_count++;
#if 0
g_print ("cmap %p: allocated (%d %d %d) %d [%d]\n", colormap,
colors[i].red, colors[i].green, colors[i].blue, colors[i].pixel,
private->info[index].ref_count);
#endif
success[i] = TRUE;
remaining--;
}
return remaining;
}
/* dirty hack for color_keying */
static void
gdk_directfb_allocate_color_key (GdkColormap *colormap)
{
GdkColormapPrivateDirectFB *private = colormap->windowing_data;
IDirectFBPalette *palette = private->palette;
if (!gdk_directfb_enable_color_keying)
return;
palette->SetEntries (palette, &gdk_directfb_bg_color, 1, 255);
colormap->colors[255].pixel = 255;
colormap->colors[255].red = ((gdk_directfb_bg_color_key.r << 8)
| gdk_directfb_bg_color_key.r);
colormap->colors[255].green = ((gdk_directfb_bg_color_key.g << 8)
| gdk_directfb_bg_color_key.g);
colormap->colors[255].blue = ((gdk_directfb_bg_color_key.b << 8)
| gdk_directfb_bg_color_key.b);
private->info[255].ref_count++;
}

546
gdk/directfb/gdkcursor-directfb.c
View File

@ -1,546 +0,0 @@
/* 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 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 "gdkcursor.h"
#include "x-cursors.xbm"
#include <directfb_version.h>
static struct {
const guchar *bits;
int width, height, hotx, hoty;
GdkCursor *cursor;
} stock_cursors[] = {
{X_cursor_bits, X_cursor_width, X_cursor_height, X_cursor_x_hot, X_cursor_y_hot},
{X_cursor_mask_bits, X_cursor_mask_width, X_cursor_mask_height, X_cursor_mask_x_hot, X_cursor_mask_y_hot},
{arrow_bits, arrow_width, arrow_height, arrow_x_hot, arrow_y_hot},
{arrow_mask_bits, arrow_mask_width, arrow_mask_height, arrow_mask_x_hot, arrow_mask_y_hot},
{based_arrow_down_bits, based_arrow_down_width, based_arrow_down_height, based_arrow_down_x_hot, based_arrow_down_y_hot},
{based_arrow_down_mask_bits, based_arrow_down_mask_width, based_arrow_down_mask_height, based_arrow_down_mask_x_hot, based_arrow_down_mask_y_hot},
{based_arrow_up_bits, based_arrow_up_width, based_arrow_up_height, based_arrow_up_x_hot, based_arrow_up_y_hot},
{based_arrow_up_mask_bits, based_arrow_up_mask_width, based_arrow_up_mask_height, based_arrow_up_mask_x_hot, based_arrow_up_mask_y_hot},
{boat_bits, boat_width, boat_height, boat_x_hot, boat_y_hot},
{boat_mask_bits, boat_mask_width, boat_mask_height, boat_mask_x_hot, boat_mask_y_hot},
{bogosity_bits, bogosity_width, bogosity_height, bogosity_x_hot, bogosity_y_hot},
{bogosity_mask_bits, bogosity_mask_width, bogosity_mask_height, bogosity_mask_x_hot, bogosity_mask_y_hot},
{bottom_left_corner_bits, bottom_left_corner_width, bottom_left_corner_height, bottom_left_corner_x_hot, bottom_left_corner_y_hot},
{bottom_left_corner_mask_bits, bottom_left_corner_mask_width, bottom_left_corner_mask_height, bottom_left_corner_mask_x_hot, bottom_left_corner_mask_y_hot},
{bottom_right_corner_bits, bottom_right_corner_width, bottom_right_corner_height, bottom_right_corner_x_hot, bottom_right_corner_y_hot},
{bottom_right_corner_mask_bits, bottom_right_corner_mask_width, bottom_right_corner_mask_height, bottom_right_corner_mask_x_hot, bottom_right_corner_mask_y_hot},
{bottom_side_bits, bottom_side_width, bottom_side_height, bottom_side_x_hot, bottom_side_y_hot},
{bottom_side_mask_bits, bottom_side_mask_width, bottom_side_mask_height, bottom_side_mask_x_hot, bottom_side_mask_y_hot},
{bottom_tee_bits, bottom_tee_width, bottom_tee_height, bottom_tee_x_hot, bottom_tee_y_hot},
{bottom_tee_mask_bits, bottom_tee_mask_width, bottom_tee_mask_height, bottom_tee_mask_x_hot, bottom_tee_mask_y_hot},
{box_spiral_bits, box_spiral_width, box_spiral_height, box_spiral_x_hot, box_spiral_y_hot},
{box_spiral_mask_bits, box_spiral_mask_width, box_spiral_mask_height, box_spiral_mask_x_hot, box_spiral_mask_y_hot},
{center_ptr_bits, center_ptr_width, center_ptr_height, center_ptr_x_hot, center_ptr_y_hot},
{center_ptr_mask_bits, center_ptr_mask_width, center_ptr_mask_height, center_ptr_mask_x_hot, center_ptr_mask_y_hot},
{circle_bits, circle_width, circle_height, circle_x_hot, circle_y_hot},
{circle_mask_bits, circle_mask_width, circle_mask_height, circle_mask_x_hot, circle_mask_y_hot},
{clock_bits, clock_width, clock_height, clock_x_hot, clock_y_hot},
{clock_mask_bits, clock_mask_width, clock_mask_height, clock_mask_x_hot, clock_mask_y_hot},
{coffee_mug_bits, coffee_mug_width, coffee_mug_height, coffee_mug_x_hot, coffee_mug_y_hot},
{coffee_mug_mask_bits, coffee_mug_mask_width, coffee_mug_mask_height, coffee_mug_mask_x_hot, coffee_mug_mask_y_hot},
{cross_bits, cross_width, cross_height, cross_x_hot, cross_y_hot},
{cross_mask_bits, cross_mask_width, cross_mask_height, cross_mask_x_hot, cross_mask_y_hot},
{cross_reverse_bits, cross_reverse_width, cross_reverse_height, cross_reverse_x_hot, cross_reverse_y_hot},
{cross_reverse_mask_bits, cross_reverse_mask_width, cross_reverse_mask_height, cross_reverse_mask_x_hot, cross_reverse_mask_y_hot},
{crosshair_bits, crosshair_width, crosshair_height, crosshair_x_hot, crosshair_y_hot},
{crosshair_mask_bits, crosshair_mask_width, crosshair_mask_height, crosshair_mask_x_hot, crosshair_mask_y_hot},
{diamond_cross_bits, diamond_cross_width, diamond_cross_height, diamond_cross_x_hot, diamond_cross_y_hot},
{diamond_cross_mask_bits, diamond_cross_mask_width, diamond_cross_mask_height, diamond_cross_mask_x_hot, diamond_cross_mask_y_hot},
{dot_bits, dot_width, dot_height, dot_x_hot, dot_y_hot},
{dot_mask_bits, dot_mask_width, dot_mask_height, dot_mask_x_hot, dot_mask_y_hot},
{dotbox_bits, dotbox_width, dotbox_height, dotbox_x_hot, dotbox_y_hot},
{dotbox_mask_bits, dotbox_mask_width, dotbox_mask_height, dotbox_mask_x_hot, dotbox_mask_y_hot},
{double_arrow_bits, double_arrow_width, double_arrow_height, double_arrow_x_hot, double_arrow_y_hot},
{double_arrow_mask_bits, double_arrow_mask_width, double_arrow_mask_height, double_arrow_mask_x_hot, double_arrow_mask_y_hot},
{draft_large_bits, draft_large_width, draft_large_height, draft_large_x_hot, draft_large_y_hot},
{draft_large_mask_bits, draft_large_mask_width, draft_large_mask_height, draft_large_mask_x_hot, draft_large_mask_y_hot},
{draft_small_bits, draft_small_width, draft_small_height, draft_small_x_hot, draft_small_y_hot},
{draft_small_mask_bits, draft_small_mask_width, draft_small_mask_height, draft_small_mask_x_hot, draft_small_mask_y_hot},
{draped_box_bits, draped_box_width, draped_box_height, draped_box_x_hot, draped_box_y_hot},
{draped_box_mask_bits, draped_box_mask_width, draped_box_mask_height, draped_box_mask_x_hot, draped_box_mask_y_hot},
{exchange_bits, exchange_width, exchange_height, exchange_x_hot, exchange_y_hot},
{exchange_mask_bits, exchange_mask_width, exchange_mask_height, exchange_mask_x_hot, exchange_mask_y_hot},
{fleur_bits, fleur_width, fleur_height, fleur_x_hot, fleur_y_hot},
{fleur_mask_bits, fleur_mask_width, fleur_mask_height, fleur_mask_x_hot, fleur_mask_y_hot},
{gobbler_bits, gobbler_width, gobbler_height, gobbler_x_hot, gobbler_y_hot},
{gobbler_mask_bits, gobbler_mask_width, gobbler_mask_height, gobbler_mask_x_hot, gobbler_mask_y_hot},
{gumby_bits, gumby_width, gumby_height, gumby_x_hot, gumby_y_hot},
{gumby_mask_bits, gumby_mask_width, gumby_mask_height, gumby_mask_x_hot, gumby_mask_y_hot},
{hand1_bits, hand1_width, hand1_height, hand1_x_hot, hand1_y_hot},
{hand1_mask_bits, hand1_mask_width, hand1_mask_height, hand1_mask_x_hot, hand1_mask_y_hot},
{hand2_bits, hand2_width, hand2_height, hand2_x_hot, hand2_y_hot},
{hand2_mask_bits, hand2_mask_width, hand2_mask_height, hand2_mask_x_hot, hand2_mask_y_hot},
{heart_bits, heart_width, heart_height, heart_x_hot, heart_y_hot},
{heart_mask_bits, heart_mask_width, heart_mask_height, heart_mask_x_hot, heart_mask_y_hot},
{icon_bits, icon_width, icon_height, icon_x_hot, icon_y_hot},
{icon_mask_bits, icon_mask_width, icon_mask_height, icon_mask_x_hot, icon_mask_y_hot},
{iron_cross_bits, iron_cross_width, iron_cross_height, iron_cross_x_hot, iron_cross_y_hot},
{iron_cross_mask_bits, iron_cross_mask_width, iron_cross_mask_height, iron_cross_mask_x_hot, iron_cross_mask_y_hot},
{left_ptr_bits, left_ptr_width, left_ptr_height, left_ptr_x_hot, left_ptr_y_hot},
{left_ptr_mask_bits, left_ptr_mask_width, left_ptr_mask_height, left_ptr_mask_x_hot, left_ptr_mask_y_hot},
{left_side_bits, left_side_width, left_side_height, left_side_x_hot, left_side_y_hot},
{left_side_mask_bits, left_side_mask_width, left_side_mask_height, left_side_mask_x_hot, left_side_mask_y_hot},
{left_tee_bits, left_tee_width, left_tee_height, left_tee_x_hot, left_tee_y_hot},
{left_tee_mask_bits, left_tee_mask_width, left_tee_mask_height, left_tee_mask_x_hot, left_tee_mask_y_hot},
{leftbutton_bits, leftbutton_width, leftbutton_height, leftbutton_x_hot, leftbutton_y_hot},
{leftbutton_mask_bits, leftbutton_mask_width, leftbutton_mask_height, leftbutton_mask_x_hot, leftbutton_mask_y_hot},
{ll_angle_bits, ll_angle_width, ll_angle_height, ll_angle_x_hot, ll_angle_y_hot},
{ll_angle_mask_bits, ll_angle_mask_width, ll_angle_mask_height, ll_angle_mask_x_hot, ll_angle_mask_y_hot},
{lr_angle_bits, lr_angle_width, lr_angle_height, lr_angle_x_hot, lr_angle_y_hot},
{lr_angle_mask_bits, lr_angle_mask_width, lr_angle_mask_height, lr_angle_mask_x_hot, lr_angle_mask_y_hot},
{man_bits, man_width, man_height, man_x_hot, man_y_hot},
{man_mask_bits, man_mask_width, man_mask_height, man_mask_x_hot, man_mask_y_hot},
{middlebutton_bits, middlebutton_width, middlebutton_height, middlebutton_x_hot, middlebutton_y_hot},
{middlebutton_mask_bits, middlebutton_mask_width, middlebutton_mask_height, middlebutton_mask_x_hot, middlebutton_mask_y_hot},
{mouse_bits, mouse_width, mouse_height, mouse_x_hot, mouse_y_hot},
{mouse_mask_bits, mouse_mask_width, mouse_mask_height, mouse_mask_x_hot, mouse_mask_y_hot},
{pencil_bits, pencil_width, pencil_height, pencil_x_hot, pencil_y_hot},
{pencil_mask_bits, pencil_mask_width, pencil_mask_height, pencil_mask_x_hot, pencil_mask_y_hot},
{pirate_bits, pirate_width, pirate_height, pirate_x_hot, pirate_y_hot},
{pirate_mask_bits, pirate_mask_width, pirate_mask_height, pirate_mask_x_hot, pirate_mask_y_hot},
{plus_bits, plus_width, plus_height, plus_x_hot, plus_y_hot},
{plus_mask_bits, plus_mask_width, plus_mask_height, plus_mask_x_hot, plus_mask_y_hot},
{question_arrow_bits, question_arrow_width, question_arrow_height, question_arrow_x_hot, question_arrow_y_hot},
{question_arrow_mask_bits, question_arrow_mask_width, question_arrow_mask_height, question_arrow_mask_x_hot, question_arrow_mask_y_hot},
{right_ptr_bits, right_ptr_width, right_ptr_height, right_ptr_x_hot, right_ptr_y_hot},
{right_ptr_mask_bits, right_ptr_mask_width, right_ptr_mask_height, right_ptr_mask_x_hot, right_ptr_mask_y_hot},
{right_side_bits, right_side_width, right_side_height, right_side_x_hot, right_side_y_hot},
{right_side_mask_bits, right_side_mask_width, right_side_mask_height, right_side_mask_x_hot, right_side_mask_y_hot},
{right_tee_bits, right_tee_width, right_tee_height, right_tee_x_hot, right_tee_y_hot},
{right_tee_mask_bits, right_tee_mask_width, right_tee_mask_height, right_tee_mask_x_hot, right_tee_mask_y_hot},
{rightbutton_bits, rightbutton_width, rightbutton_height, rightbutton_x_hot, rightbutton_y_hot},
{rightbutton_mask_bits, rightbutton_mask_width, rightbutton_mask_height, rightbutton_mask_x_hot, rightbutton_mask_y_hot},
{rtl_logo_bits, rtl_logo_width, rtl_logo_height, rtl_logo_x_hot, rtl_logo_y_hot},
{rtl_logo_mask_bits, rtl_logo_mask_width, rtl_logo_mask_height, rtl_logo_mask_x_hot, rtl_logo_mask_y_hot},
{sailboat_bits, sailboat_width, sailboat_height, sailboat_x_hot, sailboat_y_hot},
{sailboat_mask_bits, sailboat_mask_width, sailboat_mask_height, sailboat_mask_x_hot, sailboat_mask_y_hot},
{sb_down_arrow_bits, sb_down_arrow_width, sb_down_arrow_height, sb_down_arrow_x_hot, sb_down_arrow_y_hot},
{sb_down_arrow_mask_bits, sb_down_arrow_mask_width, sb_down_arrow_mask_height, sb_down_arrow_mask_x_hot, sb_down_arrow_mask_y_hot},
{sb_h_double_arrow_bits, sb_h_double_arrow_width, sb_h_double_arrow_height, sb_h_double_arrow_x_hot, sb_h_double_arrow_y_hot},
{sb_h_double_arrow_mask_bits, sb_h_double_arrow_mask_width, sb_h_double_arrow_mask_height, sb_h_double_arrow_mask_x_hot, sb_h_double_arrow_mask_y_hot},
{sb_left_arrow_bits, sb_left_arrow_width, sb_left_arrow_height, sb_left_arrow_x_hot, sb_left_arrow_y_hot},
{sb_left_arrow_mask_bits, sb_left_arrow_mask_width, sb_left_arrow_mask_height, sb_left_arrow_mask_x_hot, sb_left_arrow_mask_y_hot},
{sb_right_arrow_bits, sb_right_arrow_width, sb_right_arrow_height, sb_right_arrow_x_hot, sb_right_arrow_y_hot},
{sb_right_arrow_mask_bits, sb_right_arrow_mask_width, sb_right_arrow_mask_height, sb_right_arrow_mask_x_hot, sb_right_arrow_mask_y_hot},
{sb_up_arrow_bits, sb_up_arrow_width, sb_up_arrow_height, sb_up_arrow_x_hot, sb_up_arrow_y_hot},
{sb_up_arrow_mask_bits, sb_up_arrow_mask_width, sb_up_arrow_mask_height, sb_up_arrow_mask_x_hot, sb_up_arrow_mask_y_hot},
{sb_v_double_arrow_bits, sb_v_double_arrow_width, sb_v_double_arrow_height, sb_v_double_arrow_x_hot, sb_v_double_arrow_y_hot},
{sb_v_double_arrow_mask_bits, sb_v_double_arrow_mask_width, sb_v_double_arrow_mask_height, sb_v_double_arrow_mask_x_hot, sb_v_double_arrow_mask_y_hot},
{shuttle_bits, shuttle_width, shuttle_height, shuttle_x_hot, shuttle_y_hot},
{shuttle_mask_bits, shuttle_mask_width, shuttle_mask_height, shuttle_mask_x_hot, shuttle_mask_y_hot},
{sizing_bits, sizing_width, sizing_height, sizing_x_hot, sizing_y_hot},
{sizing_mask_bits, sizing_mask_width, sizing_mask_height, sizing_mask_x_hot, sizing_mask_y_hot},
{spider_bits, spider_width, spider_height, spider_x_hot, spider_y_hot},
{spider_mask_bits, spider_mask_width, spider_mask_height, spider_mask_x_hot, spider_mask_y_hot},
{spraycan_bits, spraycan_width, spraycan_height, spraycan_x_hot, spraycan_y_hot},
{spraycan_mask_bits, spraycan_mask_width, spraycan_mask_height, spraycan_mask_x_hot, spraycan_mask_y_hot},
{star_bits, star_width, star_height, star_x_hot, star_y_hot},
{star_mask_bits, star_mask_width, star_mask_height, star_mask_x_hot, star_mask_y_hot},
{target_bits, target_width, target_height, target_x_hot, target_y_hot},
{target_mask_bits, target_mask_width, target_mask_height, target_mask_x_hot, target_mask_y_hot},
{tcross_bits, tcross_width, tcross_height, tcross_x_hot, tcross_y_hot},
{tcross_mask_bits, tcross_mask_width, tcross_mask_height, tcross_mask_x_hot, tcross_mask_y_hot},
{top_left_arrow_bits, top_left_arrow_width, top_left_arrow_height, top_left_arrow_x_hot, top_left_arrow_y_hot},
{top_left_arrow_mask_bits, top_left_arrow_mask_width, top_left_arrow_mask_height, top_left_arrow_mask_x_hot, top_left_arrow_mask_y_hot},
{top_left_corner_bits, top_left_corner_width, top_left_corner_height, top_left_corner_x_hot, top_left_corner_y_hot},
{top_left_corner_mask_bits, top_left_corner_mask_width, top_left_corner_mask_height, top_left_corner_mask_x_hot, top_left_corner_mask_y_hot},
{top_right_corner_bits, top_right_corner_width, top_right_corner_height, top_right_corner_x_hot, top_right_corner_y_hot},
{top_right_corner_mask_bits, top_right_corner_mask_width, top_right_corner_mask_height, top_right_corner_mask_x_hot, top_right_corner_mask_y_hot},
{top_side_bits, top_side_width, top_side_height, top_side_x_hot, top_side_y_hot},
{top_side_mask_bits, top_side_mask_width, top_side_mask_height, top_side_mask_x_hot, top_side_mask_y_hot},
{top_tee_bits, top_tee_width, top_tee_height, top_tee_x_hot, top_tee_y_hot},
{top_tee_mask_bits, top_tee_mask_width, top_tee_mask_height, top_tee_mask_x_hot, top_tee_mask_y_hot},
{trek_bits, trek_width, trek_height, trek_x_hot, trek_y_hot},
{trek_mask_bits, trek_mask_width, trek_mask_height, trek_mask_x_hot, trek_mask_y_hot},
{ul_angle_bits, ul_angle_width, ul_angle_height, ul_angle_x_hot, ul_angle_y_hot},
{ul_angle_mask_bits, ul_angle_mask_width, ul_angle_mask_height, ul_angle_mask_x_hot, ul_angle_mask_y_hot},
{umbrella_bits, umbrella_width, umbrella_height, umbrella_x_hot, umbrella_y_hot},
{umbrella_mask_bits, umbrella_mask_width, umbrella_mask_height, umbrella_mask_x_hot, umbrella_mask_y_hot},
{ur_angle_bits, ur_angle_width, ur_angle_height, ur_angle_x_hot, ur_angle_y_hot},
{ur_angle_mask_bits, ur_angle_mask_width, ur_angle_mask_height, ur_angle_mask_x_hot, ur_angle_mask_y_hot},
{watch_bits, watch_width, watch_height, watch_x_hot, watch_y_hot},
{watch_mask_bits, watch_mask_width, watch_mask_height, watch_mask_x_hot, watch_mask_y_hot},
{xterm_bits, xterm_width, xterm_height, xterm_x_hot, xterm_y_hot},
{xterm_mask_bits, xterm_mask_width, xterm_mask_height, xterm_mask_x_hot, xterm_mask_y_hot}
};
GdkCursor *
gdk_cursor_new_for_display (GdkDisplay *display,GdkCursorType cursor_type)
{
GdkCursor *cursor;
GdkDisplayDFB *dfb_display = GDK_DISPLAY_DFB(display);
if (cursor_type >= sizeof(stock_cursors)/sizeof(stock_cursors[0]))
return NULL;
cursor = stock_cursors[cursor_type].cursor;
if (!cursor)
{
GdkCursorDirectFB *private;
DFBResult ret;
IDirectFBSurface *temp;
IDirectFBSurface *shape;
int width = stock_cursors[cursor_type+1].width;
int height = stock_cursors[cursor_type+1].height;
temp =gdk_display_dfb_create_surface(dfb_display,DSPF_ARGB,width,height);
if (!temp)
{
return NULL;
}
else
{
u32 *dst;
int pitch;
ret = temp->Lock (temp, DSLF_WRITE, (void**)&dst, &pitch);
if (ret)
{
DirectFBError ("gdkcursor-directfb.c (gdk_cursor_new): "
"temp->Lock", ret);
temp->Release (temp);
return NULL;
}
else
{
gint x, y;
gint mx, my;
gint p = ((stock_cursors[cursor_type].width + 7) / 8) * 8;
gint mp = ((stock_cursors[cursor_type+1].width + 7) / 8) * 8;
const guchar *src;
const guchar *mask;
pitch >>= 2;
src = stock_cursors[cursor_type].bits;
mask = stock_cursors[cursor_type+1].bits;
mx = stock_cursors[cursor_type+1].hotx - stock_cursors[cursor_type].hotx;
my = stock_cursors[cursor_type+1].hoty - stock_cursors[cursor_type].hoty;
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
gint bit = x-mx + (y-my) * p;
gint mbit = x + y * mp;
u32 color = (x-mx < 0 || y-my < 0 ||
x-mx >= stock_cursors[cursor_type].width ||
y-my >= stock_cursors[cursor_type].height)
? 0x00FFFFFF : (src[bit/8] & (1 << bit%8) ? 0 : 0x00FFFFFF);
u8 a = color ? 0xE0 : 0xFF;
u32 alpha = mask[mbit/8] & (1 << mbit%8) ? (a << 24) : 0;
dst[x + y*pitch] = alpha | color;
}
}
temp->Unlock (temp);
}
}
width += 2;
height += 2;
shape=gdk_display_dfb_create_surface(dfb_display,DSPF_ARGB,width,height);
if( !shape ) {
temp->Release(temp);
return NULL;
}
shape->Clear (shape, 0x80, 0x80, 0x80, 0);
shape->SetBlittingFlags (shape, (DSBLIT_BLEND_COLORALPHA |
DSBLIT_BLEND_ALPHACHANNEL));
shape->SetColor (shape, 0, 0, 0, 0x30);
shape->Blit (shape, temp, NULL, 0, 0);
shape->Blit (shape, temp, NULL, 0, 2);
shape->Blit (shape, temp, NULL, 2, 0);
shape->Blit (shape, temp, NULL, 2, 2);
shape->SetColor (shape, 0, 0, 0, 0xA0);
shape->Blit (shape, temp, NULL, 1, 0);
shape->Blit (shape, temp, NULL, 0, 1);
shape->Blit (shape, temp, NULL, 2, 1);
shape->Blit (shape, temp, NULL, 1, 2);
shape->SetColor (shape, 0, 0, 0, 0xE0);
shape->Blit (shape, temp, NULL, 1, 1);
temp->Release (temp);
private = g_new0 (GdkCursorDirectFB, 1);
cursor = (GdkCursor *) private;
cursor->type = GDK_CURSOR_IS_PIXMAP;
cursor->ref_count = 1;
private->shape = shape;
private->hot_x = stock_cursors[cursor_type].hotx;
private->hot_y = stock_cursors[cursor_type].hoty;
stock_cursors[cursor_type].cursor = cursor;
}
return gdk_cursor_ref (cursor);
}
GdkCursor *
gdk_cursor_new_from_pixmap (GdkPixmap *source,
GdkPixmap *mask,
const GdkColor *fg,
const GdkColor *bg,
gint x,
gint y)
{
GdkCursor *cursor;
GdkCursorDirectFB *private;
GdkDrawableImplDirectFB *impl;
GdkDrawableImplDirectFB *mask_impl;
IDirectFBSurface *shape;
g_return_val_if_fail (GDK_IS_PIXMAP (source), NULL);
g_return_val_if_fail (GDK_IS_PIXMAP (mask), NULL);
impl = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_PIXMAP_OBJECT (source)->impl);
mask_impl = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_PIXMAP_OBJECT (mask)->impl);
int width = impl->width;
int height = impl->height;
shape=gdk_display_dfb_create_surface(_gdk_display,DSPF_ARGB,width,height);
if (!shape)
{
return NULL;
}
/*
* The following code assumes that pixmap and mask are A8 surfaces
* that correspond to X11 bitmaps. This is the traditional usage of
* gdk_cursor_new_from_pixmap(). For GTK+-DirectFB it might make
* sense to allow arbitrary ARGB cursors.
*/
shape->Clear (shape, bg->red >> 8, bg->green >> 8, bg->blue >> 8, 0xFF);
shape->SetColor (shape, fg->red >> 8, fg->green >> 8, fg->blue >> 8, 0xFF);
shape->SetBlittingFlags (shape,
DSBLIT_BLEND_ALPHACHANNEL | DSBLIT_COLORIZE);
shape->Blit (shape, impl->surface, NULL, 0, 0);
shape->SetPorterDuff (shape, DSPD_DST_IN);
shape->Blit (shape, mask_impl->surface, NULL, 0, 0);
shape->SetBlittingFlags (shape, DSBLIT_NOFX);
shape->SetPorterDuff (shape, DSPD_NONE);
private = g_new (GdkCursorDirectFB, 1);
cursor = (GdkCursor *) private;
cursor->type = GDK_CURSOR_IS_PIXMAP;
cursor->ref_count = 1;
private->shape = shape;
private->hot_x = x;
private->hot_y = y;
return cursor;
}
GdkCursor *
gdk_cursor_new_from_pixbuf (GdkDisplay *display,
GdkPixbuf *pixbuf,
gint x,
gint y)
{
GdkPixmap *pixmap, *mask;
GdkCursor *cursor;
gint width, height, depth = 8;
GdkVisual* visual;
/* FIXME: this is not the right way to set colours */
GdkColor fg = { 0, 65535, 65535, 65535 };
GdkColor bg = { 0, 65535, 65535, 65535 };
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
g_return_val_if_fail (0 <= x && x < gdk_pixbuf_get_width (pixbuf), NULL);
g_return_val_if_fail (0 <= y && y < gdk_pixbuf_get_height (pixbuf), NULL);
width = gdk_pixbuf_get_width(pixbuf);
height = gdk_pixbuf_get_height(pixbuf);
pixmap = gdk_pixmap_new ( NULL, width, height, depth);
mask = gdk_pixmap_new ( NULL, width, height, 1);
visual = gdk_rgb_get_visual ();
depth = visual->depth;
gdk_pixbuf_render_pixmap_and_mask (pixbuf, &pixmap, &mask, 0);
g_return_val_if_fail (GDK_IS_PIXMAP (pixmap), NULL);
g_return_val_if_fail (GDK_IS_PIXMAP (mask), NULL);
cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &fg, &bg, x, y) ;
g_object_unref (pixmap);
g_object_unref (mask);
/* a cursor of type GDK_CURSOR_IS_PIXMAP is returned */
return cursor;
}
GdkCursor*
gdk_cursor_new_from_name (GdkDisplay *display,
const gchar *name)
{
GdkCursor *cursor;
GdkPixbuf *pixbuf;
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
pixbuf = gdk_pixbuf_new_from_file(name, NULL);
/* Prevents attempts to load stock X cursors from generating error messages */
if (pixbuf == NULL)
return NULL;
g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
cursor = gdk_cursor_new_from_pixbuf (display, pixbuf, 1, 1);
g_object_unref (pixbuf);
return cursor;
}
GdkPixbuf*
gdk_cursor_get_image (GdkCursor *cursor)
{
g_return_val_if_fail (cursor != NULL, NULL);
return NULL;
}
void
_gdk_cursor_destroy (GdkCursor *cursor)
{
GdkCursorDirectFB *private;
g_return_if_fail (cursor != NULL);
g_return_if_fail (cursor->ref_count == 0);
private = (GdkCursorDirectFB *) cursor;
private->shape->Release (private->shape);
g_free (private);
}
GdkDisplay *
gdk_cursor_get_display (GdkCursor *cursor)
{
return gdk_display_get_default ();
}
guint
gdk_display_get_default_cursor_size (GdkDisplay *display)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
return 16;
}
/**
* gdk_display_get_maximal_cursor_size:
* @display: a #GdkDisplay
* @width: the return location for the maximal cursor width
* @height: the return location for the maximal cursor height
*
* Gets the maximal size to use for cursors on @display.
*
* Since: 2.4
*/
void
gdk_display_get_maximal_cursor_size (GdkDisplay *display,
guint *width,
guint *height)
{
g_return_if_fail (GDK_IS_DISPLAY (display));
/* Cursor sizes in DirectFB can be large (4095x4095), but we limit this to
128x128 for max compatibility with the x11 backend. */
*width = 128;
*height = 128;
}
/**
* gdk_display_supports_cursor_alpha:
* @display: a #GdkDisplay
*
* Returns %TRUE if cursors can use an 8bit alpha channel
* on @display. Otherwise, cursors are restricted to bilevel
* alpha (i.e. a mask).
*
* Returns: whether cursors can have alpha channels.
*
* Since: 2.4
*/
gboolean
gdk_display_supports_cursor_alpha (GdkDisplay *display)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
return TRUE;
}
gboolean
gdk_display_supports_cursor_color (GdkDisplay *display)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
return TRUE;
}

82
gdk/directfb/gdkdirectfb.h
View File

@ -1,82 +0,0 @@
/* 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 convergence GmbH
* Written by Denis Oliver Kropp <dok@convergence.de> and
* Sven Neumann <sven@convergence.de>
*/
#ifndef __GDK_DIRECTFB_H__
#define __GDK_DIRECTFB_H__
/* This define disables some experimental code
*/
#define GDK_DIRECTFB_NO_EXPERIMENTS
#include <cairo.h>
#include <directfb.h>
#include "gdk/gdkprivate.h"
extern GdkWindow * _gdk_parent_root;
G_BEGIN_DECLS
#define GDK_ROOT_WINDOW() _gdk_parent_root
#define GDK_WINDOW_DFB_ID(win) (GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (win)->impl)->dfb_id)
/* used for the --transparent-unfocused hack */
extern gboolean gdk_directfb_apply_focus_opacity;
/* used for the --enable-color-keying hack */
extern gboolean gdk_directfb_enable_color_keying;
extern DFBColor gdk_directfb_bg_color;
extern DFBColor gdk_directfb_bg_color_key;
/* to disable antialiasing */
extern gboolean gdk_directfb_monochrome_fonts;
/* GTK+-DirectFB specific functions */
void gdk_directfb_window_set_opacity (GdkWindow *window,
guchar opacity);
GdkVisual * gdk_directfb_visual_by_format (DFBSurfacePixelFormat pixel_format);
IDirectFBWindow *gdk_directfb_window_lookup(GdkWindow *window);
IDirectFBSurface *gdk_directfb_surface_lookup(GdkWindow *window);
GdkWindow *gdk_directfb_create_child_window(GdkWindow *parent,
IDirectFBSurface *subsurface);
G_END_DECLS
#endif /* __GDK_DIRECTFB_H__ */

540
gdk/directfb/gdkdisplay-directfb.c
View File

@ -1,540 +0,0 @@
/* 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. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "config.h"
#include <glib.h>
#include "gdk.h"
#include "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
#include "gdkscreen.h"
#include "gdkdisplaymanager.h"
extern void _gdk_visual_init (void);
extern void _gdk_events_init (void);
extern void _gdk_input_init (void);
extern void _gdk_dnd_init (void);
extern void _gdk_windowing_window_init (void);
extern void _gdk_directfb_keyboard_init (void);
static gboolean gdk_directfb_argb_font = FALSE;
static gint gdk_directfb_glyph_surface_cache = 8;
const GOptionEntry _gdk_windowing_args[] =
{
{ "disable-aa-fonts",0,0,G_OPTION_ARG_INT,&gdk_directfb_monochrome_fonts,NULL,NULL },
{ "argb-font",0,0, G_OPTION_ARG_INT, &gdk_directfb_argb_font,NULL,NULL},
{ "transparent-unfocused",0,0, G_OPTION_ARG_INT, &gdk_directfb_apply_focus_opacity,NULL,NULL },
{ "glyph-surface-cache",0,0,G_OPTION_ARG_INT,&gdk_directfb_glyph_surface_cache,NULL,NULL },
{ "enable-color-keying",0,0,G_OPTION_ARG_INT,&gdk_directfb_enable_color_keying,NULL,NULL },
{ NULL}
};
/* Main entry point for gdk in 2.6 args are parsed
*/
GdkDisplay * gdk_display_open (const gchar *display_name)
{
IDirectFB *directfb;
IDirectFBDisplayLayer *layer;
IDirectFBInputDevice *keyboard;
DFBResult ret;
if (_gdk_display)
{
return GDK_DISPLAY_OBJECT(_gdk_display); /* single display only */
}
ret = DirectFBInit (NULL, NULL);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: DirectFBInit", ret);
return NULL;
}
ret = DirectFBCreate (&directfb);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: DirectFBCreate", ret);
return NULL;
}
_gdk_display = g_object_new (GDK_TYPE_DISPLAY_DFB, NULL);
_gdk_display->directfb = directfb;
ret = directfb->GetDisplayLayer (directfb, DLID_PRIMARY, &layer);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: GetDisplayLayer", ret);
directfb->Release (directfb);
_gdk_display->directfb = NULL;
return NULL;
}
ret = directfb->GetInputDevice (directfb, DIDID_KEYBOARD, &keyboard);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: GetInputDevice", ret);
directfb->Release (directfb);
_gdk_display->directfb = NULL;
return NULL;
}
_gdk_display->layer=layer;
_gdk_display->keyboard=keyboard;
_gdk_directfb_keyboard_init ();
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
_gdk_visual_init ();
_gdk_windowing_window_init ();
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen)); _gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init ();
_gdk_dnd_init ();
layer->EnableCursor (layer, 1);
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
return GDK_DISPLAY_OBJECT(_gdk_display);
}
GType
gdk_display_dfb_get_type (void)
{
static GType object_type = 0;
if (!object_type)
{
const GTypeInfo object_info =
{
sizeof (GdkDisplayDFBClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) NULL,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GdkDisplayDFB),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
object_type = g_type_register_static (GDK_TYPE_DISPLAY,
"GdkDisplayDFB",
&object_info, 0);
}
return object_type;
}
IDirectFBSurface * gdk_display_dfb_create_surface (GdkDisplayDFB *display,int format,int width, int height) {
DFBResult ret;
IDirectFBSurface *temp;
DFBSurfaceDescription dsc;
dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT;
dsc.width = width;
dsc.height = height;
dsc.pixelformat = format;
ret = display->directfb->CreateSurface (display->directfb, &dsc, &temp);
if (ret)
{
DirectFBError ("gdk_display_dfb_create_surface ", ret);
return NULL;
}
return temp;
}
/*************************************************************************************************
* Displays and Screens
*/
void
_gdk_windowing_set_default_display (GdkDisplay *display)
{
_gdk_display=GDK_DISPLAY_DFB(display);
}
G_CONST_RETURN gchar *
gdk_display_get_name (GdkDisplay *display)
{
return gdk_get_display_arg_name ();
}
int
gdk_display_get_n_screens (GdkDisplay *display)
{
return 1;
}
GdkScreen *
gdk_display_get_screen (GdkDisplay *display,
gint screen_num)
{
return _gdk_screen;
}
GdkScreen *
gdk_display_get_default_screen (GdkDisplay *display)
{
return _gdk_screen;
}
gboolean
gdk_display_supports_shapes (GdkDisplay *display)
{
return FALSE;
}
gboolean
gdk_display_supports_input_shapes (GdkDisplay *display)
{
return FALSE;
}
GdkWindow *gdk_display_get_default_group (GdkDisplay *display)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
return _gdk_parent_root;
}
/*************************************************************************************************
* Selection and Clipboard
*/
gboolean
gdk_display_supports_selection_notification (GdkDisplay *display)
{
return FALSE;
}
gboolean gdk_display_request_selection_notification (GdkDisplay *display,
GdkAtom selection)
{
g_warning("gdk_display_request_selection_notification Unimplemented function \n");
return FALSE;
}
gboolean
gdk_display_supports_clipboard_persistence (GdkDisplay *display)
{
g_warning("gdk_display_supports_clipboard_persistence Unimplemented function \n");
return FALSE;
}
void
gdk_display_store_clipboard (GdkDisplay *display,
GdkWindow *clipboard_window,
guint32 time_,
const GdkAtom *targets,
gint n_targets)
{
g_warning("gdk_display_store_clipboard Unimplemented function \n");
}
/*************************************************************************************************
* Pointer
*/
static gboolean _gdk_directfb_pointer_implicit_grab = FALSE;
GdkGrabStatus
gdk_directfb_pointer_grab (GdkWindow *window,
gint owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
GdkCursor *cursor,
guint32 time,
gboolean implicit_grab)
{
GdkWindow *toplevel;
GdkWindowImplDirectFB *impl;
if (_gdk_directfb_pointer_grab_window)
{
if (implicit_grab && !_gdk_directfb_pointer_implicit_grab)
return GDK_GRAB_ALREADY_GRABBED;
gdk_pointer_ungrab (time);
}
toplevel = gdk_directfb_window_find_toplevel (window);
impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (toplevel)->impl);
if (impl->window)
{
if (impl->window->GrabPointer (impl->window) == DFB_LOCKED)
return GDK_GRAB_ALREADY_GRABBED;
}
if (event_mask & GDK_BUTTON_MOTION_MASK)
event_mask |= (GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON2_MOTION_MASK |
GDK_BUTTON3_MOTION_MASK);
_gdk_directfb_pointer_implicit_grab = implicit_grab;
_gdk_directfb_pointer_grab_window = g_object_ref (window);
_gdk_directfb_pointer_grab_owner_events = owner_events;
_gdk_directfb_pointer_grab_confine = (confine_to ?
g_object_ref (confine_to) : NULL);
_gdk_directfb_pointer_grab_events = event_mask;
_gdk_directfb_pointer_grab_cursor = (cursor ?
gdk_cursor_ref (cursor) : NULL);
gdk_directfb_window_send_crossing_events (NULL,
window,
GDK_CROSSING_GRAB);
return GDK_GRAB_SUCCESS;
}
void
gdk_directfb_pointer_ungrab (guint32 time,
gboolean implicit_grab)
{
GdkWindow *toplevel;
GdkWindow *mousewin;
GdkWindow *old_grab_window;
GdkWindowImplDirectFB *impl;
if (implicit_grab && !_gdk_directfb_pointer_implicit_grab)
return;
if (!_gdk_directfb_pointer_grab_window)
return;
toplevel =
gdk_directfb_window_find_toplevel (_gdk_directfb_pointer_grab_window);
impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (toplevel)->impl);
if (impl->window)
impl->window->UngrabPointer (impl->window);
if (_gdk_directfb_pointer_grab_confine)
{
g_object_unref (_gdk_directfb_pointer_grab_confine);
_gdk_directfb_pointer_grab_confine = NULL;
}
if (_gdk_directfb_pointer_grab_cursor)
{
gdk_cursor_unref (_gdk_directfb_pointer_grab_cursor);
_gdk_directfb_pointer_grab_cursor = NULL;
}
old_grab_window = _gdk_directfb_pointer_grab_window;
_gdk_directfb_pointer_grab_window = NULL;
_gdk_directfb_pointer_implicit_grab = FALSE;
mousewin = gdk_window_at_pointer (NULL, NULL);
gdk_directfb_window_send_crossing_events (old_grab_window,
mousewin,
GDK_CROSSING_UNGRAB);
g_object_unref (old_grab_window);
}
void
gdk_display_pointer_ungrab (GdkDisplay *display,
guint32 time)
{
GdkPointerGrabInfo *grab = _gdk_display_get_last_pointer_grab (display);
if (grab)
{
grab->serial_end = 0;
}
_gdk_display_pointer_grab_update (display, 0);
}
/*************************************************************************************************
* Keyboard
*/
GdkGrabStatus
gdk_directfb_keyboard_grab (GdkDisplay *display,
GdkWindow *window,
gint owner_events,
guint32 time)
{
GdkWindow *toplevel;
GdkWindowImplDirectFB *impl;
g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
if (_gdk_directfb_keyboard_grab_window)
gdk_keyboard_ungrab (time);
toplevel = gdk_directfb_window_find_toplevel (window);
impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (toplevel)->impl);
if (impl->window)
{
if (impl->window->GrabKeyboard (impl->window) == DFB_LOCKED)
return GDK_GRAB_ALREADY_GRABBED;
}
_gdk_directfb_keyboard_grab_window = g_object_ref (window);
_gdk_directfb_keyboard_grab_owner_events = owner_events;
return GDK_GRAB_SUCCESS;
}
void
gdk_directfb_keyboard_ungrab (GdkDisplay *display,
guint32 time)
{
GdkWindow *toplevel;
GdkWindowImplDirectFB *impl;
if (!_gdk_directfb_keyboard_grab_window)
return;
toplevel = gdk_directfb_window_find_toplevel (_gdk_directfb_keyboard_grab_window);
impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (toplevel)->impl);
if (impl->window)
impl->window->UngrabKeyboard (impl->window);
g_object_unref (_gdk_directfb_keyboard_grab_window);
_gdk_directfb_keyboard_grab_window = NULL;
}
/*
*--------------------------------------------------------------
* gdk_keyboard_grab
*
* Grabs the keyboard to a specific window
*
* Arguments:
* "window" is the window which will receive the grab
* "owner_events" specifies whether events will be reported as is,
* or relative to "window"
* "time" specifies the time
*
* Results:
*
* Side effects:
* requires a corresponding call to gdk_keyboard_ungrab
*
*--------------------------------------------------------------
*/
GdkGrabStatus
gdk_display_keyboard_grab (GdkDisplay *display,
GdkWindow *window,
gint owner_events,
guint32 time)
{
return gdk_directfb_keyboard_grab (display, window, owner_events, time);
}
void
gdk_display_keyboard_ungrab (GdkDisplay *display,
guint32 time)
{
return gdk_directfb_keyboard_ungrab (display, time);
}
/*************************************************************************************************
* Misc Stuff
*/
void
gdk_display_beep (GdkDisplay *display)
{
}
void
gdk_display_sync (GdkDisplay *display)
{
}
void
gdk_display_flush (GdkDisplay *display)
{
}
/*************************************************************************************************
* Notifications
*/
void
gdk_notify_startup_complete (void)
{
}
/**
* gdk_notify_startup_complete_with_id:
* @startup_id: a startup-notification identifier, for which notification
* process should be completed
*
* Indicates to the GUI environment that the application has finished
* loading, using a given identifier.
*
* GTK+ will call this function automatically for #GtkWindow with custom
* startup-notification identifier unless
* gtk_window_set_auto_startup_notification() is called to disable
* that feature.
*
* Since: 2.12
**/
void
gdk_notify_startup_complete_with_id (const gchar* startup_id)
{
}
/*************************************************************************************************
* Compositing
*/
gboolean
gdk_display_supports_composite (GdkDisplay *display)
{
return FALSE;
}

59
gdk/directfb/gdkdisplay-directfb.h
View File

@ -1,59 +0,0 @@
/*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library 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.
*/
#ifndef GDK_DISPLAY_DFB_H
#define GDK_DISPLAY_DFB_H
#include <directfb.h>
#include <gdk/gdkdisplay.h>
#include <gdk/gdkkeys.h>
G_BEGIN_DECLS
typedef struct _GdkDisplayDFB GdkDisplayDFB;
typedef struct _GdkDisplayDFBClass GdkDisplayDFBClass;
#define GDK_TYPE_DISPLAY_DFB (gdk_display_dfb_get_type())
#define GDK_DISPLAY_DFB(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_DFB, GdkDisplayDFB))
#define GDK_DISPLAY_DFB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DISPLAY_DFB, GdkDisplayDFBClass))
#define GDK_IS_DISPLAY_DFB(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY_DFB))
#define GDK_IS_DISPLAY_DFB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DISPLAY_DFB))
#define GDK_DISPLAY_DFB_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DISPLAY_DFB, GdkDisplayDFBClass))
struct _GdkDisplayDFB
{
GdkDisplay parent;
IDirectFB *directfb;
IDirectFBDisplayLayer *layer;
IDirectFBEventBuffer *buffer;
IDirectFBInputDevice *keyboard;
GdkKeymap *keymap;
};
struct _GdkDisplayDFBClass
{
GdkDisplayClass parent;
};
GType gdk_display_dfb_get_type (void);
IDirectFBSurface * gdk_display_dfb_create_surface (GdkDisplayDFB *display,int format,int width, int height);
G_END_DECLS
#endif /* GDK_DISPLAY_DFB_H */

634
gdk/directfb/gdkdnd-directfb.c
View File

@ -1,634 +0,0 @@
/* GDK - The GIMP Drawing Kit
* Copyright (C) 1995-1999 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 "gdkdnd.h"
#include "gdkproperty.h"
typedef struct _GdkDragContextPrivate GdkDragContextPrivate;
typedef enum
{
GDK_DRAG_STATUS_DRAG,
GDK_DRAG_STATUS_MOTION_WAIT,
GDK_DRAG_STATUS_ACTION_WAIT,
GDK_DRAG_STATUS_DROP
} GtkDragStatus;
/* Structure that holds information about a drag in progress.
* this is used on both source and destination sides.
*/
struct _GdkDragContextPrivate
{
GdkAtom local_selection;
guint16 last_x; /* Coordinates from last event */
guint16 last_y;
guint drag_status : 4; /* current status of drag */
};
/* Drag Contexts */
static GList *contexts = NULL;
static GdkDragContext *current_dest_drag = NULL;
#define GDK_DRAG_CONTEXT_PRIVATE_DATA(ctx) ((GdkDragContextPrivate *) GDK_DRAG_CONTEXT (ctx)->windowing_data)
static void gdk_drag_context_finalize (GObject *object);
G_DEFINE_TYPE (GdkDragContext, gdk_drag_context, G_TYPE_OBJECT)
static void
gdk_drag_context_init (GdkDragContext *dragcontext)
{
GdkDragContextPrivate *private;
private = G_TYPE_INSTANCE_GET_PRIVATE (dragcontext,
GDK_TYPE_DRAG_CONTEXT,
GdkDragContextPrivate);
dragcontext->windowing_data = private;
contexts = g_list_prepend (contexts, dragcontext);
}
static void
gdk_drag_context_class_init (GdkDragContextClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gdk_drag_context_finalize;
g_type_class_add_private (object_class, sizeof (GdkDragContextPrivate));
}
static void
gdk_drag_context_finalize (GObject *object)
{
GdkDragContext *context = GDK_DRAG_CONTEXT (object);
g_list_free (context->targets);
if (context->source_window)
g_object_unref (context->source_window);
if (context->dest_window)
g_object_unref (context->dest_window);
contexts = g_list_remove (contexts, context);
G_OBJECT_CLASS (gdk_drag_context_parent_class)->finalize (object);
}
GdkDragContext *
gdk_drag_context_new (void)
{
return g_object_new (gdk_drag_context_get_type (), NULL);
}
static GdkDragContext *
gdk_drag_context_find (gboolean is_source,
GdkWindow *source,
GdkWindow *dest)
{
GdkDragContext *context;
GdkDragContextPrivate *private;
GList *list;
for (list = contexts; list; list = list->next)
{
context = (GdkDragContext *) list->data;
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (context);
if ((!context->is_source == !is_source) &&
((source == NULL) ||
(context->source_window && (context->source_window == source))) &&
((dest == NULL) ||
(context->dest_window && (context->dest_window == dest))))
return context;
}
return NULL;
}
/************************** Public API ***********************/
void
_gdk_dnd_init (void)
{
}
/* Source side */
static void
local_send_leave (GdkDragContext *context,
guint32 time)
{
GdkEvent event;
if ((current_dest_drag != NULL) &&
(current_dest_drag->protocol == GDK_DRAG_PROTO_LOCAL) &&
(current_dest_drag->source_window == context->source_window))
{
event.dnd.type = GDK_DRAG_LEAVE;
event.dnd.window = context->dest_window;
/* Pass ownership of context to the event */
event.dnd.context = current_dest_drag;
event.dnd.send_event = FALSE;
event.dnd.time = time;
current_dest_drag = NULL;
gdk_event_put (&event);
}
}
static void
local_send_enter (GdkDragContext *context,
guint32 time)
{
GdkDragContextPrivate *private;
GdkDragContext *new_context;
GdkEvent event;
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (context);
if (!private->local_selection)
private->local_selection = gdk_atom_intern ("LocalDndSelection", FALSE);
if (current_dest_drag != NULL)
{
g_object_unref (current_dest_drag);
current_dest_drag = NULL;
}
new_context = gdk_drag_context_new ();
new_context->protocol = GDK_DRAG_PROTO_LOCAL;
new_context->is_source = FALSE;
new_context->source_window = g_object_ref (context->source_window);
new_context->dest_window = g_object_ref (context->dest_window);
new_context->targets = g_list_copy (context->targets);
gdk_window_set_events (new_context->source_window,
gdk_window_get_events (new_context->source_window) |
GDK_PROPERTY_CHANGE_MASK);
new_context->actions = context->actions;
event.dnd.type = GDK_DRAG_ENTER;
event.dnd.window = context->dest_window;
event.dnd.send_event = FALSE;
event.dnd.context = new_context;
event.dnd.time = time;
current_dest_drag = new_context;
(GDK_DRAG_CONTEXT_PRIVATE_DATA (new_context))->local_selection =
private->local_selection;
gdk_event_put (&event);
}
static void
local_send_motion (GdkDragContext *context,
gint x_root,
gint y_root,
GdkDragAction action,
guint32 time)
{
GdkEvent event;
if ((current_dest_drag != NULL) &&
(current_dest_drag->protocol == GDK_DRAG_PROTO_LOCAL) &&
(current_dest_drag->source_window == context->source_window))
{
event.dnd.type = GDK_DRAG_MOTION;
event.dnd.window = current_dest_drag->dest_window;
event.dnd.send_event = FALSE;
event.dnd.context = current_dest_drag;
event.dnd.time = time;
event.dnd.x_root = x_root;
event.dnd.y_root = y_root;
current_dest_drag->suggested_action = action;
current_dest_drag->actions = action;
(GDK_DRAG_CONTEXT_PRIVATE_DATA (current_dest_drag))->last_x = x_root;
(GDK_DRAG_CONTEXT_PRIVATE_DATA (current_dest_drag))->last_y = y_root;
GDK_DRAG_CONTEXT_PRIVATE_DATA (context)->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
gdk_event_put (&event);
}
}
static void
local_send_drop (GdkDragContext *context,
guint32 time)
{
GdkEvent event;
if ((current_dest_drag != NULL) &&
(current_dest_drag->protocol == GDK_DRAG_PROTO_LOCAL) &&
(current_dest_drag->source_window == context->source_window))
{
GdkDragContextPrivate *private;
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (current_dest_drag);
event.dnd.type = GDK_DROP_START;
event.dnd.window = current_dest_drag->dest_window;
event.dnd.send_event = FALSE;
event.dnd.context = current_dest_drag;
event.dnd.time = time;
event.dnd.x_root = private->last_x;
event.dnd.y_root = private->last_y;
gdk_event_put (&event);
}
}
static void
gdk_drag_do_leave (GdkDragContext *context,
guint32 time)
{
if (context->dest_window)
{
switch (context->protocol)
{
case GDK_DRAG_PROTO_LOCAL:
local_send_leave (context, time);
break;
default:
break;
}
g_object_unref (context->dest_window);
context->dest_window = NULL;
}
}
GdkDragContext *
gdk_drag_begin (GdkWindow *window,
GList *targets)
{
GList *list;
GdkDragContext *new_context;
g_return_val_if_fail (window != NULL, NULL);
g_object_ref (window);
new_context = gdk_drag_context_new ();
new_context->is_source = TRUE;
new_context->source_window = window;
new_context->targets = NULL;
new_context->actions = 0;
for (list = targets; list; list = list->next)
new_context->targets = g_list_append (new_context->targets, list->data);
return new_context;
}
guint32
gdk_drag_get_protocol_for_display(GdkDisplay *display, guint32 xid,
GdkDragProtocol *protocol)
{
GdkWindow *window;
window = gdk_window_lookup ((GdkNativeWindow) xid);
if (window &&
g_object_get_data (G_OBJECT (window), "gdk-dnd-registered") != NULL)
{
*protocol = GDK_DRAG_PROTO_LOCAL;
return xid;
}
*protocol = GDK_DRAG_PROTO_NONE;
return 0;
}
void
gdk_drag_find_window_for_screen (GdkDragContext *context,
GdkWindow *drag_window,
GdkScreen *screen,
gint x_root,
gint y_root,
GdkWindow **dest_window,
GdkDragProtocol *protocol)
{
GdkWindow *dest;
g_return_if_fail (context != NULL);
dest = gdk_window_get_pointer (NULL, &x_root, &y_root, NULL);
if (context->dest_window != dest)
{
guint32 recipient;
/* Check if new destination accepts drags, and which protocol */
if ((recipient = gdk_drag_get_protocol (GDK_WINDOW_DFB_ID (dest),
protocol)))
{
*dest_window = gdk_window_lookup ((GdkNativeWindow) recipient);
if (dest_window)
g_object_ref (*dest_window);
}
else
*dest_window = NULL;
}
else
{
*dest_window = context->dest_window;
if (*dest_window)
g_object_ref (*dest_window);
*protocol = context->protocol;
}
}
gboolean
gdk_drag_motion (GdkDragContext *context,
GdkWindow *dest_window,
GdkDragProtocol protocol,
gint x_root,
gint y_root,
GdkDragAction suggested_action,
GdkDragAction possible_actions,
guint32 time)
{
GdkDragContextPrivate *private;
g_return_val_if_fail (context != NULL, FALSE);
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (context);
if (context->dest_window != dest_window)
{
GdkEvent event;
/* Send a leave to the last destination */
gdk_drag_do_leave (context, time);
private->drag_status = GDK_DRAG_STATUS_DRAG;
/* Check if new destination accepts drags, and which protocol */
if (dest_window)
{
context->dest_window = g_object_ref (dest_window);
context->protocol = protocol;
switch (protocol)
{
case GDK_DRAG_PROTO_LOCAL:
local_send_enter (context, time);
break;
default:
break;
}
context->suggested_action = suggested_action;
}
else
{
context->dest_window = NULL;
context->action = 0;
}
/* Push a status event, to let the client know that
* the drag changed
*/
event.dnd.type = GDK_DRAG_STATUS;
event.dnd.window = context->source_window;
/* We use this to signal a synthetic status. Perhaps
* we should use an extra field...
*/
event.dnd.send_event = TRUE;
event.dnd.context = context;
event.dnd.time = time;
gdk_event_put (&event);
}
else
{
context->suggested_action = suggested_action;
}
/* Send a drag-motion event */
private->last_x = x_root;
private->last_y = y_root;
if (context->dest_window)
{
if (private->drag_status == GDK_DRAG_STATUS_DRAG)
{
switch (context->protocol)
{
case GDK_DRAG_PROTO_LOCAL:
local_send_motion (context,
x_root, y_root, suggested_action, time);
break;
case GDK_DRAG_PROTO_NONE:
g_warning ("GDK_DRAG_PROTO_NONE is not valid in gdk_drag_motion()");
break;
default:
break;
}
}
else
return TRUE;
}
return FALSE;
}
void
gdk_drag_drop (GdkDragContext *context,
guint32 time)
{
g_return_if_fail (context != NULL);
if (context->dest_window)
{
switch (context->protocol)
{
case GDK_DRAG_PROTO_LOCAL:
local_send_drop (context, time);
break;
case GDK_DRAG_PROTO_NONE:
g_warning ("GDK_DRAG_PROTO_NONE is not valid in gdk_drag_drop()");
break;
default:
break;
}
}
}
void
gdk_drag_abort (GdkDragContext *context,
guint32 time)
{
g_return_if_fail (context != NULL);
gdk_drag_do_leave (context, time);
}
/* Destination side */
void
gdk_drag_status (GdkDragContext *context,
GdkDragAction action,
guint32 time)
{
GdkDragContextPrivate *private;
GdkDragContext *src_context;
GdkEvent event;
g_return_if_fail (context != NULL);
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (context);
src_context = gdk_drag_context_find (TRUE,
context->source_window,
context->dest_window);
if (src_context)
{
GdkDragContextPrivate *private;
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (src_context);
if (private->drag_status == GDK_DRAG_STATUS_MOTION_WAIT)
private->drag_status = GDK_DRAG_STATUS_DRAG;
event.dnd.type = GDK_DRAG_STATUS;
event.dnd.window = src_context->source_window;
event.dnd.send_event = FALSE;
event.dnd.context = src_context;
event.dnd.time = time;
src_context->action = action;
gdk_event_put (&event);
}
}
void
gdk_drop_reply (GdkDragContext *context,
gboolean ok,
guint32 time)
{
g_return_if_fail (context != NULL);
}
void
gdk_drop_finish (GdkDragContext *context,
gboolean success,
guint32 time)
{
GdkDragContextPrivate *private;
GdkDragContext *src_context;
GdkEvent event;
g_return_if_fail (context != NULL);
private = GDK_DRAG_CONTEXT_PRIVATE_DATA (context);
src_context = gdk_drag_context_find (TRUE,
context->source_window,
context->dest_window);
if (src_context)
{
g_object_ref (src_context);
event.dnd.type = GDK_DROP_FINISHED;
event.dnd.window = src_context->source_window;
event.dnd.send_event = FALSE;
event.dnd.context = src_context;
gdk_event_put (&event);
}
}
gboolean
gdk_drag_drop_succeeded (GdkDragContext *context)
{
g_warning("gdk_drag_drop_succeeded unimplemented \n");
return TRUE;
}
void
gdk_window_register_dnd (GdkWindow *window)
{
g_return_if_fail (window != NULL);
if (g_object_get_data (G_OBJECT (window), "gdk-dnd-registered") != NULL)
return;
g_object_set_data (G_OBJECT (window),
"gdk-dnd-registered",
GINT_TO_POINTER (TRUE));
}
/*************************************************************
* gdk_drag_get_selection:
* Returns the selection atom for the current source window
* arguments:
*
* results:
*************************************************************/
GdkAtom
gdk_drag_get_selection (GdkDragContext *context)
{
g_return_val_if_fail (context != NULL, GDK_NONE);
if (context->protocol == GDK_DRAG_PROTO_LOCAL)
return (GDK_DRAG_CONTEXT_PRIVATE_DATA (context))->local_selection;
else
return GDK_NONE;
}

626
gdk/directfb/gdkdrawable-directfb.c
View File

@ -1,626 +0,0 @@
/* 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 <assert.h>
#include <string.h>
#include "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
#include "../../gdk-pixbuf/gdk-pixbuf-private.h"
#include "gdkinternals.h"
#include "cairo-directfb.h"
#include <direct/debug.h>
#include <direct/messages.h>
/*
* There can be multiple domains in one file and one domain (same same) in multiple files.
*/
D_DEBUG_DOMAIN( GDKDFB_Drawable, "GDKDFB/Drawable", "GDK DirectFB Drawable" );
D_DEBUG_DOMAIN( GDKDFB_DrawClip, "GDKDFB/DrawClip", "GDK DirectFB Drawable Clip Region" );
/* From DirectFB's <gfx/generix/duffs_device.h> */
#define DUFF_1() \
case 1:\
SET_PIXEL( D[0], S[0] );
#define DUFF_2() \
case 3:\
SET_PIXEL( D[2], S[2] );\
case 2:\
SET_PIXEL( D[1], S[1] );\
DUFF_1()
#define DUFF_3() \
case 7:\
SET_PIXEL( D[6], S[6] );\
case 6:\
SET_PIXEL( D[5], S[5] );\
case 5:\
SET_PIXEL( D[4], S[4] );\
case 4:\
SET_PIXEL( D[3], S[3] );\
DUFF_2()
#define DUFF_4() \
case 15:\
SET_PIXEL( D[14], S[14] );\
case 14:\
SET_PIXEL( D[13], S[13] );\
case 13:\
SET_PIXEL( D[12], S[12] );\
case 12:\
SET_PIXEL( D[11], S[11] );\
case 11:\
SET_PIXEL( D[10], S[10] );\
case 10:\
SET_PIXEL( D[9], S[9] );\
case 9:\
SET_PIXEL( D[8], S[8] );\
case 8:\
SET_PIXEL( D[7], S[7] );\
DUFF_3()
#define SET_PIXEL_DUFFS_DEVICE_N( D, S, w, n ) \
do {\
while (w) {\
register int l = w & ((1 << n) - 1);\
switch (l) {\
default:\
l = (1 << n);\
SET_PIXEL( D[(1 << n)-1], S[(1 << n)-1] );\
DUFF_##n()\
}\
D += l;\
S += l;\
w -= l;\
}\
} while(0)
static GdkScreen * gdk_directfb_get_screen (GdkDrawable *drawable);
static void gdk_drawable_impl_directfb_class_init (GdkDrawableImplDirectFBClass *klass);
static cairo_surface_t *gdk_directfb_ref_cairo_surface (GdkDrawable *drawable);
static gboolean accelerated_alpha_blending = FALSE;
static gpointer parent_class = NULL;
static const cairo_user_data_key_t gdk_directfb_cairo_key;
/**********************************************************
* DirectFB specific implementations of generic functions *
**********************************************************/
static void
gdk_directfb_set_colormap (GdkDrawable *drawable,
GdkColormap *colormap)
{
GdkDrawableImplDirectFB *impl;
impl = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
D_DEBUG_AT( GDKDFB_Drawable, "%s( %p, %p ) <- old %p\n", G_STRFUNC, drawable, colormap, impl->colormap );
if (impl->colormap == colormap)
return;
if (impl->colormap)
g_object_unref (impl->colormap);
impl->colormap = colormap;
if (colormap)
g_object_ref (colormap);
}
static GdkColormap*
gdk_directfb_get_colormap (GdkDrawable *drawable)
{
GdkColormap *retval;
retval = GDK_DRAWABLE_IMPL_DIRECTFB (drawable)->colormap;
if (!retval) {
retval = gdk_colormap_get_system ();
gdk_directfb_set_colormap(drawable,retval);
}
return retval;
}
static gint
gdk_directfb_get_depth (GdkDrawable *drawable)
{
GdkDrawableImplDirectFB *impl = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
return DFB_BITS_PER_PIXEL (impl->format);
}
static void
gdk_directfb_get_size (GdkDrawable *drawable,
gint *width,
gint *height)
{
GdkDrawableImplDirectFB *impl;
impl = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
if (width)
*width = impl->width;
if (height)
*height = impl->height;
}
static GdkVisual*
gdk_directfb_get_visual (GdkDrawable *drawable)
{
return gdk_visual_get_system ();
}
/* Calculates the real clipping region for a drawable, taking into account
* other windows and the gc clip region.
*/
void
gdk_directfb_clip_region (GdkDrawable *drawable,
GdkGC *gc,
GdkRectangle *draw_rect,
cairo_region_t *ret_clip)
{
GdkDrawableImplDirectFB *private;
GdkRectangle rect;
g_return_if_fail (GDK_IS_DRAWABLE (drawable));
g_return_if_fail (GDK_IS_DRAWABLE_IMPL_DIRECTFB (drawable));
g_return_if_fail (ret_clip != NULL);
D_DEBUG_AT( GDKDFB_DrawClip, "%s( %p, %p, %p )\n", G_STRFUNC, drawable, gc, draw_rect );
private = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
if (!draw_rect)
{
rect.x = 0;
rect.y = 0;
rect.width = private->width;
rect.height = private->height;
draw_rect = &rect;
}
D_DEBUG_AT( GDKDFB_DrawClip, " -> draw rectangle == %4d,%4d - %4dx%4d =\n",
draw_rect->x, draw_rect->y, draw_rect->width, draw_rect->height );
temp_region_init_rectangle( ret_clip, draw_rect );
if (private->buffered) {
D_DEBUG_AT( GDKDFB_DrawClip, " -> buffered region > %4d,%4d - %4dx%4d < (%ld boxes)\n",
GDKDFB_RECTANGLE_VALS_FROM_BOX( &private->paint_region.extents ),
private->paint_region.numRects );
cairo_region_intersect (ret_clip, &private->paint_region);
}
if (gc)
{
GdkGCDirectFB *gc_private = GDK_GC_DIRECTFB (gc);
cairo_region_t *region = &gc_private->clip_region;
if (region->numRects)
{
D_DEBUG_AT( GDKDFB_DrawClip, " -> clipping region > %4d,%4d - %4dx%4d < (%ld boxes)\n",
GDKDFB_RECTANGLE_VALS_FROM_BOX( &region->extents ), region->numRects );
if (gc->clip_x_origin || gc->clip_y_origin)
{
cairo_region_translate (ret_clip, -gc->clip_x_origin, -gc->clip_y_origin);
cairo_region_intersect (ret_clip, region);
cairo_region_translate (ret_clip, gc->clip_x_origin, gc->clip_y_origin);
}
else
{
cairo_region_intersect (ret_clip, region);
}
}
if (gc_private->values_mask & GDK_GC_SUBWINDOW &&
gc_private->values.subwindow_mode == GDK_INCLUDE_INFERIORS)
return;
}
if (private->buffered) {
D_DEBUG_AT( GDKDFB_DrawClip, " => returning clip >> %4d,%4d - %4dx%4d << (%ld boxes)\n",
GDKDFB_RECTANGLE_VALS_FROM_BOX( &ret_clip->extents ), ret_clip->numRects );
return;
}
if (GDK_IS_WINDOW (private->wrapper) &&
GDK_WINDOW_IS_MAPPED (private->wrapper) &&
!GDK_WINDOW_OBJECT (private->wrapper)->input_only)
{
GList *cur;
cairo_region_t temp;
temp.numRects = 1;
temp.rects = &temp.extents;
temp.size = 1;
for (cur = GDK_WINDOW_OBJECT (private->wrapper)->children;
cur;
cur = cur->next)
{
GdkWindowObject *cur_private;
GdkDrawableImplDirectFB *cur_impl;
cur_private = GDK_WINDOW_OBJECT (cur->data);
if (!GDK_WINDOW_IS_MAPPED (cur_private) || cur_private->input_only)
continue;
cur_impl = GDK_DRAWABLE_IMPL_DIRECTFB (cur_private->impl);
temp.extents.x1 = cur_private->x;
temp.extents.y1 = cur_private->y;
temp.extents.x2 = cur_private->x + cur_impl->width;
temp.extents.y2 = cur_private->y + cur_impl->height;
D_DEBUG_AT( GDKDFB_DrawClip, " -> clipping child [ %4d,%4d - %4dx%4d ] (%ld boxes)\n",
GDKDFB_RECTANGLE_VALS_FROM_BOX( &temp.extents ), temp.numRects );
cairo_region_subtract (ret_clip, &temp);
}
}
D_DEBUG_AT( GDKDFB_DrawClip, " => returning clip >> %4d,%4d - %4dx%4d << (%ld boxes)\n",
GDKDFB_RECTANGLE_VALS_FROM_BOX( &ret_clip->extents ), ret_clip->numRects );
}
/* Drawing
*/
static inline void
gdk_directfb_set_color (GdkDrawableImplDirectFB *impl,
GdkColor *color,
guchar alpha)
{
if (DFB_PIXELFORMAT_IS_INDEXED (impl->format))
{
impl->surface->SetColorIndex (impl->surface, color->pixel);
}
else
{
impl->surface->SetColor (impl->surface,
color->red >> 8,
color->green >> 8,
color->blue >> 8,
alpha);
}
}
static gboolean
gdk_directfb_setup_for_drawing (GdkDrawableImplDirectFB *impl,
GdkGCDirectFB *gc_private)
{
DFBSurfaceDrawingFlags flags = DSDRAW_NOFX;
GdkColor color = { 0, 0, 0, 0 };
guchar alpha = 0xFF;
if (!impl->surface)
return FALSE;
if (gc_private && gc_private->values_mask & GDK_GC_FOREGROUND)
color = gc_private->values.foreground;
if (gc_private && gc_private->values_mask & GDK_GC_FUNCTION)
{
switch (gc_private->values.function)
{
case GDK_COPY:
flags = DSDRAW_NOFX;
break;
case GDK_INVERT:
color.red = color.green = color.blue = 0xFFFF;
alpha = 0x0;
flags = DSDRAW_XOR;
break;
case GDK_XOR:
alpha = 0x0;
flags = DSDRAW_XOR;
break;
case GDK_CLEAR:
color.red = color.green = color.blue = 0x0;
flags = DSDRAW_NOFX;
break;
case GDK_NOOP:
return FALSE;
case GDK_SET:
color.red = color.green = color.blue = 0xFFFF;
flags = DSDRAW_NOFX;
break;
default:
g_message ("unsupported GC function %d",
gc_private->values.function);
flags = DSDRAW_NOFX;
break;
}
}
gdk_directfb_set_color (impl, &color, alpha);
impl->surface->SetDrawingFlags (impl->surface, flags);
return TRUE;
}
static inline void
convert_rgba_pixbuf_to_image (guint32 *src,
guint src_pitch,
guint32 *dest,
guint dest_pitch,
guint width,
guint height)
{
guint i;
while (height--)
{
for (i = 0; i < width; i++)
{
guint32 pixel = GUINT32_FROM_BE (src[i]);
dest[i] = (pixel >> 8) | (pixel << 24);
}
src += src_pitch;
dest += dest_pitch;
}
}
static inline void
convert_rgb_pixbuf_to_image (guchar *src,
guint src_pitch,
guint32 *dest,
guint dest_pitch,
guint width,
guint height)
{
guint i;
guchar *s;
while (height--)
{
s = src;
for (i = 0; i < width; i++, s += 3)
dest[i] = 0xFF000000 | (s[0] << 16) | (s[1] << 8) | s[2];
src += src_pitch;
dest += dest_pitch;
}
}
/*
* Object stuff
*/
static inline const char *
drawable_impl_type_name( GObject *object )
{
if (GDK_IS_PIXMAP (object))
return "PIXMAP";
if (GDK_IS_WINDOW (object))
return "WINDOW";
if (GDK_IS_DRAWABLE_IMPL_DIRECTFB (object))
return "DRAWABLE";
return "unknown";
}
static void
gdk_drawable_impl_directfb_finalize (GObject *object)
{
GdkDrawableImplDirectFB *impl;
impl = GDK_DRAWABLE_IMPL_DIRECTFB (object);
D_DEBUG_AT( GDKDFB_Drawable, "%s( %p ) <- %dx%d (%s at %4d,%4d)\n", G_STRFUNC,
object, impl->width, impl->height,
drawable_impl_type_name( object ),
impl->abs_x, impl->abs_y );
gdk_directfb_set_colormap (GDK_DRAWABLE (object), NULL);
if( impl->cairo_surface ) {
cairo_surface_finish(impl->cairo_surface);
}
if( impl->surface )
impl->surface->Release (impl->surface);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gdk_drawable_impl_directfb_class_init (GdkDrawableImplDirectFBClass *klass)
{
GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gdk_drawable_impl_directfb_finalize;
drawable_class->create_gc = _gdk_directfb_gc_new;
drawable_class->ref_cairo_surface = gdk_directfb_ref_cairo_surface;
drawable_class->set_colormap = gdk_directfb_set_colormap;
drawable_class->get_colormap = gdk_directfb_get_colormap;
drawable_class->get_depth = gdk_directfb_get_depth;
drawable_class->get_visual = gdk_directfb_get_visual;
drawable_class->get_size = gdk_directfb_get_size;
drawable_class->get_screen = gdk_directfb_get_screen;
real_draw_pixbuf = drawable_class->draw_pixbuf;
drawable_class->draw_pixbuf = gdk_directfb_draw_pixbuf;
/* check for hardware-accelerated alpha-blending */
{
DFBGraphicsDeviceDescription desc;
_gdk_display->directfb->GetDeviceDescription ( _gdk_display->directfb, &desc);
accelerated_alpha_blending =
((desc.acceleration_mask & DFXL_BLIT) &&
(desc.blitting_flags & DSBLIT_BLEND_ALPHACHANNEL));
}
}
GType
gdk_drawable_impl_directfb_get_type (void)
{
static GType object_type = 0;
if (!object_type)
{
const GTypeInfo object_info =
{
sizeof (GdkDrawableImplDirectFBClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gdk_drawable_impl_directfb_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GdkDrawableImplDirectFB),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
object_type = g_type_register_static (GDK_TYPE_DRAWABLE,
"GdkDrawableImplDirectFB",
&object_info, 0);
}
return object_type;
}
static GdkScreen * gdk_directfb_get_screen (GdkDrawable *drawable){
return gdk_screen_get_default();
}
static void
gdk_directfb_cairo_surface_destroy (void *data)
{
GdkDrawableImplDirectFB *impl = data;
impl->cairo_surface = NULL;
}
void
_gdk_windowing_set_cairo_surface_size (cairo_surface_t *surface,
int width,
int height)
{
}
cairo_surface_t *
_gdk_windowing_create_cairo_surface (GdkDrawable *drawable,
int width,
int height)
{
GdkDrawableImplDirectFB *impl;
IDirectFB *dfb;
cairo_surface_t *ret;
impl = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
dfb = GDK_DISPLAY_DFB (gdk_drawable_get_display (drawable))->directfb;
ret = cairo_directfb_surface_create (dfb, impl->surface);
cairo_surface_set_user_data (ret,
&gdk_directfb_cairo_key, drawable,
gdk_directfb_cairo_surface_destroy);
return ret;
}
static cairo_surface_t *
gdk_directfb_ref_cairo_surface (GdkDrawable *drawable)
{
GdkDrawableImplDirectFB *impl;
IDirectFB *dfb;
g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_DIRECTFB (drawable), NULL);
impl = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
dfb = GDK_DISPLAY_DFB(gdk_drawable_get_display(drawable))->directfb;
if (!impl->cairo_surface) {
IDirectFBSurface *surface;
g_assert (impl->surface != NULL);
#if defined(CAIRO_VERSION) && CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1,5,5)
impl->surface->GetSubSurface (impl->surface, NULL, &surface);
#else
surface = impl->surface;
#endif
if (surface) {
impl->cairo_surface = cairo_directfb_surface_create (dfb, surface);
if (impl->cairo_surface) {
cairo_surface_set_user_data (impl->cairo_surface,
&gdk_directfb_cairo_key, drawable,
gdk_directfb_cairo_surface_destroy);
}
#if defined(CAIRO_VERSION) && CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1,5,5)
surface->Release (surface);
#endif
}
} else {
cairo_surface_reference (impl->cairo_surface);
}
g_assert (impl->cairo_surface != NULL);
return impl->cairo_surface;
}

963
gdk/directfb/gdkevents-directfb.c
View File

@ -1,963 +0,0 @@
/* 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
#define EventBuffer _gdk_display->buffer
#define DirectFB _gdk_display->directfb
/*********************************************
* Functions for maintaining the event queue *
*********************************************/
static GdkEvent * gdk_event_translate (DFBWindowEvent *dfbevent,
GdkWindow *window);
/*
* Private variable declarations
*/
static GList *client_filters; /* Filters for client messages */
static void
fixup_event (GdkEvent *event)
{
if (event->any.window)
g_object_ref (event->any.window);
if (((event->any.type == GDK_ENTER_NOTIFY) ||
(event->any.type == GDK_LEAVE_NOTIFY)) &&
(event->crossing.subwindow != NULL))
g_object_ref (event->crossing.subwindow);
event->any.send_event = FALSE;
}
static GdkFilterReturn
apply_filters (GdkWindow *window,
DFBWindowEvent *dfbevent,
GList *filters)
{
GdkFilterReturn result = GDK_FILTER_CONTINUE;
GdkEvent *event;
GList *node;
GList *tmp_list;
event = gdk_event_new (GDK_NOTHING);
if (window != NULL)
event->any.window = g_object_ref (window);
((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;
/* I think GdkFilterFunc semantics require the passed-in event
* to already be in the queue. The filter func can generate
* more events and append them after it if it likes.
*/
node = _gdk_event_queue_append ((GdkDisplay*)_gdk_display, event);
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)
break;
}
if (result == GDK_FILTER_CONTINUE || result == GDK_FILTER_REMOVE)
{
_gdk_event_queue_remove_link ((GdkDisplay*)_gdk_display, node);
g_list_free_1 (node);
gdk_event_free (event);
}
else /* GDK_FILTER_TRANSLATE */
{
((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;
fixup_event (event);
}
return result;
}
static void
dfb_events_process_window_event (DFBWindowEvent *event)
{
GdkWindow *window;
/*
* 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)
{
switch (apply_filters (NULL, event, _gdk_default_filters))
{
case GDK_FILTER_REMOVE:
case GDK_FILTER_TRANSLATE:
return;
default:
break;
}
}
window = gdk_directfb_window_id_table_lookup (event->window_id);
if (!window)
return;
gdk_event_translate (event, window);
}
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;
}
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;
if (GDK_WINDOW_IS_MAPPED (win) &&
*winx >= win->x &&
*winx < win->x + GDK_DRAWABLE_IMPL_DIRECTFB (win->impl)->width &&
*winy >= win->y &&
*winy < win->y + GDK_DRAWABLE_IMPL_DIRECTFB (win->impl)->height)
{
*winx -= win->x;
*winy -= win->y;
return gdk_directfb_child_at (GDK_WINDOW (win), winx, winy );
}
}
return window;
}
static GdkEvent *
gdk_event_translate (DFBWindowEvent *dfbevent,
GdkWindow *window)
{
GdkWindowObject *private;
GdkDisplay *display;
GdkEvent *event = NULL;
g_return_val_if_fail (dfbevent != NULL, NULL);
g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
private = GDK_WINDOW_OBJECT (window);
g_object_ref (G_OBJECT (window));
/*
* Apply per-window 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 (private->filters)
{
switch (apply_filters (window, dfbevent, private->filters))
{
case GDK_FILTER_REMOVE:
case GDK_FILTER_TRANSLATE:
g_object_unref (G_OBJECT (window));
return NULL;
default:
break;
}
}
display = gdk_drawable_get_display (GDK_DRAWABLE (window));
switch (dfbevent->type)
{
case DWET_BUTTONDOWN:
case DWET_BUTTONUP:
{
static gboolean click_grab = FALSE;
GdkWindow *child;
gint wx, wy;
guint mask;
guint button;
_gdk_directfb_mouse_x = wx = dfbevent->cx;
_gdk_directfb_mouse_y = wy = dfbevent->cy;
switch (dfbevent->button)
{
case DIBI_LEFT:
button = 1;
mask = GDK_BUTTON1_MASK;
break;
case DIBI_MIDDLE:
button = 2;
mask = GDK_BUTTON2_MASK;
break;
case DIBI_RIGHT:
button = 3;
mask = GDK_BUTTON3_MASK;
break;
default:
button = dfbevent->button + 1;
mask = 0;
break;
}
child = gdk_directfb_child_at (_gdk_parent_root, &wx, &wy);
if (_gdk_directfb_pointer_grab_window &&
(_gdk_directfb_pointer_grab_events & (dfbevent->type ==
DWET_BUTTONDOWN ?
GDK_BUTTON_PRESS_MASK :
GDK_BUTTON_RELEASE_MASK)) &&
(_gdk_directfb_pointer_grab_owner_events == FALSE ||
child == _gdk_parent_root) )
{
GdkDrawableImplDirectFB *impl;
child = _gdk_directfb_pointer_grab_window;
impl = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (child)->impl);
dfbevent->x = dfbevent->cx - impl->abs_x;
dfbevent->y = dfbevent->cy - impl->abs_y;
}
else if (!_gdk_directfb_pointer_grab_window ||
(_gdk_directfb_pointer_grab_owner_events == TRUE))
{
dfbevent->x = wx;
dfbevent->y = wy;
}
else
{
child = NULL;
}
if (dfbevent->type == DWET_BUTTONDOWN)
_gdk_directfb_modifiers |= mask;
else
_gdk_directfb_modifiers &= ~mask;
if (child)
{
event =
gdk_directfb_event_make (child,
dfbevent->type == DWET_BUTTONDOWN ?
GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
event->button.x_root = _gdk_directfb_mouse_x;
event->button.y_root = _gdk_directfb_mouse_y;
event->button.x = dfbevent->x;
event->button.y = dfbevent->y;
event->button.state = _gdk_directfb_modifiers;
event->button.button = button;
event->button.device = display->core_pointer;
GDK_NOTE (EVENTS,
g_message ("button: %d at %d,%d %s with state 0x%08x",
event->button.button,
(int)event->button.x, (int)event->button.y,
dfbevent->type == DWET_BUTTONDOWN ?
"pressed" : "released",
_gdk_directfb_modifiers));
if (dfbevent->type == DWET_BUTTONDOWN)
_gdk_event_button_generate (display, event);
}
/* Handle implicit button grabs: */
if (dfbevent->type == DWET_BUTTONDOWN && !click_grab && child)
{
if (gdk_directfb_pointer_grab (child, FALSE,
gdk_window_get_events (child),
NULL, NULL,
GDK_CURRENT_TIME,
TRUE) == GDK_GRAB_SUCCESS)
click_grab = TRUE;
}
else if (dfbevent->type == DWET_BUTTONUP &&
!(_gdk_directfb_modifiers & (GDK_BUTTON1_MASK |
GDK_BUTTON2_MASK |
GDK_BUTTON3_MASK)) && click_grab)
{
gdk_directfb_pointer_ungrab (GDK_CURRENT_TIME, TRUE);
click_grab = FALSE;
}
}
break;
case DWET_MOTION:
{
GdkWindow *event_win=NULL;
GdkWindow *child;
_gdk_directfb_mouse_x = dfbevent->cx;
_gdk_directfb_mouse_y = dfbevent->cy;
//child = gdk_directfb_child_at (window, &dfbevent->x, &dfbevent->y);
/* Go all the way to root to catch popup menus */
int wx=_gdk_directfb_mouse_x;
int wy=_gdk_directfb_mouse_y;
child = gdk_directfb_child_at (_gdk_parent_root, &wx, &wy);
/* first let's see if any cossing event has to be send */
gdk_directfb_window_send_crossing_events (NULL, child, GDK_CROSSING_NORMAL);
/* then dispatch the motion event to the window the cursor it's inside */
event_win = gdk_directfb_pointer_event_window (child, GDK_MOTION_NOTIFY);
if (event_win)
{
if (event_win == _gdk_directfb_pointer_grab_window) {
GdkDrawableImplDirectFB *impl;
child = _gdk_directfb_pointer_grab_window;
impl = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (child)->impl);
dfbevent->x = _gdk_directfb_mouse_x - impl->abs_x;
dfbevent->y = _gdk_directfb_mouse_y - impl->abs_y;
}
event = gdk_directfb_event_make (child, GDK_MOTION_NOTIFY);
event->motion.x_root = _gdk_directfb_mouse_x;
event->motion.y_root = _gdk_directfb_mouse_y;
//event->motion.x = dfbevent->x;
//event->motion.y = dfbevent->y;
event->motion.x = wx;
event->motion.y = wy;
event->motion.state = _gdk_directfb_modifiers;
event->motion.is_hint = FALSE;
event->motion.device = display->core_pointer;
if (GDK_WINDOW_OBJECT (event_win)->event_mask &
GDK_POINTER_MOTION_HINT_MASK)
{
while (EventBuffer->PeekEvent (EventBuffer,
DFB_EVENT (dfbevent)) == DFB_OK
&& dfbevent->type == DWET_MOTION)
{
EventBuffer->GetEvent (EventBuffer, DFB_EVENT (dfbevent));
event->motion.is_hint = TRUE;
}
}
}
/* make sure crossing events go to the event window found */
/* GdkWindow *ev_win = ( event_win == NULL ) ? gdk_window_at_pointer (NULL,NULL) :event_win;
gdk_directfb_window_send_crossing_events (NULL,ev_win,GDK_CROSSING_NORMAL);
*/
}
break;
case DWET_GOTFOCUS:
gdk_directfb_change_focus (window);
break;
case DWET_LOSTFOCUS:
gdk_directfb_change_focus (_gdk_parent_root);
break;
case DWET_POSITION:
{
GdkWindow *event_win;
private->x = dfbevent->x;
private->y = dfbevent->y;
event_win = gdk_directfb_other_event_window (window, GDK_CONFIGURE);
if (event_win)
{
event = gdk_directfb_event_make (event_win, GDK_CONFIGURE);
event->configure.x = dfbevent->x;
event->configure.y = dfbevent->y;
event->configure.width =
GDK_DRAWABLE_IMPL_DIRECTFB (private->impl)->width;
event->configure.height =
GDK_DRAWABLE_IMPL_DIRECTFB (private->impl)->height;
}
_gdk_directfb_calc_abs (window);
}
break;
case DWET_POSITION_SIZE:
private->x = dfbevent->x;
private->y = dfbevent->y;
/* fallthru */
case DWET_SIZE:
{
GdkDrawableImplDirectFB *impl;
GdkWindow *event_win;
GList *list;
impl = GDK_DRAWABLE_IMPL_DIRECTFB (private->impl);
event_win = gdk_directfb_other_event_window (window, GDK_CONFIGURE);
if (event_win)
{
event = gdk_directfb_event_make (event_win, GDK_CONFIGURE);
event->configure.x = private->x;
event->configure.y = private->y;
event->configure.width = dfbevent->w;
event->configure.height = dfbevent->h;
}
impl->width = dfbevent->w;
impl->height = dfbevent->h;
for (list = private->children; list; list = list->next)
{
GdkWindowObject *win;
GdkDrawableImplDirectFB *impl;
win = GDK_WINDOW_OBJECT (list->data);
impl = GDK_DRAWABLE_IMPL_DIRECTFB (win->impl);
_gdk_directfb_move_resize_child (GDK_WINDOW (win),
win->x, win->y,
impl->width, impl->height);
}
_gdk_directfb_calc_abs (window);
gdk_window_clear (window);
gdk_window_invalidate_rect (window, NULL, TRUE);
}
break;
case DWET_KEYDOWN:
case DWET_KEYUP:
{
GdkEventType type = (dfbevent->type == DWET_KEYUP ?
GDK_KEY_RELEASE : GDK_KEY_PRESS);
GdkWindow *event_win =
gdk_directfb_keyboard_event_window (gdk_directfb_window_find_focus (),
type);
if (event_win)
{
event = gdk_directfb_event_make (event_win, type);
gdk_directfb_translate_key_event (dfbevent, &event->key);
}
}
break;
case DWET_LEAVE:
_gdk_directfb_mouse_x = dfbevent->cx;
_gdk_directfb_mouse_y = dfbevent->cy;
gdk_directfb_window_send_crossing_events (NULL, _gdk_parent_root,
GDK_CROSSING_NORMAL);
if (gdk_directfb_apply_focus_opacity)
{
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));
}
break;
case DWET_ENTER:
{
GdkWindow *child;
_gdk_directfb_mouse_x = dfbevent->cx;
_gdk_directfb_mouse_y = dfbevent->cy;
child = gdk_directfb_child_at (window, &dfbevent->x, &dfbevent->y);
/* this makes sure pointer is set correctly when it previously left
* a window being not standard shaped
*/
gdk_window_set_cursor (window, NULL);
gdk_directfb_window_send_crossing_events (NULL, child,
GDK_CROSSING_NORMAL);
if (gdk_directfb_apply_focus_opacity)
{
GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window->SetOpacity
(GDK_WINDOW_IMPL_DIRECTFB (private->impl)->window,
GDK_WINDOW_IMPL_DIRECTFB (private->impl)->opacity);
}
}
break;
case DWET_CLOSE:
{
GdkWindow *event_win;
event_win = gdk_directfb_other_event_window (window, GDK_DELETE);
if (event_win)
event = gdk_directfb_event_make (event_win, GDK_DELETE);
}
break;
case DWET_DESTROYED:
{
GdkWindow *event_win;
event_win = gdk_directfb_other_event_window (window, GDK_DESTROY);
if (event_win)
event = gdk_directfb_event_make (event_win, GDK_DESTROY);
gdk_window_destroy_notify (window);
}
break;
case DWET_WHEEL:
{
GdkWindow *event_win;
_gdk_directfb_mouse_x = dfbevent->cx;
_gdk_directfb_mouse_y = dfbevent->cy;
if (_gdk_directfb_pointer_grab_window)
{
GdkDrawableImplDirectFB *impl;
event_win = _gdk_directfb_pointer_grab_window;
impl =
GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (event_win)->impl);
dfbevent->x = dfbevent->cx - impl->abs_x;
dfbevent->y = dfbevent->cy - impl->abs_y;
}
else
{
event_win = gdk_directfb_child_at (window,
&dfbevent->x, &dfbevent->y);
}
if (event_win)
{
event = gdk_directfb_event_make (event_win, GDK_SCROLL);
event->scroll.direction = (dfbevent->step < 0 ?
GDK_SCROLL_DOWN : GDK_SCROLL_UP);
event->scroll.x_root = _gdk_directfb_mouse_x;
event->scroll.y_root = _gdk_directfb_mouse_y;
event->scroll.x = dfbevent->x;
event->scroll.y = dfbevent->y;
event->scroll.state = _gdk_directfb_modifiers;
event->scroll.device = display->core_pointer;
}
}
break;
default:
g_message ("unhandled DirectFB windowing event 0x%08x", dfbevent->type);
}
g_object_unref (G_OBJECT (window));
return event;
}
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)
{
}

254
gdk/directfb/gdkgeometry-directfb.c
View File

@ -1,254 +0,0 @@
/* 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" /* For gdk_rectangle_intersect */
#include "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
#include "gdkinternals.h"
void
_gdk_directfb_window_get_offsets (GdkWindow *window,
gint *x_offset,
gint *y_offset)
{
if (x_offset)
*x_offset = 0;
if (y_offset)
*y_offset = 0;
}
gboolean
_gdk_windowing_window_queue_antiexpose (GdkWindow *window,
cairo_region_t *area)
{
return FALSE;
}
/**
* gdk_window_scroll:
* @window: a #GdkWindow
* @dx: Amount to scroll in the X direction
* @dy: Amount to scroll in the Y direction
*
* Scroll the contents of its window, both pixels and children, by
* the given amount. Portions of the window that the scroll operation
* brings in from offscreen areas are invalidated.
**/
void
_gdk_directfb_window_scroll (GdkWindow *window,
gint dx,
gint dy)
{
GdkWindowObject *private;
GdkDrawableImplDirectFB *impl;
cairo_region_t *invalidate_region = NULL;
GList *list;
g_return_if_fail (GDK_IS_WINDOW (window));
if (GDK_WINDOW_DESTROYED (window))
return;
private = GDK_WINDOW_OBJECT (window);
impl = GDK_DRAWABLE_IMPL_DIRECTFB (private->impl);
if (dx == 0 && dy == 0)
return;
/* Move the current invalid region */
if (private->update_area)
cairo_region_translate (private->update_area, dx, dy);
if (GDK_WINDOW_IS_MAPPED (window))
{
GdkRectangle clip_rect = { 0, 0, impl->width, impl->height };
GdkRectangle rect = { dx, dy, impl->width, impl->height };
invalidate_region = cairo_region_create_rectangle (&clip_rect);
if (gdk_rectangle_intersect (&rect, &clip_rect, &rect) &&
(!private->update_area ||
!cairo_region_contains_rectangle (private->update_area, &rect)))
{
cairo_region_t *region;
region = cairo_region_create_rectangle (&rect);
cairo_region_subtract (invalidate_region, region);
cairo_region_destroy (region);
if (impl->surface)
{
DFBRegion update = { rect.x, rect.y,
rect.x + rect.width - 1,
rect.y + rect.height - 1 };
impl->surface->SetClip (impl->surface, &update);
impl->surface->Blit (impl->surface, impl->surface, NULL, dx, dy);
impl->surface->SetClip (impl->surface, NULL);
impl->surface->Flip(impl->surface,&update,0);
}
}
}
for (list = private->children; list; list = list->next)
{
GdkWindowObject *obj = GDK_WINDOW_OBJECT (list->data);
GdkDrawableImplDirectFB *obj_impl = GDK_DRAWABLE_IMPL_DIRECTFB (obj->impl);
_gdk_directfb_move_resize_child (list->data,
obj->x + dx,
obj->y + dy,
obj_impl->width,
obj_impl->height);
}
_gdk_directfb_calc_abs (window);
if (invalidate_region)
{
gdk_window_invalidate_region (window, invalidate_region, TRUE);
cairo_region_destroy (invalidate_region);
}
}
/**
* gdk_window_move_region:
* @window: a #GdkWindow
* @region: The #cairo_region_t to move
* @dx: Amount to move in the X direction
* @dy: Amount to move in the Y direction
*
* Move the part of @window indicated by @region by @dy pixels in the Y
* direction and @dx pixels in the X direction. The portions of @region
* that not covered by the new position of @region are invalidated.
*
* Child windows are not moved.
*
* Since: 2.8
**/
void
_gdk_directfb_window_move_region (GdkWindow *window,
const cairo_region_t *region,
gint dx,
gint dy)
{
GdkWindowObject *private;
GdkDrawableImplDirectFB *impl;
cairo_region_t *window_clip;
cairo_region_t *src_region;
cairo_region_t *brought_in;
cairo_region_t *dest_region;
cairo_region_t *moving_invalid_region;
GdkRectangle dest_extents;
g_return_if_fail (GDK_IS_WINDOW (window));
g_return_if_fail (region != NULL);
if (GDK_WINDOW_DESTROYED (window))
return;
private = GDK_WINDOW_OBJECT (window);
impl = GDK_DRAWABLE_IMPL_DIRECTFB (private->impl);
if (dx == 0 && dy == 0)
return;
GdkRectangle clip_rect = { 0, 0, impl->width, impl->height };
window_clip = cairo_region_create_rectangle (&clip_rect);
/* compute source regions */
src_region = cairo_region_copy (region);
brought_in = cairo_region_copy (region);
cairo_region_intersect (src_region, window_clip);
cairo_region_subtract (brought_in, src_region);
cairo_region_translate (brought_in, dx, dy);
/* compute destination regions */
dest_region = cairo_region_copy (src_region);
cairo_region_translate (dest_region, dx, dy);
cairo_region_intersect (dest_region, window_clip);
cairo_region_get_extents (dest_region, &dest_extents);
cairo_region_destroy (window_clip);
/* calculating moving part of current invalid area */
moving_invalid_region = NULL;
if (private->update_area)
{
moving_invalid_region = cairo_region_copy (private->update_area);
cairo_region_intersect (moving_invalid_region, src_region);
cairo_region_translate (moving_invalid_region, dx, dy);
}
/* invalidate all of the src region */
gdk_window_invalidate_region (window, src_region, FALSE);
/* un-invalidate destination region */
if (private->update_area)
cairo_region_subtract (private->update_area, dest_region);
/* invalidate moving parts of existing update area */
if (moving_invalid_region)
{
gdk_window_invalidate_region (window, moving_invalid_region, FALSE);
cairo_region_destroy (moving_invalid_region);
}
/* invalidate area brought in from off-screen */
gdk_window_invalidate_region (window, brought_in, FALSE);
cairo_region_destroy (brought_in);
/* Actually do the moving */
if (impl->surface)
{
DFBRectangle source = { dest_extents.x - dx,
dest_extents.y - dy,
dest_extents.width,
dest_extents.height};
DFBRegion destination = { dest_extents.x,
dest_extents.y,
dest_extents.x+dest_extents.width-1,
dest_extents.y+dest_extents.height-1};
impl->surface->SetClip (impl->surface, &destination);
impl->surface->Blit (impl->surface, impl->surface,&source,dx,dy);
impl->surface->SetClip (impl->surface, NULL);
impl->surface->Flip(impl->surface,&destination,0);
}
cairo_region_destroy (src_region);
cairo_region_destroy (dest_region);
}

58
gdk/directfb/gdkglobals-directfb.c
View File

@ -1,58 +0,0 @@
/* 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"
GdkDisplayDFB *_gdk_display = NULL;
GdkScreen * _gdk_screen = NULL;
gboolean gdk_directfb_apply_focus_opacity = FALSE;
gboolean gdk_directfb_enable_color_keying = FALSE;
DFBColor gdk_directfb_bg_color = { 0, 0, 0, 0 };
DFBColor gdk_directfb_bg_color_key = { 0, 0, 0, 0 };
gboolean gdk_directfb_monochrome_fonts = FALSE;
GdkWindow * _gdk_directfb_pointer_grab_window = NULL;
GdkWindow * _gdk_directfb_keyboard_grab_window = NULL;
GdkWindow * _gdk_directfb_pointer_grab_confine = NULL;
gboolean _gdk_directfb_pointer_grab_owner_events = FALSE;
gboolean _gdk_directfb_keyboard_grab_owner_events = FALSE;
GdkEventMask _gdk_directfb_pointer_grab_events = 0;
GdkEventMask _gdk_directfb_keyboard_grab_events = 0;
GdkCursor * _gdk_directfb_pointer_grab_cursor = NULL;
GdkAtom _gdk_selection_property = 0;

60
gdk/directfb/gdkim-directfb.c
View File

@ -1,60 +0,0 @@
/* 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 <string.h>
#include <locale.h>
#include "gdkdirectfb.h"
/*
*--------------------------------------------------------------
* gdk_set_locale
*
* Arguments:
*
* Results:
*
* Side effects:
*
*--------------------------------------------------------------
*/
gchar*
gdk_set_locale (void)
{
if (!setlocale (LC_ALL,""))
g_warning ("locale not supported by C library");
return setlocale (LC_ALL, NULL);
}

327
gdk/directfb/gdkinput-directfb.c
View File

@ -1,327 +0,0 @@
/* GDK - The GIMP Drawing Kit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
* Copyright (C) 1999 Tor Lillqvist
*
* 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 "gdkinput-directfb.h"
#include "gdkinput.h"
#include "gdkkeysyms.h"
static GdkDeviceAxis gdk_input_core_axes[] =
{
{ GDK_AXIS_X, 0, 0 },
{ GDK_AXIS_Y, 0, 0 }
};
GdkDevice * _gdk_core_pointer = NULL;
GList * _gdk_input_devices = NULL;
gboolean _gdk_input_ignore_core = FALSE;
int _gdk_directfb_mouse_x = 0;
int _gdk_directfb_mouse_y = 0;
void
_gdk_init_input_core (void)
{
GdkDisplay *display = GDK_DISPLAY_OBJECT(_gdk_display);
_gdk_core_pointer = g_object_new (GDK_TYPE_DEVICE, NULL);
_gdk_core_pointer->name = "Core Pointer";
_gdk_core_pointer->source = GDK_SOURCE_MOUSE;
_gdk_core_pointer->mode = GDK_MODE_SCREEN;
_gdk_core_pointer->has_cursor = TRUE;
_gdk_core_pointer->num_axes = 2;
_gdk_core_pointer->axes = gdk_input_core_axes;
_gdk_core_pointer->num_keys = 0;
_gdk_core_pointer->keys = NULL;
display->core_pointer = _gdk_core_pointer;
}
static void
gdk_device_finalize (GObject *object)
{
g_error ("A GdkDevice object was finalized. This should not happen");
}
static void
gdk_device_class_init (GObjectClass *class)
{
class->finalize = gdk_device_finalize;
}
GType
gdk_device_get_type (void)
{
static GType object_type = 0;
if (!object_type)
{
const GTypeInfo object_info =
{
sizeof (GdkDeviceClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gdk_device_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GdkDevice),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
object_type = g_type_register_static (G_TYPE_OBJECT,
"GdkDevice",
&object_info, 0);
}
return object_type;
}
void
_gdk_input_init (void)
{
_gdk_init_input_core ();
_gdk_input_devices = g_list_append (NULL, _gdk_core_pointer);
_gdk_input_ignore_core = FALSE;
}
void
_gdk_input_exit (void)
{
GList *tmp_list;
GdkDevice *gdkdev;
for (tmp_list = _gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
{
gdkdev = (GdkDevice *)(tmp_list->data);
if (!GDK_IS_CORE (gdkdev))
{
gdk_device_set_mode ((GdkDevice *)gdkdev, GDK_MODE_DISABLED);
g_free (gdkdev->name);
g_free (gdkdev->axes);
g_free (gdkdev->keys);
g_free (gdkdev);
}
}
g_list_free (_gdk_input_devices);
}
/**
* gdk_device_get_axis:
* @device: a #GdkDevice
* @axes: pointer to an array of axes
* @use: the use to look for
* @value: location to store the found value.
*
* Interprets an array of double as axis values for a given device,
* and locates the value in the array for a given axis use.
*
* Return value: %TRUE if the given axis use was found, otherwise %FALSE
**/
gboolean
gdk_device_get_axis (GdkDevice *device,
gdouble *axes,
GdkAxisUse use,
gdouble *value)
{
gint i;
g_return_val_if_fail (device != NULL, FALSE);
if (axes == NULL)
return FALSE;
for (i = 0; i < device->num_axes; i++)
if (device->axes[i].use == use)
{
if (value)
*value = axes[i];
return TRUE;
}
return FALSE;
}
void
gdk_device_set_key (GdkDevice *device,
guint index,
guint keyval,
GdkModifierType modifiers)
{
g_return_if_fail (device != NULL);
g_return_if_fail (index < device->num_keys);
device->keys[index].keyval = keyval;
device->keys[index].modifiers = modifiers;
}
void
gdk_device_set_axis_use (GdkDevice *device,
guint index,
GdkAxisUse use)
{
g_return_if_fail (device != NULL);
g_return_if_fail (index < device->num_axes);
device->axes[index].use = use;
switch (use)
{
case GDK_AXIS_X:
case GDK_AXIS_Y:
device->axes[index].min = 0.0;
device->axes[index].max = 0.0;
break;
case GDK_AXIS_XTILT:
case GDK_AXIS_YTILT:
device->axes[index].min = -1.0;
device->axes[index].max = 1.0;
break;
default:
device->axes[index].min = 0.0;
device->axes[index].max = 1.0;
break;
}
}
gboolean
gdk_device_set_mode (GdkDevice *device,
GdkInputMode mode)
{
g_message ("unimplemented %s", G_STRFUNC);
return FALSE;
}
gboolean
gdk_device_get_history (GdkDevice *device,
GdkWindow *window,
guint32 start,
guint32 stop,
GdkTimeCoord ***events,
gint *n_events)
{
g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
g_return_val_if_fail (events != NULL, FALSE);
g_return_val_if_fail (n_events != NULL, FALSE);
*n_events = 0;
*events = NULL;
if (GDK_WINDOW_DESTROYED (window))
return FALSE;
if (GDK_IS_CORE (device))
return FALSE;
else
return FALSE;
//TODODO_gdk_device_get_history (device, window, start, stop, events, n_events);
}
void
gdk_device_free_history (GdkTimeCoord **events,
gint n_events)
{
gint i;
for (i = 0; i < n_events; i++)
g_free (events[i]);
g_free (events);
}
void
gdk_device_get_state (GdkDevice *device,
GdkWindow *window,
gdouble *axes,
GdkModifierType *mask)
{
g_return_if_fail (device != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
if (mask)
*mask = _gdk_directfb_modifiers;
}
void
gdk_directfb_mouse_get_info (gint *x,
gint *y,
GdkModifierType *mask)
{
if (x)
*x = _gdk_directfb_mouse_x;
if (y)
*y = _gdk_directfb_mouse_y;
if (mask)
*mask = _gdk_directfb_modifiers;
}
void
gdk_input_set_extension_events (GdkWindow *window,
gint mask,
GdkExtensionMode mode)
{
g_message ("unimplemented %s", G_STRFUNC);
}
GList *
gdk_devices_list (void)
{
return _gdk_input_devices;
}
GList *
gdk_display_list_devices (GdkDisplay *dpy)
{
return _gdk_input_devices;
}
void
gdk_device_set_source (GdkDevice *device,
GdkInputSource source)
{
g_return_if_fail (device != NULL);
device->source = source;
}

143
gdk/directfb/gdkinput-directfb.h
View File

@ -1,143 +0,0 @@
/* 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 Library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library 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 convergence GmbH
* Written by Denis Oliver Kropp <dok@convergence.de> and
* Sven Neumann <sven@convergence.de>
*/
#ifndef __GDK_INPUT_DIRECTFB_H__
#define __GDK_INPUT_DIRECTFB_H__
extern GdkModifierType _gdk_directfb_modifiers;
extern int _gdk_directfb_mouse_x, _gdk_directfb_mouse_y;
typedef struct _GdkAxisInfo GdkAxisInfo;
/* information about a device axis */
struct _GdkAxisInfo
{
/* reported x resolution */
gint xresolution;
/* reported x minimum/maximum values */
gint xmin_value, xmax_value;
/* calibrated resolution (for aspect ration) - only relative values
between axes used */
gint resolution;
/* calibrated minimum/maximum values */
gint min_value, max_value;
};
#define GDK_INPUT_NUM_EVENTC 6
struct _GdkDeviceClass
{
GObjectClass parent_class;
};
struct _GdkInputWindow
{
/* gdk window */
GdkWindow *window;
/* Extension mode (GDK_EXTENSION_EVENTS_ALL/CURSOR) */
GdkExtensionMode mode;
/* position relative to root window */
gint root_x;
gint root_y;
/* rectangles relative to window of windows obscuring this one */
GdkRectangle *obscuring;
gint num_obscuring;
/* Is there a pointer grab for this window ? */
gint grabbed;
};
/* Global data */
#define GDK_IS_CORE(d) (((GdkDevice *)(d)) == _gdk_core_pointer)
extern GList *_gdk_input_devices;
extern GList *_gdk_input_windows;
extern gint _gdk_input_ignore_core;
/* Function declarations */
/* The following functions are provided by each implementation
*/
gint _gdk_input_window_none_event(GdkEvent *event,
gchar *msg);
void _gdk_input_configure_event (GdkEventConfigure *event,
GdkWindow *window);
void _gdk_input_enter_event (GdkEventCrossing *event,
GdkWindow *window);
gint _gdk_input_other_event (GdkEvent *event,
gchar *msg,
GdkWindow *window);
/* These should be in gdkinternals.h */
GdkInputWindow * gdk_input_window_find (GdkWindow *window);
void gdk_input_window_destroy (GdkWindow *window);
gint _gdk_input_enable_window (GdkWindow *window,
GdkDevice *gdkdev);
gint _gdk_input_disable_window (GdkWindow *window,
GdkDevice *gdkdev);
gint _gdk_input_grab_pointer (GdkWindow *window,
gint owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
guint32 time);
void _gdk_input_ungrab_pointer (guint32 time);
gboolean _gdk_device_get_history (GdkDevice *device,
GdkWindow *window,
guint32 start,
guint32 stop,
GdkTimeCoord ***events,
gint *n_events);
gint gdk_input_common_init (gint include_core);
gint gdk_input_common_other_event (GdkEvent *event,
gchar *msg,
GdkInputWindow *input_window,
GdkWindow *window);
void _gdk_directfb_keyboard_init (void);
void _gdk_directfb_keyboard_exit (void);
void gdk_directfb_translate_key_event (DFBWindowEvent *dfb_event,
GdkEventKey *event);
#endif /* __GDK_INPUT_DIRECTFB_H__ */

2032
gdk/directfb/gdkkeys-directfb.c
View File

File diff suppressed because it is too large Load Diff

417
gdk/directfb/gdkmain-directfb.c
View File

@ -1,417 +0,0 @@
/* GDK - The GIMP Drawing Kit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
* Copyright (C) 1998-1999 Tor Lillqvist
*
* 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>
*/
/*
Main entry point for 2.6 seems to be open_display so
most stuff in main is moved over to gdkdisplay-directfb.c
I'll move stub functions here that make no sense for directfb
and true globals
Michael Emmel
*/
#include "config.h"
#include <string.h>
#include <stdlib.h>
#include "gdk.h"
#include "gdkdisplay.h"
#include "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
#include "gdkinternals.h"
#include "gdkinput-directfb.h"
#include "gdkintl.h"
void
_gdk_windowing_init (void)
{
/* Not that usable called before parse_args
*/
}
void
_gdk_windowing_display_set_sm_client_id (GdkDisplay *display,const gchar *sm_client_id)
{
g_message ("gdk_set_sm_client_id() is unimplemented.");
}
void
_gdk_windowing_exit (void)
{
if (_gdk_display->buffer)
_gdk_display->buffer->Release (_gdk_display->buffer);
_gdk_directfb_keyboard_exit ();
if (_gdk_display->keyboard)
_gdk_display->keyboard->Release (_gdk_display->keyboard);
_gdk_display->layer->Release (_gdk_display->layer);
_gdk_display->directfb->Release (_gdk_display->directfb);
g_free (_gdk_display);
_gdk_display = NULL;
}
gchar *
gdk_get_display (void)
{
return g_strdup (gdk_display_get_name (gdk_display_get_default ()));
}
/* utils */
static const guint type_masks[] =
{
GDK_STRUCTURE_MASK, /* GDK_DELETE = 0, */
GDK_STRUCTURE_MASK, /* GDK_DESTROY = 1, */
GDK_EXPOSURE_MASK, /* GDK_EXPOSE = 2, */
GDK_POINTER_MOTION_MASK, /* GDK_MOTION_NOTIFY = 3, */
GDK_BUTTON_PRESS_MASK, /* GDK_BUTTON_PRESS = 4, */
GDK_BUTTON_PRESS_MASK, /* GDK_2BUTTON_PRESS = 5, */
GDK_BUTTON_PRESS_MASK, /* GDK_3BUTTON_PRESS = 6, */
GDK_BUTTON_RELEASE_MASK, /* GDK_BUTTON_RELEASE = 7, */
GDK_KEY_PRESS_MASK, /* GDK_KEY_PRESS = 8, */
GDK_KEY_RELEASE_MASK, /* GDK_KEY_RELEASE = 9, */
GDK_ENTER_NOTIFY_MASK, /* GDK_ENTER_NOTIFY = 10, */
GDK_LEAVE_NOTIFY_MASK, /* GDK_LEAVE_NOTIFY = 11, */
GDK_FOCUS_CHANGE_MASK, /* GDK_FOCUS_CHANGE = 12, */
GDK_STRUCTURE_MASK, /* GDK_CONFIGURE = 13, */
GDK_VISIBILITY_NOTIFY_MASK,/* GDK_MAP = 14, */
GDK_VISIBILITY_NOTIFY_MASK,/* GDK_UNMAP = 15, */
GDK_PROPERTY_CHANGE_MASK, /* GDK_PROPERTY_NOTIFY = 16, */
GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_CLEAR = 17, */
GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_REQUEST = 18, */
GDK_PROPERTY_CHANGE_MASK, /* GDK_SELECTION_NOTIFY = 19, */
GDK_PROXIMITY_IN_MASK, /* GDK_PROXIMITY_IN = 20, */
GDK_PROXIMITY_OUT_MASK, /* GDK_PROXIMITY_OUT = 21, */
GDK_ALL_EVENTS_MASK, /* GDK_DRAG_ENTER = 22, */
GDK_ALL_EVENTS_MASK, /* GDK_DRAG_LEAVE = 23, */
GDK_ALL_EVENTS_MASK, /* GDK_DRAG_MOTION = 24, */
GDK_ALL_EVENTS_MASK, /* GDK_DRAG_STATUS = 25, */
GDK_ALL_EVENTS_MASK, /* GDK_DROP_START = 26, */
GDK_ALL_EVENTS_MASK, /* GDK_DROP_FINISHED = 27, */
GDK_ALL_EVENTS_MASK, /* GDK_CLIENT_EVENT = 28, */
GDK_VISIBILITY_NOTIFY_MASK,/* GDK_VISIBILITY_NOTIFY = 29, */
GDK_EXPOSURE_MASK, /* GDK_NO_EXPOSE = 30, */
GDK_SCROLL_MASK /* GDK_SCROLL = 31 */
};
GdkWindow *
gdk_directfb_other_event_window (GdkWindow *window,
GdkEventType type)
{
guint32 evmask;
GdkWindow *w;
w = window;
while (w != _gdk_parent_root)
{
/* Huge hack, so that we don't propagate events to GtkWindow->frame */
if ((w != window) &&
(GDK_WINDOW_OBJECT (w)->window_type != GDK_WINDOW_CHILD) &&
(g_object_get_data (G_OBJECT (w), "gdk-window-child-handler")))
break;
evmask = GDK_WINDOW_OBJECT (w)->event_mask;
if (evmask & type_masks[type])
return w;
w = gdk_window_get_parent (w);
}
return NULL;
}
GdkWindow *
gdk_directfb_pointer_event_window (GdkWindow *window,
GdkEventType type)
{
guint evmask;
GdkModifierType mask;
GdkWindow *w;
gdk_directfb_mouse_get_info (NULL, NULL, &mask);
if (_gdk_directfb_pointer_grab_window && !_gdk_directfb_pointer_grab_owner_events )
{
evmask = _gdk_directfb_pointer_grab_events;
if (evmask & (GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON2_MOTION_MASK |
GDK_BUTTON3_MOTION_MASK))
{
if (((mask & GDK_BUTTON1_MASK) &&
(evmask & GDK_BUTTON1_MOTION_MASK)) ||
((mask & GDK_BUTTON2_MASK) &&
(evmask & GDK_BUTTON2_MOTION_MASK)) ||
((mask & GDK_BUTTON3_MASK) &&
(evmask & GDK_BUTTON3_MOTION_MASK)))
evmask |= GDK_POINTER_MOTION_MASK;
}
if (evmask & type_masks[type]) {
if( _gdk_directfb_pointer_grab_owner_events ) {
return _gdk_directfb_pointer_grab_window;
}else {
GdkWindowObject *obj= GDK_WINDOW_OBJECT(window);
while (obj != NULL &&
obj != GDK_WINDOW_OBJECT(_gdk_directfb_pointer_grab_window)) {
obj = (GdkWindowObject *)obj->parent;
}
if( obj ==GDK_WINDOW_OBJECT(_gdk_directfb_pointer_grab_window) ) {
return window;
}else {
//was not child of the grab window so return the grab window
return _gdk_directfb_pointer_grab_window;
}
}
}
}
w = window;
while (w != _gdk_parent_root)
{
/* Huge hack, so that we don't propagate events to GtkWindow->frame */
if ((w != window) &&
(GDK_WINDOW_OBJECT (w)->window_type != GDK_WINDOW_CHILD) &&
(g_object_get_data (G_OBJECT (w), "gdk-window-child-handler")))
break;
evmask = GDK_WINDOW_OBJECT (w)->event_mask;
if (evmask & (GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON2_MOTION_MASK |
GDK_BUTTON3_MOTION_MASK))
{
if (((mask & GDK_BUTTON1_MASK) &&
(evmask & GDK_BUTTON1_MOTION_MASK)) ||
((mask & GDK_BUTTON2_MASK) &&
(evmask & GDK_BUTTON2_MOTION_MASK)) ||
((mask & GDK_BUTTON3_MASK) &&
(evmask & GDK_BUTTON3_MOTION_MASK)))
evmask |= GDK_POINTER_MOTION_MASK;
}
if (evmask & type_masks[type])
return w;
w = gdk_window_get_parent (w);
}
return NULL;
}
GdkWindow *
gdk_directfb_keyboard_event_window (GdkWindow *window,
GdkEventType type)
{
guint32 evmask;
GdkWindow *w;
if (_gdk_directfb_keyboard_grab_window &&
!_gdk_directfb_keyboard_grab_owner_events)
{
return _gdk_directfb_keyboard_grab_window;
}
w = window;
while (w != _gdk_parent_root)
{
/* Huge hack, so that we don't propagate events to GtkWindow->frame */
if ((w != window) &&
(GDK_WINDOW_OBJECT (w)->window_type != GDK_WINDOW_CHILD) &&
(g_object_get_data (G_OBJECT (w), "gdk-window-child-handler")))
break;
evmask = GDK_WINDOW_OBJECT (w)->event_mask;
if (evmask & type_masks[type])
return w;
w = gdk_window_get_parent (w);
}
return w;
}
GdkEvent *
gdk_directfb_event_make (GdkWindow *window,
GdkEventType type)
{
GdkEvent *event = gdk_event_new (GDK_NOTHING);
guint32 the_time = gdk_directfb_get_time ();
event->any.type = type;
event->any.window = g_object_ref (window);
event->any.send_event = FALSE;
switch (type)
{
case GDK_MOTION_NOTIFY:
event->motion.time = the_time;
event->motion.axes = NULL;
break;
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
event->button.time = the_time;
event->button.axes = NULL;
break;
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
event->key.time = the_time;
break;
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY:
event->crossing.time = the_time;
break;
case GDK_PROPERTY_NOTIFY:
event->property.time = the_time;
break;
case GDK_SELECTION_CLEAR:
case GDK_SELECTION_REQUEST:
case GDK_SELECTION_NOTIFY:
event->selection.time = the_time;
break;
case GDK_PROXIMITY_IN:
case GDK_PROXIMITY_OUT:
event->proximity.time = the_time;
break;
case GDK_DRAG_ENTER:
case GDK_DRAG_LEAVE:
case GDK_DRAG_MOTION:
case GDK_DRAG_STATUS:
case GDK_DROP_START:
case GDK_DROP_FINISHED:
event->dnd.time = the_time;
break;
case GDK_SCROLL:
event->scroll.time = the_time;
break;
case GDK_FOCUS_CHANGE:
case GDK_CONFIGURE:
case GDK_MAP:
case GDK_UNMAP:
case GDK_CLIENT_EVENT:
case GDK_VISIBILITY_NOTIFY:
case GDK_NO_EXPOSE:
case GDK_DELETE:
case GDK_DESTROY:
case GDK_EXPOSE:
default:
break;
}
_gdk_event_queue_append (gdk_display_get_default (), event);
return event;
}
void
gdk_error_trap_push (void)
{
}
gint
gdk_error_trap_pop (void)
{
return 0;
}
GdkGrabStatus
gdk_keyboard_grab (GdkWindow *window,
gint owner_events,
guint32 time)
{
return gdk_directfb_keyboard_grab (gdk_display_get_default(),
window,
owner_events,
time);
}
/*
*--------------------------------------------------------------
* gdk_pointer_grab
*
* Grabs the pointer to a specific window
*
* Arguments:
* "window" is the window which will receive the grab
* "owner_events" specifies whether events will be reported as is,
* or relative to "window"
* "event_mask" masks only interesting events
* "confine_to" limits the cursor movement to the specified window
* "cursor" changes the cursor for the duration of the grab
* "time" specifies the time
*
* Results:
*
* Side effects:
* requires a corresponding call to gdk_pointer_ungrab
*
*--------------------------------------------------------------
*/
GdkGrabStatus
_gdk_windowing_pointer_grab (GdkWindow *window,
GdkWindow *native,
gboolean owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
GdkCursor *cursor,
guint32 time)
{
g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
_gdk_display_add_pointer_grab (&_gdk_display->parent,
window,
native,
owner_events,
event_mask,
0,
time,
FALSE);
return GDK_GRAB_SUCCESS;
}

232
gdk/directfb/gdkpixmap-directfb.c
View File

@ -1,232 +0,0 @@
/* GDK - The GIMP Drawing Kit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
* Copyright (C) 1998-1999 Tor Lillqvist
*
* 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 <stdlib.h>
#include <string.h>
#include "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
#include "gdkinternals.h"
#include "gdkpixmap.h"
static void gdk_pixmap_impl_directfb_init (GdkPixmapImplDirectFB *pixmap);
static void gdk_pixmap_impl_directfb_class_init (GdkPixmapImplDirectFBClass *klass);
static void gdk_pixmap_impl_directfb_finalize (GObject *object);
static gpointer parent_class = NULL;
GType
gdk_pixmap_impl_directfb_get_type (void)
{
static GType object_type = 0;
if (!object_type)
{
const GTypeInfo object_info =
{
sizeof (GdkPixmapImplDirectFBClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gdk_pixmap_impl_directfb_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GdkPixmapImplDirectFB),
0, /* n_preallocs */
(GInstanceInitFunc) gdk_pixmap_impl_directfb_init,
};
object_type = g_type_register_static (GDK_TYPE_DRAWABLE_IMPL_DIRECTFB,
"GdkPixmapImplDirectFB",
&object_info, 0);
}
return object_type;
}
GType
_gdk_pixmap_impl_get_type (void)
{
return gdk_pixmap_impl_directfb_get_type ();
}
static void
gdk_pixmap_impl_directfb_init (GdkPixmapImplDirectFB *impl)
{
GdkDrawableImplDirectFB *draw_impl = GDK_DRAWABLE_IMPL_DIRECTFB (impl);
draw_impl->width = 1;
draw_impl->height = 1;
}
static void
gdk_pixmap_impl_directfb_class_init (GdkPixmapImplDirectFBClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gdk_pixmap_impl_directfb_finalize;
}
static void
gdk_pixmap_impl_directfb_finalize (GObject *object)
{
if (G_OBJECT_CLASS (parent_class)->finalize)
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GdkPixmap*
_gdk_pixmap_new (GdkDrawable *drawable,
gint width,
gint height,
gint depth)
{
DFBSurfacePixelFormat format;
IDirectFBSurface *surface;
GdkPixmap *pixmap;
GdkDrawableImplDirectFB *draw_impl;
g_return_val_if_fail (drawable == NULL || GDK_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (drawable != NULL || depth != -1, NULL);
g_return_val_if_fail (width > 0 && height > 0, NULL);
if (!drawable)
drawable = _gdk_parent_root;
if (GDK_IS_WINDOW (drawable) && GDK_WINDOW_DESTROYED (drawable))
return NULL;
GDK_NOTE (MISC, g_print ("gdk_pixmap_new: %dx%dx%d\n",
width, height, depth));
if (depth == -1)
{
draw_impl =
GDK_DRAWABLE_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (drawable)->impl);
g_return_val_if_fail (draw_impl != NULL, NULL);
draw_impl->surface->GetPixelFormat (draw_impl->surface, &format);
depth = DFB_BITS_PER_PIXEL (format);
}
else
{
switch (depth)
{
case 1:
format = DSPF_A8;
break;
case 8:
format = DSPF_LUT8;
break;
case 15:
format = DSPF_ARGB1555;
break;
case 16:
format = DSPF_RGB16;
break;
case 24:
format = DSPF_RGB24;
break;
case 32:
format = DSPF_RGB32;
break;
default:
g_message ("unimplemented %s for depth %d", G_STRFUNC, depth);
return NULL;
}
}
if( !(surface =
gdk_display_dfb_create_surface(_gdk_display,format,width,height) )) {
g_assert( surface != NULL);
return NULL;
}
pixmap = g_object_new (gdk_pixmap_get_type (), NULL);
draw_impl = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_PIXMAP_OBJECT (pixmap)->impl);
draw_impl->surface = surface;
surface->Clear (surface, 0x0, 0x0, 0x0, 0x0);
surface->GetSize (surface, &draw_impl->width, &draw_impl->height);
surface->GetPixelFormat (surface, &draw_impl->format);
draw_impl->abs_x = draw_impl->abs_y = 0;
GDK_PIXMAP_OBJECT (pixmap)->depth = depth;
return pixmap;
}
GdkPixmap*
gdk_pixmap_foreign_new (GdkNativeWindow anid)
{
g_warning(" gdk_pixmap_foreign_new unsuporrted \n");
return NULL;
}
GdkPixmap*
gdk_pixmap_foreign_new_for_display (GdkDisplay *display, GdkNativeWindow anid)
{
return gdk_pixmap_foreign_new(anid);
}
GdkPixmap*
gdk_pixmap_foreign_new_for_screen (GdkScreen *screen,
GdkNativeWindow anid,
gint width,
gint height,
gint depth)
{
/*Use the root drawable for now since only one screen */
return gdk_pixmap_new(NULL,width,height,depth);
}
GdkPixmap*
gdk_pixmap_lookup (GdkNativeWindow anid)
{
g_warning(" gdk_pixmap_lookup unsuporrted \n");
return NULL;
}
GdkPixmap* gdk_pixmap_lookup_for_display (GdkDisplay *display,GdkNativeWindow anid)
{
return gdk_pixmap_lookup (anid);
}

381
gdk/directfb/gdkprivate-directfb.h
View File

@ -1,381 +0,0 @@
/* 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>
*/
#ifndef __GDK_PRIVATE_DIRECTFB_H__
#define __GDK_PRIVATE_DIRECTFB_H__
//#include <gdk/gdk.h>
#include <gdk/gdkprivate.h>
#include "gdkinternals.h"
#include "gdkcursor.h"
#include "gdkdisplay-directfb.h"
#include <cairo.h>
#include <string.h>
#include <directfb_util.h>
#define GDK_TYPE_DRAWABLE_IMPL_DIRECTFB (gdk_drawable_impl_directfb_get_type ())
#define GDK_DRAWABLE_IMPL_DIRECTFB(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAWABLE_IMPL_DIRECTFB, GdkDrawableImplDirectFB))
#define GDK_IS_DRAWABLE_IMPL_DIRECTFB(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAWABLE_IMPL_DIRECTFB))
#define GDK_TYPE_WINDOW_IMPL_DIRECTFB (gdk_window_impl_directfb_get_type ())
#define GDK_WINDOW_IMPL_DIRECTFB(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW_IMPL_DIRECTFB, GdkWindowImplDirectFB))
#define GDK_IS_WINDOW_IMPL_DIRECTFB(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW_IMPL_DIRECTFB))
#define GDK_TYPE_PIXMAP_IMPL_DIRECTFB (gdk_pixmap_impl_directfb_get_type ())
#define GDK_PIXMAP_IMPL_DIRECTFB(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXMAP_IMPL_DIRECTFB, GdkPixmapImplDirectFB))
#define GDK_IS_PIXMAP_IMPL_DIRECTFB(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXMAP_IMPL_DIRECTFB))
typedef struct _GdkDrawableImplDirectFB GdkDrawableImplDirectFB;
typedef struct _GdkWindowImplDirectFB GdkWindowImplDirectFB;
typedef struct _GdkPixmapImplDirectFB GdkPixmapImplDirectFB;
struct _GdkDrawableImplDirectFB
{
GdkDrawable parent_object;
GdkDrawable *wrapper;
gboolean buffered;
cairo_region_t paint_region;
gint paint_depth;
gint width;
gint height;
gint abs_x;
gint abs_y;
cairo_region_t clip_region;
GdkColormap *colormap;
IDirectFBSurface *surface;
DFBSurfacePixelFormat format;
cairo_surface_t * cairo_surface;
};
typedef struct
{
GdkDrawableClass parent_class;
} GdkDrawableImplDirectFBClass;
GType gdk_drawable_impl_directfb_get_type (void);
GdkEvent * gdk_directfb_event_make (GdkWindow *window,
GdkEventType type);
/*
* Pixmap
*/
struct _GdkPixmapImplDirectFB
{
GdkDrawableImplDirectFB parent_instance;
};
typedef struct
{
GdkDrawableImplDirectFBClass parent_class;
} GdkPixmapImplDirectFBClass;
GType gdk_pixmap_impl_directfb_get_type (void);
/*
* Window
*/
typedef struct
{
gulong length;
GdkAtom type;
gint format;
guchar data[1];
} GdkWindowProperty;
struct _GdkWindowImplDirectFB
{
GdkDrawableImplDirectFB drawable;
GdkWindow *gdkWindow;
IDirectFBWindow *window;
DFBWindowID dfb_id;
GdkCursor *cursor;
GHashTable *properties;
guint8 opacity;
GdkWindowTypeHint type_hint;
DFBUpdates flips;
DFBRegion flip_regions[4];
};
typedef struct
{
GdkDrawableImplDirectFBClass parent_class;
} GdkWindowImplDirectFBClass;
GType gdk_window_impl_directfb_get_type (void);
void gdk_directfb_window_send_crossing_events (GdkWindow *src,
GdkWindow *dest,
GdkCrossingMode mode);
void _gdk_directfb_calc_abs (GdkWindow *window);
GdkWindow * gdk_directfb_window_find_toplevel (GdkWindow *window);
void gdk_directfb_window_id_table_insert (DFBWindowID dfb_id,
GdkWindow *window);
void gdk_directfb_window_id_table_remove (DFBWindowID dfb_id);
GdkWindow * gdk_directfb_window_id_table_lookup (DFBWindowID dfb_id);
void _gdk_directfb_window_get_offsets (GdkWindow *window,
gint *x_offset,
gint *y_offset);
void _gdk_directfb_window_scroll (GdkWindow *window,
gint dx,
gint dy);
void _gdk_directfb_window_move_region (GdkWindow *window,
const cairo_region_t *region,
gint dx,
gint dy);
typedef struct
{
GdkCursor cursor;
gint hot_x;
gint hot_y;
IDirectFBSurface *shape;
} GdkCursorDirectFB;
typedef struct
{
GdkVisual visual;
DFBSurfacePixelFormat format;
} GdkVisualDirectFB;
void gdk_directfb_event_windows_add (GdkWindow *window);
void gdk_directfb_event_windows_remove (GdkWindow *window);
GdkGrabStatus gdk_directfb_keyboard_grab (GdkDisplay *display,
GdkWindow *window,
gint owner_events,
guint32 time);
void gdk_directfb_keyboard_ungrab(GdkDisplay *display,
guint32 time);
GdkGrabStatus gdk_directfb_pointer_grab (GdkWindow *window,
gint owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
GdkCursor *cursor,
guint32 time,
gboolean implicit_grab);
void gdk_directfb_pointer_ungrab (guint32 time,
gboolean implicit_grab);
guint32 gdk_directfb_get_time (void);
GdkWindow * gdk_directfb_pointer_event_window (GdkWindow *window,
GdkEventType type);
GdkWindow * gdk_directfb_keyboard_event_window (GdkWindow *window,
GdkEventType type);
GdkWindow * gdk_directfb_other_event_window (GdkWindow *window,
GdkEventType type);
void _gdk_selection_window_destroyed (GdkWindow *window);
void _gdk_directfb_move_resize_child (GdkWindow *window,
gint x,
gint y,
gint width,
gint height);
GdkWindow * gdk_directfb_child_at (GdkWindow *window,
gint *x,
gint *y);
GdkWindow * gdk_directfb_window_find_focus (void);
void gdk_directfb_change_focus (GdkWindow *new_focus_window);
void gdk_directfb_mouse_get_info (gint *x,
gint *y,
GdkModifierType *mask);
/**********************/
/* Global variables */
/**********************/
extern GdkDisplayDFB *_gdk_display;
/* Pointer grab info */
extern GdkWindow * _gdk_directfb_pointer_grab_window;
extern gboolean _gdk_directfb_pointer_grab_owner_events;
extern GdkWindow * _gdk_directfb_pointer_grab_confine;
extern GdkEventMask _gdk_directfb_pointer_grab_events;
extern GdkCursor * _gdk_directfb_pointer_grab_cursor;
/* Keyboard grab info */
extern GdkWindow * _gdk_directfb_keyboard_grab_window;
extern GdkEventMask _gdk_directfb_keyboard_grab_events;
extern gboolean _gdk_directfb_keyboard_grab_owner_events;
extern GdkScreen * _gdk_screen;
extern GdkAtom _gdk_selection_property;
IDirectFBPalette * gdk_directfb_colormap_get_palette (GdkColormap *colormap);
/* these are Linux-FB specific functions used for window decorations */
typedef gboolean (* GdkWindowChildChanged) (GdkWindow *window,
gint x,
gint y,
gint width,
gint height,
gpointer user_data);
typedef void (* GdkWindowChildGetPos) (GdkWindow *window,
gint *x,
gint *y,
gpointer user_data);
void gdk_fb_window_set_child_handler (GdkWindow *window,
GdkWindowChildChanged changed,
GdkWindowChildGetPos get_pos,
gpointer user_data);
void gdk_directfb_clip_region (GdkDrawable *drawable,
GdkGC *gc,
GdkRectangle *draw_rect,
cairo_region_t *ret_clip);
/* Utilities for avoiding mallocs */
static inline void
temp_region_init_copy( cairo_region_t *region,
const cairo_region_t *source)
{
if (region != source) /* don't want to copy to itself */
{
if (region->size < source->numRects)
{
if (region->rects && region->rects != &region->extents)
g_free( region->rects );
region->rects = g_new (cairo_region_tBox, source->numRects);
region->size = source->numRects;
}
region->numRects = source->numRects;
region->extents = source->extents;
memcpy( region->rects, source->rects, source->numRects * sizeof (cairo_region_tBox) );
}
}
static inline void
temp_region_init_rectangle( cairo_region_t *region,
const GdkRectangle *rect )
{
region->numRects = 1;
region->rects = &region->extents;
region->extents.x1 = rect->x;
region->extents.y1 = rect->y;
region->extents.x2 = rect->x + rect->width;
region->extents.y2 = rect->y + rect->height;
region->size = 1;
}
static inline void
temp_region_init_rectangle_vals( cairo_region_t *region,
int x,
int y,
int w,
int h )
{
region->numRects = 1;
region->rects = &region->extents;
region->extents.x1 = x;
region->extents.y1 = y;
region->extents.x2 = x + w;
region->extents.y2 = y + h;
region->size = 1;
}
static inline void
temp_region_reset( cairo_region_t *region )
{
if (region->size > 32 && region->rects && region->rects != &region->extents) {
g_free( region->rects );
region->size = 1;
region->rects = &region->extents;
}
region->numRects = 0;
}
static inline void
temp_region_deinit( cairo_region_t *region )
{
if (region->rects && region->rects != &region->extents) {
g_free( region->rects );
region->rects = NULL;
}
region->numRects = 0;
}
#define GDKDFB_RECTANGLE_VALS_FROM_BOX(s) (s)->x1, (s)->y1, (s)->x2-(s)->x1, (s)->y2-(s)->y1
#endif /* __GDK_PRIVATE_DIRECTFB_H__ */

397
gdk/directfb/gdkproperty-directfb.c
View File

@ -1,397 +0,0 @@
/* 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 <string.h>
#include "gdkproperty.h"
#include "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
#include "gdkinternals.h"
static GHashTable *names_to_atoms;
static GPtrArray *atoms_to_names;
static const gchar xatoms_string[] =
/* These are all the standard predefined X atoms */
"NONE\0"
"PRIMARY\0"
"SECONDARY\0"
"ARC\0"
"ATOM\0"
"BITMAP\0"
"CARDINAL\0"
"COLORMAP\0"
"CURSOR\0"
"CUT_BUFFER0\0"
"CUT_BUFFER1\0"
"CUT_BUFFER2\0"
"CUT_BUFFER3\0"
"CUT_BUFFER4\0"
"CUT_BUFFER5\0"
"CUT_BUFFER6\0"
"CUT_BUFFER7\0"
"DRAWABLE\0"
"FONT\0"
"INTEGER\0"
"PIXMAP\0"
"POINT\0"
"RECTANGLE\0"
"RESOURCE_MANAGER\0"
"RGB_COLOR_MAP\0"
"RGB_BEST_MAP\0"
"RGB_BLUE_MAP\0"
"RGB_DEFAULT_MAP\0"
"RGB_GRAY_MAP\0"
"RGB_GREEN_MAP\0"
"RGB_RED_MAP\0"
"STRING\0"
"VISUALID\0"
"WINDOW\0"
"WM_COMMAND\0"
"WM_HINTS\0"
"WM_CLIENT_MACHINE\0"
"WM_ICON_NAME\0"
"WM_ICON_SIZE\0"
"WM_NAME\0"
"WM_NORMAL_HINTS\0"
"WM_SIZE_HINTS\0"
"WM_ZOOM_HINTS\0"
"MIN_SPACE\0"
"NORM_SPACE\0"
"MAX_SPACE\0"
"END_SPACE\0"
"SUPERSCRIPT_X\0"
"SUPERSCRIPT_Y\0"
"SUBSCRIPT_X\0"
"SUBSCRIPT_Y\0"
"UNDERLINE_POSITION\0"
"UNDERLINE_THICKNESS\0"
"STRIKEOUT_ASCENT\0"
"STRIKEOUT_DESCENT\0"
"ITALIC_ANGLE\0"
"X_HEIGHT\0"
"QUAD_WIDTH\0"
"WEIGHT\0"
"POINT_SIZE\0"
"RESOLUTION\0"
"COPYRIGHT\0"
"NOTICE\0"
"FONT_NAME\0"
"FAMILY_NAME\0"
"FULL_NAME\0"
"CAP_HEIGHT\0"
"WM_CLASS\0"
"WM_TRANSIENT_FOR\0"
;
static const gint xatoms_offset[] = {
0, 5, 13, 23, 27, 32, 39, 48, 57, 64, 76, 88,
100, 112, 124, 136, 148, 160, 169, 174, 182, 189, 195, 205,
222, 236, 249, 262, 278, 291, 305, 317, 324, 333, 340, 351,
360, 378, 391, 404, 412, 428, 442, 456, 466, 477, 487, 497,
511, 525, 537, 549, 568, 588, 605, 623, 636, 645, 656, 663,
674, 685, 695, 702, 712, 724, 734, 745, 754
};
#define N_CUSTOM_PREDEFINED 1
static void
ensure_atom_tables (void)
{
int i;
if (names_to_atoms)
return;
names_to_atoms = g_hash_table_new (g_str_hash, g_str_equal);
atoms_to_names = g_ptr_array_sized_new (G_N_ELEMENTS (xatoms_offset));
for (i = 0; i < G_N_ELEMENTS (xatoms_offset); i++)
{
g_hash_table_insert(names_to_atoms, (gchar *)xatoms_string + xatoms_offset[i], GINT_TO_POINTER (i));
g_ptr_array_add(atoms_to_names, (gchar *)xatoms_string + xatoms_offset[i]);
}
}
static GdkAtom
intern_atom_internal (const gchar *atom_name, gboolean allocate)
{
gpointer result;
gchar *name;
g_return_val_if_fail (atom_name != NULL, GDK_NONE);
ensure_atom_tables ();
if (g_hash_table_lookup_extended (names_to_atoms, atom_name, NULL, &result))
return result;
result = GINT_TO_POINTER (atoms_to_names->len);
name = allocate ? g_strdup (atom_name) : (gchar *)atom_name;
g_hash_table_insert(names_to_atoms, name, result);
g_ptr_array_add(atoms_to_names, name);
return result;
}
GdkAtom
gdk_atom_intern (const gchar *atom_name,
gboolean only_if_exists)
{
return intern_atom_internal (atom_name, TRUE);
}
GdkAtom
gdk_atom_intern_static_string (const gchar *atom_name)
{
return intern_atom_internal (atom_name, FALSE);
}
gchar *
gdk_atom_name (GdkAtom atom)
{
if (!atoms_to_names)
return NULL;
if (GPOINTER_TO_INT (atom) >= atoms_to_names->len)
return NULL;
return g_strdup(g_ptr_array_index (atoms_to_names, GPOINTER_TO_INT (atom)));
}
static void
gdk_property_delete_2 (GdkWindow *window,
GdkAtom property,
GdkWindowProperty *prop)
{
GdkWindowImplDirectFB *impl;
GdkEvent *event;
GdkWindow *event_window;
impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
g_hash_table_remove (impl->properties, GUINT_TO_POINTER (property));
g_free (prop);
event_window = gdk_directfb_other_event_window (window, GDK_PROPERTY_NOTIFY);
if (event_window)
{
event = gdk_directfb_event_make (event_window, GDK_PROPERTY_NOTIFY);
event->property.atom = property;
event->property.state = GDK_PROPERTY_DELETE;
}
}
void
gdk_property_delete (GdkWindow *window,
GdkAtom property)
{
GdkWindowImplDirectFB *impl;
GdkWindowProperty *prop;
g_return_if_fail (GDK_IS_WINDOW (window));
impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
if (!impl->properties)
return;
prop = g_hash_table_lookup (impl->properties, GUINT_TO_POINTER (property));
if (!prop)
return;
gdk_property_delete_2 (window, property, prop);
}
gboolean
gdk_property_get (GdkWindow *window,
GdkAtom property,
GdkAtom type,
gulong offset,
gulong length,
gint pdelete,
GdkAtom *actual_property_type,
gint *actual_format_type,
gint *actual_length,
guchar **data)
{
GdkWindowImplDirectFB *impl;
GdkWindowProperty *prop;
gint nbytes = 0;
g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), FALSE);
g_return_val_if_fail (data != NULL, FALSE);
if (!window)
window = _gdk_parent_root;
if (GDK_WINDOW_DESTROYED (window))
return FALSE;
impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
if (!impl->properties)
return FALSE;
prop = g_hash_table_lookup (impl->properties, GUINT_TO_POINTER (property));
if (!prop)
{
if (actual_property_type)
*actual_property_type = GDK_NONE;
return FALSE;
}
nbytes = CLAMP (length, 0, prop->length - offset * 4);
if (nbytes > 0 &&
(prop->type == 0 /* AnyPropertyType */ || prop->type == type))
{
*data = g_malloc (nbytes + 1);
memcpy (*data, prop->data + offset, nbytes);
(*data)[nbytes] = 0;
}
else
{
*data = NULL;
}
if (actual_length)
*actual_length = nbytes;
if (actual_property_type)
*actual_property_type = prop->type;
if (actual_format_type)
*actual_format_type = prop->format;
/* only delete the property if it was completely retrieved */
if (pdelete && length >= *actual_length && *data != NULL)
{
gdk_property_delete_2 (window, property, prop);
}
return TRUE;
}
void
gdk_property_change (GdkWindow *window,
GdkAtom property,
GdkAtom type,
gint format,
GdkPropMode mode,
const guchar *data,
gint nelements)
{
GdkWindowImplDirectFB *impl;
GdkWindowProperty *prop;
GdkWindowProperty *new_prop;
gint new_size = 0;
GdkEvent *event;
GdkWindow *event_window;
g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
if (!window)
window = _gdk_parent_root;
if (GDK_WINDOW_DESTROYED (window))
return;
impl = GDK_WINDOW_IMPL_DIRECTFB (GDK_WINDOW_OBJECT (window)->impl);
if (!impl->properties)
impl->properties = g_hash_table_new (NULL, NULL);
prop = g_hash_table_lookup (impl->properties, GUINT_TO_POINTER (property));
switch (mode)
{
case GDK_PROP_MODE_REPLACE:
new_size = nelements * (format >> 3);
break;
case GDK_PROP_MODE_PREPEND:
case GDK_PROP_MODE_APPEND:
new_size = nelements * (format >> 3);
if (prop)
{
if (type != prop->type || format != prop->format)
return;
new_size += prop->length;
}
break;
}
new_prop = g_malloc (G_STRUCT_OFFSET (GdkWindowProperty, data) + new_size);
new_prop->length = new_size;
new_prop->type = type;
new_prop->format = format;
switch (mode)
{
case GDK_PROP_MODE_REPLACE:
memcpy (new_prop->data, data, new_size);
break;
case GDK_PROP_MODE_APPEND:
if (prop)
memcpy (new_prop->data, prop->data, prop->length);
memcpy (new_prop->data + new_prop->length,
data, (nelements * (format >> 3)));
break;
case GDK_PROP_MODE_PREPEND:
memcpy (new_prop->data, data, (nelements * (format >> 3)));
if (prop)
memcpy (new_prop->data + (nelements * (format >> 3)),
prop->data, prop->length);
break;
}
g_hash_table_insert (impl->properties,
GUINT_TO_POINTER (property), new_prop);
g_free (prop);
event_window = gdk_directfb_other_event_window (window, GDK_PROPERTY_NOTIFY);
if (event_window)
{
event = gdk_directfb_event_make (event_window, GDK_PROPERTY_NOTIFY);
event->property.atom = property;
event->property.state = GDK_PROPERTY_NEW_VALUE;
}
}

248
gdk/directfb/gdkscreen-directfb.c
View File

@ -1,248 +0,0 @@
/* GDK - The GIMP Drawing Kit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
* Copyright (C) 1998-1999 Tor Lillqvist
*
* 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 "gdkscreen.h"
#include "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
#include "gdkinternals.h"
static GdkColormap *default_colormap = NULL;
GdkDisplay *
gdk_screen_get_display (GdkScreen *screen)
{
return GDK_DISPLAY_OBJECT(_gdk_display);
}
GdkWindow *
gdk_screen_get_root_window (GdkScreen *screen)
{
return _gdk_parent_root;
}
GdkColormap*
gdk_screen_get_default_colormap (GdkScreen *screen)
{
return default_colormap;
}
void
gdk_screen_set_default_colormap (GdkScreen *screen,
GdkColormap *colormap)
{
GdkColormap *old_colormap;
g_return_if_fail (GDK_IS_SCREEN (screen));
g_return_if_fail (GDK_IS_COLORMAP (colormap));
old_colormap = default_colormap;
default_colormap = g_object_ref (colormap);
if (old_colormap)
g_object_unref (old_colormap);
}
gint
gdk_screen_get_n_monitors (GdkScreen *screen)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
return 1;
}
gint
gdk_screen_get_primary_monitor (GdkScreen *screen)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
return 0;
}
void
gdk_screen_get_monitor_geometry (GdkScreen *screen,
gint num_monitor,
GdkRectangle *dest)
{
g_return_if_fail (GDK_IS_SCREEN (screen));
g_return_if_fail (dest != NULL);
dest->x = 0;
dest->y = 0;
dest->width = gdk_screen_width ();
dest->height = gdk_screen_height ();
}
gint
gdk_screen_get_monitor_width_mm (GdkScreen *screen,
gint monitor_num)
{
return gdk_screen_get_width_mm (screen);
}
gint
gdk_screen_get_monitor_height_mm (GdkScreen *screen,
gint monitor_num)
{
return gdk_screen_get_height_mm (screen);
}
gchar *
gdk_screen_get_monitor_plug_name (GdkScreen *screen,
gint monitor_num)
{
return g_strdup ("DirectFB");
}
gint
gdk_screen_get_number (GdkScreen *screen)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
return 0;
}
gchar *
_gdk_windowing_substitute_screen_number (const gchar *display_name,
int screen_number)
{
return g_strdup (display_name);
}
gchar *
gdk_screen_make_display_name (GdkScreen *screen)
{
return g_strdup ("DirectFB");
}
gint
gdk_screen_get_width (GdkScreen *screen)
{
DFBDisplayLayerConfig dlc;
_gdk_display->layer->GetConfiguration (_gdk_display->layer, &dlc);
return dlc.width;
}
gint
gdk_screen_get_height (GdkScreen *screen)
{
DFBDisplayLayerConfig dlc;
_gdk_display->layer->GetConfiguration (_gdk_display->layer, &dlc);
return dlc.height;
}
gint
gdk_screen_get_width_mm (GdkScreen *screen)
{
static gboolean first_call = TRUE;
DFBDisplayLayerConfig dlc;
if (first_call)
{
g_message
("gdk_screen_width_mm() assumes a screen resolution of 72 dpi");
first_call = FALSE;
}
_gdk_display->layer->GetConfiguration (_gdk_display->layer, &dlc);
return (dlc.width * 254) / 720;
}
gint
gdk_screen_get_height_mm (GdkScreen *screen)
{
static gboolean first_call = TRUE;
DFBDisplayLayerConfig dlc;
if (first_call)
{
g_message
("gdk_screen_height_mm() assumes a screen resolution of 72 dpi");
first_call = FALSE;
}
_gdk_display->layer->GetConfiguration (_gdk_display->layer, &dlc);
return (dlc.height * 254) / 720;
}
GdkVisual *
gdk_screen_get_rgba_visual (GdkScreen *screen)
{
static GdkVisual *rgba_visual;
if( !rgba_visual )
rgba_visual = gdk_directfb_visual_by_format(DSPF_ARGB);
return rgba_visual;
}
GdkColormap *
gdk_screen_get_rgba_colormap (GdkScreen *screen)
{
static GdkColormap *rgba_colormap;
if( !rgba_colormap && gdk_screen_get_rgba_visual(screen) )
rgba_colormap = gdk_colormap_new (gdk_screen_get_rgba_visual(screen),FALSE);
return rgba_colormap;
}
GdkWindow *
gdk_screen_get_active_window (GdkScreen *screen)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
return NULL;
}
GList *
gdk_screen_get_window_stack (GdkScreen *screen)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
return NULL;
}
gboolean
gdk_screen_is_composited (GdkScreen *screen)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
return FALSE;
}

494
gdk/directfb/gdkselection-directfb.c
View File

@ -1,494 +0,0 @@
/* 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 <string.h>
#include "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
#include "gdkproperty.h"
#include "gdkselection.h"
#include "gdkprivate.h"
typedef struct _OwnerInfo OwnerInfo;
struct _OwnerInfo
{
GdkAtom selection;
GdkWindow *owner;
};
GSList *owner_list = NULL;
/* When a window is destroyed we check if it is the owner
* of any selections. This is somewhat inefficient, but
* owner_list is typically short, and it is a low memory,
* low code solution
*/
void
_gdk_selection_window_destroyed (GdkWindow *window)
{
GSList *tmp_list = owner_list;
while (tmp_list)
{
OwnerInfo *info = tmp_list->data;
tmp_list = tmp_list->next;
if (info->owner == window)
{
owner_list = g_slist_remove (owner_list, info);
g_free (info);
}
}
}
gint
gdk_selection_owner_set_for_display (GdkDisplay *display,
GdkWindow *owner,
GdkAtom selection,
guint32 time,
gint send_event)
{
GSList *tmp_list;
OwnerInfo *info;
tmp_list = owner_list;
while (tmp_list)
{
info = tmp_list->data;
if (info->selection == selection)
{
owner_list = g_slist_remove (owner_list, info);
g_free (info);
break;
}
tmp_list = tmp_list->next;
}
if (owner)
{
info = g_new (OwnerInfo, 1);
info->owner = owner;
info->selection = selection;
owner_list = g_slist_prepend (owner_list, info);
}
return TRUE;
}
GdkWindow *
gdk_selection_owner_get_for_display (GdkDisplay *display,
GdkAtom selection)
{
OwnerInfo *info;
GSList *tmp_list;
tmp_list = owner_list;
while (tmp_list)
{
info = tmp_list->data;
if (info->selection == selection)
{
return info->owner;
}
tmp_list = tmp_list->next;
}
return NULL;
}
void
gdk_selection_convert (GdkWindow *requestor,
GdkAtom selection,
GdkAtom target,
guint32 time)
{
GdkEvent *event;
GdkWindow *owner;
GdkWindow *event_window;
owner = gdk_selection_owner_get (selection);
if (owner)
{
event_window = gdk_directfb_other_event_window (owner,
GDK_SELECTION_REQUEST);
if (event_window)
{
event = gdk_directfb_event_make (event_window,
GDK_SELECTION_REQUEST);
event->selection.requestor = GDK_WINDOW_DFB_ID (requestor);
event->selection.selection = selection;
event->selection.target = target;
event->selection.property = _gdk_selection_property;
}
}
else
{
/* If no owner for the specified selection exists, the X server
* generates a SelectionNotify event to the requestor with property None.
*/
gdk_selection_send_notify (GDK_WINDOW_DFB_ID (requestor),
selection,
target,
GDK_NONE,
0);
}
}
gint
gdk_selection_property_get (GdkWindow *requestor,
guchar **data,
GdkAtom *ret_type,
gint *ret_format)
{
guchar *t = NULL;
GdkAtom prop_type;
gint prop_format;
gint prop_len;
g_return_val_if_fail (requestor != NULL, 0);
g_return_val_if_fail (GDK_IS_WINDOW (requestor), 0);
if (!gdk_property_get (requestor,
_gdk_selection_property,
0/*AnyPropertyType?*/,
0, 0,
FALSE,
&prop_type, &prop_format, &prop_len,
&t))
{
*data = NULL;
return 0;
}
if (ret_type)
*ret_type = prop_type;
if (ret_format)
*ret_format = prop_format;
if (!gdk_property_get (requestor,
_gdk_selection_property,
0/*AnyPropertyType?*/,
0, prop_len + 1,
FALSE,
&prop_type, &prop_format, &prop_len,
&t))
{
*data = NULL;
return 0;
}
*data = t;
return prop_len;
}
void
gdk_selection_send_notify_for_display (GdkDisplay *display,
guint32 requestor,
GdkAtom selection,
GdkAtom target,
GdkAtom property,
guint32 time)
{
GdkEvent *event;
GdkWindow *event_window;
event_window = gdk_window_lookup ((GdkNativeWindow) requestor);
if (!event_window)
return;
event_window = gdk_directfb_other_event_window (event_window,
GDK_SELECTION_NOTIFY);
if (event_window)
{
event = gdk_directfb_event_make (event_window, GDK_SELECTION_NOTIFY);
event->selection.selection = selection;
event->selection.target = target;
event->selection.property = property;
event->selection.requestor = (GdkNativeWindow) requestor;
}
}
gint
gdk_text_property_to_text_list_for_display (GdkDisplay *display,
GdkAtom encoding,
gint format,
const guchar *text,
gint length,
gchar ***list)
{
g_warning ("gdk_text_property_to_text_list() not implemented\n");
return 0;
}
void
gdk_free_text_list (gchar **list)
{
g_return_if_fail (list != NULL);
g_warning ("gdk_free_text_list() not implemented\n");
}
gint
gdk_string_to_compound_text_for_display (GdkDisplay *display,
const gchar *str,
GdkAtom *encoding,
gint *format,
guchar **ctext,
gint *length)
{
g_warning ("gdk_string_to_compound_text() not implemented\n");
return 0;
}
void
gdk_free_compound_text (guchar *ctext)
{
g_warning ("gdk_free_compound_text() not implemented\n");
}
/**
* gdk_utf8_to_string_target:
* @str: a UTF-8 string
*
* Convert an UTF-8 string into the best possible representation
* as a STRING. The representation of characters not in STRING
* is not specified; it may be as pseudo-escape sequences
* \x{ABCD}, or it may be in some other form of approximation.
*
* Return value: the newly allocated string, or %NULL if the
* conversion failed. (It should not fail for
* any properly formed UTF-8 string.)
**/
gchar *
gdk_utf8_to_string_target (const gchar *str)
{
g_warning ("gdk_utf8_to_string_target() not implemented\n");
return 0;
}
/**
* gdk_utf8_to_compound_text:
* @str: a UTF-8 string
* @encoding: location to store resulting encoding
* @format: location to store format of the result
* @ctext: location to store the data of the result
* @length: location to store the length of the data
* stored in @ctext
*
* Convert from UTF-8 to compound text.
*
* Return value: %TRUE if the conversion succeeded, otherwise
* false.
**/
gboolean
gdk_utf8_to_compound_text_for_display (GdkDisplay *display,
const gchar *str,
GdkAtom *encoding,
gint *format,
guchar **ctext,
gint *length)
{
g_warning ("gdk_utf8_to_compound_text() not implemented\n");
return 0;
}
static gint
make_list (const gchar *text,
gint length,
gboolean latin1,
gchar ***list)
{
GSList *strings = NULL;
gint n_strings = 0;
gint i;
const gchar *p = text;
const gchar *q;
GSList *tmp_list;
GError *error = NULL;
while (p < text + length)
{
gchar *str;
q = p;
while (*q && q < text + length)
q++;
if (latin1)
{
str = g_convert (p, q - p,
"UTF-8", "ISO-8859-1",
NULL, NULL, &error);
if (!str)
{
g_warning ("Error converting selection from STRING: %s",
error->message);
g_error_free (error);
}
}
else
str = g_strndup (p, q - p);
if (str)
{
strings = g_slist_prepend (strings, str);
n_strings++;
}
p = q + 1;
}
if (list)
*list = g_new (gchar *, n_strings + 1);
(*list)[n_strings] = NULL;
i = n_strings;
tmp_list = strings;
while (tmp_list)
{
if (list)
(*list)[--i] = tmp_list->data;
else
g_free (tmp_list->data);
tmp_list = tmp_list->next;
}
g_slist_free (strings);
return n_strings;
}
/**
* gdk_text_property_to_utf8_list:
* @encoding: an atom representing the encoding of the text
* @format: the format of the property
* @text: the text to convert
* @length: the length of @text, in bytes
* @list: location to store the list of strings or %NULL. The
* list should be freed with g_strfreev().
*
* Convert a text property in the giving encoding to
* a list of UTF-8 strings.
*
* Return value: the number of strings in the resulting
* list.
**/
gint
gdk_text_property_to_utf8_list_for_display (GdkDisplay *display,
GdkAtom encoding,
gint format,
const guchar *text,
gint length,
gchar ***list)
{
g_return_val_if_fail (text != NULL, 0);
g_return_val_if_fail (length >= 0, 0);
if (encoding == GDK_TARGET_STRING)
{
return make_list ((gchar *)text, length, TRUE, list);
}
else if (encoding == gdk_atom_intern ("UTF8_STRING", FALSE))
{
return make_list ((gchar *)text, length, FALSE, list);
}
else
{
gchar **local_list;
gint local_count;
gint i;
const gchar *charset = NULL;
gboolean need_conversion = !g_get_charset (&charset);
gint count = 0;
GError *error = NULL;
/* Probably COMPOUND text, we fall back to Xlib routines
*/
local_count = gdk_text_property_to_text_list (encoding,
format,
text,
length,
&local_list);
if (list)
*list = g_new (gchar *, local_count + 1);
for (i = 0; i < local_count; i++)
{
/* list contains stuff in our default encoding
*/
if (need_conversion)
{
gchar *utf = g_convert (local_list[i], -1,
"UTF-8", charset,
NULL, NULL, &error);
if (utf)
{
if (list)
(*list)[count++] = utf;
else
g_free (utf);
}
else
{
g_warning ("Error converting to UTF-8 from '%s': %s",
charset, error->message);
g_error_free (error);
error = NULL;
}
}
else
{
if (list)
(*list)[count++] = g_strdup (local_list[i]);
}
}
gdk_free_text_list (local_list);
(*list)[count] = NULL;
return count;
}
}

104
gdk/directfb/gdkspawn-directfb.c
View File

@ -1,104 +0,0 @@
/*
* Copyright (C) 2003 Sun Microsystems Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library 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.
*
* Authors: Mark McLoughlin <mark@skynet.ie>
*/
#include "config.h"
#include <glib.h>
#include "gdk.h"
#include "gdkspawn.h"
#include "gdkprivate.h"
gboolean
gdk_spawn_on_screen (GdkScreen *screen,
const gchar *working_directory,
gchar **argv,
gchar **envp,
GSpawnFlags flags,
GSpawnChildSetupFunc child_setup,
gpointer user_data,
GPid *child_pid,
GError **error)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
return g_spawn_async (working_directory,
argv,
envp,
flags,
child_setup,
user_data,
child_pid,
error);
}
gboolean
gdk_spawn_on_screen_with_pipes (GdkScreen *screen,
const gchar *working_directory,
gchar **argv,
gchar **envp,
GSpawnFlags flags,
GSpawnChildSetupFunc child_setup,
gpointer user_data,
GPid *child_pid,
gint *standard_input,
gint *standard_output,
gint *standard_error,
GError **error)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
return g_spawn_async_with_pipes (working_directory,
argv,
envp,
flags,
child_setup,
user_data,
child_pid,
standard_input,
standard_output,
standard_error,
error);
}
gboolean
gdk_spawn_command_line_on_screen (GdkScreen *screen,
const gchar *command_line,
GError **error)
{
gchar **argv = NULL;
gboolean retval;
g_return_val_if_fail (command_line != NULL, FALSE);
if (!g_shell_parse_argv (command_line,
NULL, &argv,
error))
return FALSE;
retval = gdk_spawn_on_screen (screen,
NULL, argv, NULL,
G_SPAWN_SEARCH_PATH,
NULL, NULL, NULL,
error);
g_strfreev (argv);
return retval;
}

263
gdk/directfb/gdktestutils-directfb.c
View File

@ -1,263 +0,0 @@
/* Gtk+ testing utilities
* Copyright (C) 2007 Imendio AB
* Authors: Tim Janik
*
* 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.
*/
/*
* 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 <unistd.h>
#include "gdk.h"
#include "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
#include <gdk/gdktestutils.h>
#include <gdk/gdkkeysyms.h>
static DFBInputDeviceKeySymbol
_gdk_keyval_to_directfb (guint keyval)
{
switch (keyval) {
case 0 ... 127:
return DFB_KEY( UNICODE, keyval );
case GDK_F1 ... GDK_F12:
return keyval - GDK_F1 + DIKS_F1;
case GDK_BackSpace:
return DIKS_BACKSPACE;
case GDK_Tab:
return DIKS_TAB;
case GDK_Return:
return DIKS_RETURN;
case GDK_Escape:
return DIKS_ESCAPE;
case GDK_Delete:
return DIKS_DELETE;
case GDK_Left:
return DIKS_CURSOR_LEFT;
case GDK_Up:
return DIKS_CURSOR_UP;
case GDK_Right:
return DIKS_CURSOR_RIGHT;
case GDK_Down:
return DIKS_CURSOR_DOWN;
case GDK_Insert:
return DIKS_INSERT;
case GDK_Home:
return DIKS_HOME;
case GDK_End:
return DIKS_END;
case GDK_Page_Up:
return DIKS_PAGE_UP;
case GDK_Page_Down:
return DIKS_PAGE_DOWN;
case GDK_Print:
return DIKS_PRINT;
case GDK_Pause:
return DIKS_PAUSE;
case GDK_Clear:
return DIKS_CLEAR;
case GDK_Cancel:
return DIKS_CANCEL;
/* TODO: handle them all */
default:
break;
}
return DIKS_NULL;
}
static DFBInputDeviceModifierMask
_gdk_modifiers_to_directfb (GdkModifierType modifiers)
{
DFBInputDeviceModifierMask dfb_modifiers = 0;
if (modifiers & GDK_MOD1_MASK)
dfb_modifiers |= DIMM_ALT;
if (modifiers & GDK_MOD2_MASK)
dfb_modifiers |= DIMM_ALTGR;
if (modifiers & GDK_CONTROL_MASK)
dfb_modifiers |= DIMM_CONTROL;
if (modifiers & GDK_SHIFT_MASK)
dfb_modifiers |= DIMM_SHIFT;
return dfb_modifiers;
}
/**
* gdk_test_render_sync
* @window: a mapped GdkWindow
*
* This function retrives a pixel from @window to force the windowing
* system to carry out any pending rendering commands.
* This function is intended to be used to syncronize with rendering
* pipelines, to benchmark windowing system rendering operations.
**/
void
gdk_test_render_sync (GdkWindow *window)
{
_gdk_display->directfb->WaitIdle (_gdk_display->directfb);
}
/**
* gdk_test_simulate_key
* @window: Gdk window to simulate a key event for.
* @x: x coordinate within @window for the key event.
* @y: y coordinate within @window for the key event.
* @keyval: A Gdk keyboard value.
* @modifiers: Keyboard modifiers the event is setup with.
* @key_pressrelease: either %GDK_KEY_PRESS or %GDK_KEY_RELEASE
*
* This function is intended to be used in Gtk+ test programs.
* If (@x,@y) are > (-1,-1), it will warp the mouse pointer to
* the given (@x,@y) corrdinates within @window and simulate a
* key press or release event.
* When the mouse pointer is warped to the target location, use
* of this function outside of test programs that run in their
* own virtual windowing system (e.g. Xvfb) is not recommended.
* If (@x,@y) are passed as (-1,-1), the mouse pointer will not
* be warped and @window origin will be used as mouse pointer
* location for the event.
* Also, gtk_test_simulate_key() is a fairly low level function,
* for most testing purposes, gtk_test_widget_send_key() is the
* right function to call which will generate a key press event
* followed by its accompanying key release event.
*
* Returns: wether all actions neccessary for a key event simulation were carried out successfully.
**/
gboolean
gdk_test_simulate_key (GdkWindow *window,
gint x,
gint y,
guint keyval,
GdkModifierType modifiers,
GdkEventType key_pressrelease)
{
GdkWindowObject *private;
GdkWindowImplDirectFB *impl;
DFBWindowEvent evt;
g_return_val_if_fail (GDK_IS_WINDOW(window), FALSE);
g_return_val_if_fail (key_pressrelease == GDK_KEY_PRESS ||
key_pressrelease == GDK_KEY_RELEASE, FALSE);
private = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
if (x >= 0 && y >= 0) {
int win_x, win_y;
impl->window->GetPosition (impl->window, &win_x, &win_y);
if (_gdk_display->layer->WarpCursor (_gdk_display->layer, win_x+x, win_y+y))
return FALSE;
}
evt.clazz = DFEC_WINDOW;
evt.type = (key_pressrelease == GDK_KEY_PRESS) ? DWET_KEYDOWN : DWET_KEYUP;
#if ((DIRECTFB_MAJOR_VERSION > 1) || (DIRECTFB_MINOR_VERSION >= 2))
evt.flags = DWEF_NONE;
#endif
evt.window_id = impl->dfb_id;
evt.x = MAX(x, 0);
evt.y = MAX(y, 0);
_gdk_display->layer->GetCursorPosition (_gdk_display->layer, &evt.cx, &evt.cy);
evt.key_code = -1;
evt.key_symbol = _gdk_keyval_to_directfb (keyval);
evt.modifiers = _gdk_modifiers_to_directfb (modifiers);
evt.locks = (modifiers & GDK_LOCK_MASK) ? DILS_CAPS : 0;
gettimeofday (&evt.timestamp, NULL);
_gdk_display->buffer->PostEvent (_gdk_display->buffer, DFB_EVENT(&evt));
return TRUE;
}
/**
* gdk_test_simulate_button
* @window: Gdk window to simulate a button event for.
* @x: x coordinate within @window for the button event.
* @y: y coordinate within @window for the button event.
* @button: Number of the pointer button for the event, usually 1, 2 or 3.
* @modifiers: Keyboard modifiers the event is setup with.
* @button_pressrelease: either %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE
*
* This function is intended to be used in Gtk+ test programs.
* It will warp the mouse pointer to the given (@x,@y) corrdinates
* within @window and simulate a button press or release event.
* Because the mouse pointer needs to be warped to the target
* location, use of this function outside of test programs that
* run in their own virtual windowing system (e.g. Xvfb) is not
* recommended.
* Also, gtk_test_simulate_button() is a fairly low level function,
* for most testing purposes, gtk_test_widget_click() is the right
* function to call which will generate a button press event followed
* by its accompanying button release event.
*
* Returns: wether all actions neccessary for a button event simulation were carried out successfully.
**/
gboolean
gdk_test_simulate_button (GdkWindow *window,
gint x,
gint y,
guint button, /*1..3*/
GdkModifierType modifiers,
GdkEventType button_pressrelease)
{
GdkWindowObject *private;
GdkWindowImplDirectFB *impl;
DFBWindowEvent evt;
g_return_val_if_fail (GDK_IS_WINDOW(window), FALSE);
g_return_val_if_fail (button_pressrelease == GDK_BUTTON_PRESS ||
button_pressrelease == GDK_BUTTON_RELEASE, FALSE);
private = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_DIRECTFB (private->impl);
if (x >= 0 && y >= 0) {
int win_x, win_y;
impl->window->GetPosition (impl->window, &win_x, &win_y);
if (_gdk_display->layer->WarpCursor (_gdk_display->layer, win_x+x, win_y+y))
return FALSE;
}
evt.clazz = DFEC_WINDOW;
evt.type = (button_pressrelease == GDK_BUTTON_PRESS) ? DWET_BUTTONDOWN : DWET_BUTTONUP;
#if ((DIRECTFB_MAJOR_VERSION > 1) || (DIRECTFB_MINOR_VERSION >= 2))
evt.flags = DWEF_NONE;
#endif
evt.window_id = impl->dfb_id;
evt.x = MAX(x, 0);
evt.y = MAX(y, 0);
_gdk_display->layer->GetCursorPosition (_gdk_display->layer, &evt.cx, &evt.cy);
evt.modifiers = _gdk_modifiers_to_directfb (modifiers);
evt.locks = (modifiers & GDK_LOCK_MASK) ? DILS_CAPS : 0;
evt.button = button;
evt.buttons = 0;
gettimeofday (&evt.timestamp, NULL);
_gdk_display->buffer->PostEvent (_gdk_display->buffer, DFB_EVENT(&evt));
return TRUE;
}

493
gdk/directfb/gdkvisual-directfb.c
View File

@ -1,493 +0,0 @@
/* 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 "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
#include "gdkscreen.h"
#include "gdkvisual.h"
struct _GdkVisualClass
{
GObjectClass parent_class;
};
static void gdk_visual_decompose_mask (gulong mask,
gint *shift,
gint *prec);
static GdkVisualDirectFB * gdk_directfb_visual_create (DFBSurfacePixelFormat pixelformat);
static DFBSurfacePixelFormat formats[] =
{
DSPF_ARGB,
DSPF_LUT8,
DSPF_RGB32,
DSPF_RGB24,
DSPF_RGB16,
DSPF_ARGB1555,
DSPF_RGB332
};
GdkVisual * system_visual = NULL;
static GdkVisualDirectFB * visuals[G_N_ELEMENTS (formats) + 1] = { NULL };
static gint available_depths[G_N_ELEMENTS (formats) + 1] = {0};
static GdkVisualType available_types[G_N_ELEMENTS (formats) + 1] = {0};
static void
gdk_visual_finalize (GObject *object)
{
g_error ("A GdkVisual object was finalized. This should not happen");
}
static void
gdk_visual_class_init (GObjectClass *class)
{
class->finalize = gdk_visual_finalize;
}
GType
gdk_visual_get_type (void)
{
static GType object_type = 0;
if (!object_type)
{
const GTypeInfo object_info =
{
sizeof (GdkVisualClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gdk_visual_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GdkVisualDirectFB),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
object_type = g_type_register_static (G_TYPE_OBJECT,
"GdkVisual",
&object_info, 0);
}
return object_type;
}
void
_gdk_visual_init ()
{
DFBDisplayLayerConfig dlc;
DFBSurfaceDescription desc;
IDirectFBSurface *dest;
gint i, c;
_gdk_display->layer->GetConfiguration (_gdk_display->layer, &dlc);
g_assert( dlc.pixelformat != DSPF_UNKNOWN);
dest = gdk_display_dfb_create_surface(_gdk_display,dlc.pixelformat,8,8);
g_assert (dest != NULL);
/* We could provide all visuals since DirectFB allows us to mix
surface formats. Blitting with format conversion can however
be incredibly slow, so we've choosen to register only those
visuals that can be blitted to the display layer in hardware.
If you want to use a special pixelformat that is not registered
here, you can create it using the DirectFB-specific function
gdk_directfb_visual_by_format().
Note:
changed to do all formats but we should redo this code
to ensure the base format ARGB LUT8 RGB etc then add ones supported
by the hardware
*/
for (i = 0; i < G_N_ELEMENTS (formats); i++)
{
IDirectFBSurface *src;
DFBAccelerationMask acc;
desc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT;
desc.width = 8;
desc.height = 8;
desc.pixelformat = formats[i];
//call direct so fail silently is ok
if (_gdk_display->directfb->CreateSurface (_gdk_display->directfb,
&desc, &src) != DFB_OK)
continue;
visuals[i] = gdk_directfb_visual_create (formats[i]);
dest->GetAccelerationMask (dest, src, &acc);
if (acc & DFXL_BLIT || formats[i] == dlc.pixelformat)
{
system_visual = GDK_VISUAL (visuals[i]);
}
src->Release (src);
}
dest->Release (dest);
//fallback to ARGB must be supported
if (!system_visual)
{
g_assert (visuals[DSPF_ARGB] != NULL);
system_visual = GDK_VISUAL(visuals[DSPF_ARGB]);
}
g_assert (system_visual != NULL);
}
gint
gdk_visual_get_best_depth (void)
{
return system_visual->depth;
}
GdkVisualType
gdk_visual_get_best_type (void)
{
return system_visual->type;
}
GdkVisual*
gdk_screen_get_system_visual (GdkScreen *screen)
{
g_assert( system_visual);
return system_visual;
}
GdkVisual*
gdk_visual_get_best (void)
{
return system_visual;
}
GdkVisual*
gdk_visual_get_best_with_depth (gint depth)
{
gint i;
for (i = 0; visuals[i]; i++)
{
if( visuals[i] ) {
GdkVisual *visual = GDK_VISUAL (visuals[i]);
if (depth == visual->depth)
return visual;
}
}
return NULL;
}
GdkVisual*
gdk_visual_get_best_with_type (GdkVisualType visual_type)
{
gint i;
for (i = 0; visuals[i]; i++)
{
if( visuals[i] ) {
GdkVisual *visual = GDK_VISUAL (visuals[i]);
if (visual_type == visual->type)
return visual;
}
}
return NULL;
}
GdkVisual*
gdk_visual_get_best_with_both (gint depth,
GdkVisualType visual_type)
{
gint i;
for (i = 0; visuals[i]; i++)
{
if( visuals[i] ) {
GdkVisual *visual = GDK_VISUAL (visuals[i]);
if (depth == visual->depth && visual_type == visual->type)
return visual;
}
}
return system_visual;
}
void
gdk_query_depths (gint **depths,
gint *count)
{
gint i;
for (i = 0; available_depths[i]; i++)
;
*count = i;
*depths = available_depths;
}
void
gdk_query_visual_types (GdkVisualType **visual_types,
gint *count)
{
gint i;
for (i = 0; available_types[i]; i++)
;
*count = i;
*visual_types = available_types;
}
GList *
gdk_screen_list_visuals (GdkScreen *screen)
{
GList *list = NULL;
gint i;
for (i = 0; visuals[i]; i++)
if( visuals[i] ) {
GdkVisual * vis = GDK_VISUAL(visuals[i]);
list = g_list_append (list,vis);
}
return list;
}
/**
* gdk_directfb_visual_by_format:
* @pixel_format: the pixel_format of the requested visual
*
* This function is specific to the DirectFB backend. It allows
* to specify a GdkVisual by @pixel_format.
*
* At startup, only those visuals that can be blitted
* hardware-accelerated are registered. By using
* gdk_directfb_visual_by_format() you can retrieve visuals that
* don't match this criteria since this function will try to create
* a new visual for the desired @pixel_format for you.
*
* Return value: a pointer to the GdkVisual or %NULL if the
* pixel_format is unsupported.
**/
GdkVisual *
gdk_directfb_visual_by_format (DFBSurfacePixelFormat pixel_format)
{
gint i;
/* first check if one the registered visuals matches */
for (i = 0; visuals[i]; i++)
if ( visuals[i] && visuals[i]->format == pixel_format)
return GDK_VISUAL (visuals[i]);
/* none matched, try to create a new one for this pixel_format */
{
DFBSurfaceDescription desc;
IDirectFBSurface *test;
desc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT;
desc.width = 8;
desc.height = 8;
desc.pixelformat = pixel_format;
if ( _gdk_display->directfb->CreateSurface ( _gdk_display->directfb, &desc, &test) != DFB_OK)
return NULL;
test->Release (test);
}
return GDK_VISUAL(gdk_directfb_visual_create (pixel_format));
}
GdkScreen *
gdk_visual_get_screen (GdkVisual *visual)
{
g_return_val_if_fail (GDK_IS_VISUAL (visual), NULL);
return gdk_screen_get_default ();
}
static void
gdk_visual_decompose_mask (gulong mask,
gint *shift,
gint *prec)
{
*shift = 0;
*prec = 0;
while (!(mask & 0x1))
{
(*shift)++;
mask >>= 1;
}
while (mask & 0x1)
{
(*prec)++;
mask >>= 1;
}
}
static GdkVisualDirectFB *
gdk_directfb_visual_create (DFBSurfacePixelFormat pixelformat)
{
GdkVisual *visual;
gint i;
for (i = 0; i < G_N_ELEMENTS (formats); i++)
if (formats[i] == pixelformat)
break;
if (i == G_N_ELEMENTS (formats))
{
g_warning ("unsupported pixelformat");
return NULL;
}
visual = g_object_new (GDK_TYPE_VISUAL, NULL);
switch (pixelformat)
{
case DSPF_LUT8:
visual->type = GDK_VISUAL_PSEUDO_COLOR;
visual->bits_per_rgb = 8;
break;
case DSPF_RGB332:
visual->type = GDK_VISUAL_STATIC_COLOR;
visual->bits_per_rgb = 3;
break;
case DSPF_ARGB1555:
visual->type = GDK_VISUAL_TRUE_COLOR;
visual->red_mask = 0x00007C00;
visual->green_mask = 0x000003E0;
visual->blue_mask = 0x0000001F;
visual->bits_per_rgb = 5;
break;
case DSPF_RGB16:
visual->type = GDK_VISUAL_TRUE_COLOR;
visual->red_mask = 0x0000F800;
visual->green_mask = 0x000007E0;
visual->blue_mask = 0x0000001F;
visual->bits_per_rgb = 6;
break;
case DSPF_RGB24:
case DSPF_RGB32:
case DSPF_ARGB:
visual->type = GDK_VISUAL_TRUE_COLOR;
visual->red_mask = 0x00FF0000;
visual->green_mask = 0x0000FF00;
visual->blue_mask = 0x000000FF;
visual->bits_per_rgb = 8;
break;
default:
g_assert_not_reached ();
}
#if G_BYTE_ORDER == G_BIG_ENDIAN
visual->byte_order = GDK_MSB_FIRST;
#else
visual->byte_order = GDK_LSB_FIRST;
#endif
visual->depth = DFB_BITS_PER_PIXEL (pixelformat);
switch (visual->type)
{
case GDK_VISUAL_TRUE_COLOR:
gdk_visual_decompose_mask (visual->red_mask,
&visual->red_shift, &visual->red_prec);
gdk_visual_decompose_mask (visual->green_mask,
&visual->green_shift, &visual->green_prec);
gdk_visual_decompose_mask (visual->blue_mask,
&visual->blue_shift, &visual->blue_prec);
/* the number of possible levels per color component */
visual->colormap_size = 1 << MAX (visual->red_prec,
MAX (visual->green_prec,
visual->blue_prec));
break;
case GDK_VISUAL_STATIC_COLOR:
case GDK_VISUAL_PSEUDO_COLOR:
visual->colormap_size = 1 << visual->depth;
visual->red_mask = 0;
visual->red_shift = 0;
visual->red_prec = 0;
visual->green_mask = 0;
visual->green_shift = 0;
visual->green_prec = 0;
visual->blue_mask = 0;
visual->blue_shift = 0;
visual->blue_prec = 0;
break;
default:
g_assert_not_reached ();
}
((GdkVisualDirectFB *)visual)->format = pixelformat;
for (i = 0; available_depths[i]; i++)
if (available_depths[i] == visual->depth)
break;
if (!available_depths[i])
available_depths[i] = visual->depth;
for (i = 0; available_types[i]; i++)
if (available_types[i] == visual->type)
break;
if (!available_types[i])
available_types[i] = visual->type;
return (GdkVisualDirectFB *) visual;
}

2891
gdk/directfb/gdkwindow-directfb.c
View File

File diff suppressed because it is too large Load Diff

69
gdk/directfb/gdkwindowid.c
View File

@ -1,69 +0,0 @@
/* 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 "gdkdirectfb.h"
#include "gdkprivate-directfb.h"
static GHashTable *window_id_ht = NULL;
void
gdk_directfb_window_id_table_insert (DFBWindowID dfb_id,
GdkWindow *window)
{
if (!window_id_ht)
window_id_ht = g_hash_table_new (g_direct_hash, g_direct_equal);
g_hash_table_insert (window_id_ht, GUINT_TO_POINTER (dfb_id), window);
}
void
gdk_directfb_window_id_table_remove (DFBWindowID dfb_id)
{
if (window_id_ht)
g_hash_table_remove (window_id_ht, GUINT_TO_POINTER (dfb_id));
}
GdkWindow *
gdk_directfb_window_id_table_lookup (DFBWindowID dfb_id)
{
GdkWindow *window = NULL;
if (window_id_ht)
window = (GdkWindow *) g_hash_table_lookup (window_id_ht,
GUINT_TO_POINTER (dfb_id));
return window;
}

924
gdk/directfb/x-cursors.xbm
View File

@ -1,924 +0,0 @@
#define X_cursor_width 14
#define X_cursor_height 14
#define X_cursor_x_hot 6
#define X_cursor_y_hot 6
static unsigned char X_cursor_bits[] = {
0x07, 0xb8, 0x0f, 0x3c, 0x1f, 0x3e, 0x3e, 0x1f, 0xfc, 0x0f, 0xf8, 0x07, 0xf0, 0x03, 0xf0, 0x03, 0xf8, 0x07, 0xfc, 0x0f, 0x3e, 0x1f, 0x1f, 0x3e, 0x0f, 0x3c, 0x07, 0x38};
#define X_cursor_mask_width 16
#define X_cursor_mask_height 16
#define X_cursor_mask_x_hot 7
#define X_cursor_mask_y_hot 7
static unsigned char X_cursor_mask_bits[] = {
0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe, 0xfe, 0x7f, 0xfc, 0x3f, 0xf8, 0x1f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0x7f, 0xfe, 0x3f, 0xfc, 0x1f, 0xf8, 0x0f, 0xf0};
#define arrow_width 14
#define arrow_height 14
#define arrow_x_hot 13
#define arrow_y_hot 0
static unsigned char arrow_bits[] = {
00, 0xb0, 00, 0x3c, 00, 0x1f, 0xc0, 0x1f, 0xf0, 0x0f, 0xfc, 0x0f, 0xc0, 0x07, 0xe0, 0x07, 0x70, 0x03, 0x38, 0x03, 0x1c, 0x01, 0x0e, 0x01, 0x07, 00, 0x02, 00};
#define arrow_mask_width 16
#define arrow_mask_height 16
#define arrow_mask_x_hot 14
#define arrow_mask_y_hot 1
static unsigned char arrow_mask_bits[] = {
00, 0xe0, 00, 0xf8, 00, 0xfe, 0x80, 0x7f, 0xe0, 0x7f, 0xf8, 0x3f, 0xfc, 0x3f, 0xfc, 0x1f, 0xe0, 0x1f, 0xf0, 0x0f, 0xf8, 0x0f, 0x7c, 0x07, 0x3e, 0x07, 0x1f, 0x02, 0x0e, 00, 0x04, 00};
#define based_arrow_down_width 8
#define based_arrow_down_height 10
#define based_arrow_down_x_hot 3
#define based_arrow_down_y_hot 9
static unsigned char based_arrow_down_bits[] = {
0xff, 00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x5a, 0x3c, 0x18};
#define based_arrow_down_mask_width 10
#define based_arrow_down_mask_height 12
#define based_arrow_down_mask_x_hot 4
#define based_arrow_down_mask_y_hot 10
static unsigned char based_arrow_down_mask_bits[] = {
0xff, 0x23, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0x78, 00, 0x78, 00, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfc, 00, 0x78, 00};
#define based_arrow_up_width 8
#define based_arrow_up_height 10
#define based_arrow_up_x_hot 3
#define based_arrow_up_y_hot 9
static unsigned char based_arrow_up_bits[] = {
0x18, 0x3c, 0x5a, 0x18, 0x18, 0x18, 0x18, 0xff, 00, 0xff};
#define based_arrow_up_mask_width 10
#define based_arrow_up_mask_height 12
#define based_arrow_up_mask_x_hot 4
#define based_arrow_up_mask_y_hot 10
static unsigned char based_arrow_up_mask_bits[] = {
0x30, 0x20, 0x78, 00, 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0x78, 00, 0x78, 00, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03};
#define boat_width 16
#define boat_height 8
#define boat_x_hot 14
#define boat_y_hot 3
static unsigned char boat_bits[] = {
0x80, 00, 0xe0, 0x03, 0x11, 0x06, 0xff, 0xff, 00, 0x18, 00, 0x04, 00, 0x02, 0xff, 0x03};
#define boat_mask_width 16
#define boat_mask_height 9
#define boat_mask_x_hot 14
#define boat_mask_y_hot 4
static unsigned char boat_mask_bits[] = {
0xe0, 00, 0xf0, 0x03, 0xf9, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, 0x07, 0xff, 0x03};
#define bogosity_width 13
#define bogosity_height 14
#define bogosity_x_hot 6
#define bogosity_y_hot 6
static unsigned char bogosity_bits[] = {
0x47, 0x9c, 0x44, 0x04, 0x44, 0x04, 0x44, 0x04, 0xff, 0x1f, 0x45, 0x14, 0x45, 0x14, 0x45, 0x14, 0x45, 0x14, 0xff, 0x1f, 0x44, 0x04, 0x44, 0x04, 0x44, 0x04, 0x47, 0x1c};
#define bogosity_mask_width 15
#define bogosity_mask_height 16
#define bogosity_mask_x_hot 7
#define bogosity_mask_y_hot 7
static unsigned char bogosity_mask_bits[] = {
0xdf, 0x7d, 0xdf, 0x7d, 0xdf, 0x7d, 0xdc, 0x1d, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xdf, 0x7d, 0xdf, 0x7d, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xdc, 0x1d, 0xdf, 0x7d, 0xdf, 0x7d, 0xdf, 0x7d};
#define bottom_left_corner_width 14
#define bottom_left_corner_height 14
#define bottom_left_corner_x_hot 0
#define bottom_left_corner_y_hot 13
static unsigned char bottom_left_corner_bits[] = {
0x03, 0x80, 0x03, 00, 0x23, 0x08, 0x23, 0x04, 0x23, 0x02, 0x23, 0x01, 0xa3, 00, 0x63, 00, 0xe3, 0x0f, 0x03, 00, 0x03, 00, 0x03, 00, 0xff, 0x3f, 0xff, 0x3f};
#define bottom_left_corner_mask_width 16
#define bottom_left_corner_mask_height 16
#define bottom_left_corner_mask_x_hot 1
#define bottom_left_corner_mask_y_hot 14
static unsigned char bottom_left_corner_mask_bits[] = {
0x0f, 00, 0x0f, 00, 0xef, 0x30, 0xef, 0x38, 0xef, 0x1c, 0xef, 0x0e, 0xef, 0x07, 0xef, 0x03, 0xef, 0x3f, 0xef, 0x3f, 0xef, 0x3f, 0x0f, 00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
#define bottom_right_corner_width 14
#define bottom_right_corner_height 14
#define bottom_right_corner_x_hot 13
#define bottom_right_corner_y_hot 13
static unsigned char bottom_right_corner_bits[] = {
00, 0xb0, 00, 0x30, 0x04, 0x31, 0x08, 0x31, 0x10, 0x31, 0x20, 0x31, 0x40, 0x31, 0x80, 0x31, 0xfc, 0x31, 00, 0x30, 00, 0x30, 00, 0x30, 0xff, 0x3f, 0xff, 0x3f};
#define bottom_right_corner_mask_width 16
#define bottom_right_corner_mask_height 16
#define bottom_right_corner_mask_x_hot 14
#define bottom_right_corner_mask_y_hot 14
static unsigned char bottom_right_corner_mask_bits[] = {
00, 0xf0, 00, 0xf0, 0x0c, 0xf7, 0x1c, 0xf7, 0x38, 0xf7, 0x70, 0xf7, 0xe0, 0xf7, 0xc0, 0xf7, 0xfc, 0xf7, 0xfc, 0xf7, 0xfc, 0xf7, 00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
#define bottom_side_width 13
#define bottom_side_height 14
#define bottom_side_x_hot 6
#define bottom_side_y_hot 13
static unsigned char bottom_side_bits[] = {
0x40, 0x80, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00, 0x44, 0x04, 0x48, 0x02, 0x50, 0x01, 0xe0, 00, 0x40, 00, 00, 00, 0xff, 0x1f, 0xff, 0x1f};
#define bottom_side_mask_width 15
#define bottom_side_mask_height 16
#define bottom_side_mask_x_hot 7
#define bottom_side_mask_y_hot 14
static unsigned char bottom_side_mask_bits[] = {
0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xcc, 0x19, 0xdc, 0x1d, 0xf8, 0x0f, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f};
#define bottom_tee_width 14
#define bottom_tee_height 10
#define bottom_tee_x_hot 7
#define bottom_tee_y_hot 9
static unsigned char bottom_tee_bits[] = {
0xc0, 0x80, 0xc0, 00, 0xc0, 00, 0xc0, 00, 0xc0, 00, 0xc0, 00, 0xc0, 00, 0xc0, 00, 0xff, 0x3f, 0xff, 0x3f};
#define bottom_tee_mask_width 16
#define bottom_tee_mask_height 12
#define bottom_tee_mask_x_hot 8
#define bottom_tee_mask_y_hot 10
static unsigned char bottom_tee_mask_bits[] = {
0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
#define box_spiral_width 15
#define box_spiral_height 16
#define box_spiral_x_hot 8
#define box_spiral_y_hot 8
static unsigned char box_spiral_bits[] = {
0xff, 0xff, 0x01, 00, 0xfd, 0x7f, 0x05, 0x40, 0xf5, 0x5f, 0x15, 0x50, 0xd5, 0x57, 0x55, 0x54, 0x55, 0x55, 0xd5, 0x55, 0x15, 0x54, 0xf5, 0x57, 0x05, 0x50, 0xfd, 0x5f, 0x01, 0x40, 0xff, 0x7f};
#define box_spiral_mask_width 16
#define box_spiral_mask_height 16
#define box_spiral_mask_x_hot 8
#define box_spiral_mask_y_hot 8
static unsigned char box_spiral_mask_bits[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
#define center_ptr_width 10
#define center_ptr_height 14
#define center_ptr_x_hot 4
#define center_ptr_y_hot 0
static unsigned char center_ptr_bits[] = {
0x30, 0x90, 0x30, 00, 0x78, 00, 0x78, 00, 0xfc, 00, 0xfc, 00, 0xfe, 0x01, 0xfe, 0x01, 0x33, 0x03, 0x31, 0x02, 0x30, 00, 0x30, 00, 0x30, 00, 0x30, 00};
#define center_ptr_mask_width 12
#define center_ptr_mask_height 16
#define center_ptr_mask_x_hot 5
#define center_ptr_mask_y_hot 1
static unsigned char center_ptr_mask_bits[] = {
0xf0, 0x20, 0xf0, 00, 0xf8, 0x01, 0xf8, 0x01, 0xfc, 0x03, 0xfc, 0x03, 0xfe, 0x07, 0xfe, 0x07, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xf7, 0x0e, 0xf0, 00, 0xf0, 00, 0xf0, 00, 0xf0, 00};
#define circle_width 14
#define circle_height 14
#define circle_x_hot 7
#define circle_y_hot 7
static unsigned char circle_bits[] = {
0xe0, 0x81, 0xf8, 0x07, 0xfc, 0x0f, 0x1e, 0x1e, 0x0e, 0x1c, 0x07, 0x38, 0x07, 0x38, 0x07, 0x38, 0x07, 0x38, 0x0e, 0x1c, 0x1e, 0x1e, 0xfc, 0x0f, 0xf8, 0x07, 0xe0, 0x01};
#define circle_mask_width 16
#define circle_mask_height 16
#define circle_mask_x_hot 8
#define circle_mask_y_hot 8
static unsigned char circle_mask_bits[] = {
0xe0, 0x07, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xfe, 0x7f, 0x3f, 0xfc, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x3f, 0xfc, 0xfe, 0x7f, 0xfe, 0x7f, 0xfc, 0x3f, 0xf8, 0x1f, 0xe0, 0x07};
#define clock_width 14
#define clock_height 16
#define clock_x_hot 6
#define clock_y_hot 3
static unsigned char clock_bits[] = {
0xfc, 0x8f, 0xe6, 0x19, 0x13, 0x33, 0xc9, 0x24, 0x79, 0x24, 0x11, 0x22, 0xe3, 0x31, 0xfe, 0x1f, 0xca, 0x14, 0xca, 0x14, 0xca, 0x14, 0xea, 0x15, 0xcb, 0x34, 0x0f, 0x3c, 0xff, 0x3f, 0xff, 0x3f};
#define clock_mask_width 15
#define clock_mask_height 16
#define clock_mask_x_hot 6
#define clock_mask_y_hot 3
static unsigned char clock_mask_bits[] = {
0xfe, 0x1f, 0xf7, 0x39, 0xdb, 0x77, 0xed, 0x6d, 0xfd, 0x6f, 0xf9, 0x66, 0xf3, 0x73, 0xff, 0x3f, 0xeb, 0x35, 0xeb, 0x35, 0xeb, 0x35, 0xfb, 0x37, 0xeb, 0x75, 0xcf, 0x7c, 0xff, 0x7f, 0xff, 0x7f};
#define coffee_mug_width 15
#define coffee_mug_height 16
#define coffee_mug_x_hot 7
#define coffee_mug_y_hot 9
static unsigned char coffee_mug_bits[] = {
0xf8, 0x8f, 0x04, 0x10, 0x06, 0x60, 0x0a, 0x58, 0xf2, 0x47, 0x03, 0x40, 0x03, 0x40, 0x02, 0x40, 0x02, 0x40, 0x9a, 0x58, 0x56, 0x55, 0xd7, 0x55, 0x5b, 0x59, 0x02, 0x40, 0x02, 0x40, 0xfc, 0x3f};
#define coffee_mug_mask_width 16
#define coffee_mug_mask_height 16
#define coffee_mug_mask_x_hot 7
#define coffee_mug_mask_y_hot 9
static unsigned char coffee_mug_mask_bits[] = {
0xf8, 0x0f, 0xfc, 0x1f, 0xfe, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xfc, 0x3f};
#define cross_width 16
#define cross_height 15
#define cross_x_hot 7
#define cross_y_hot 7
static unsigned char cross_bits[] = {
0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x7f, 0xff, 00, 00, 0x7f, 0xff, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01};
#define cross_mask_width 16
#define cross_mask_height 16
#define cross_mask_x_hot 7
#define cross_mask_y_hot 7
static unsigned char cross_mask_bits[] = {
0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x03};
#define cross_reverse_width 16
#define cross_reverse_height 15
#define cross_reverse_x_hot 7
#define cross_reverse_y_hot 7
static unsigned char cross_reverse_bits[] = {
0x42, 0x21, 0x45, 0x51, 0x4a, 0x29, 0x54, 0x15, 0x68, 0x0b, 0x50, 0x05, 0xbf, 0xfe, 0x40, 0x01, 0xbf, 0xfe, 0x50, 0x05, 0x68, 0x0b, 0x54, 0x15, 0x4a, 0x29, 0x45, 0x51, 0x42, 0x21};
#define cross_reverse_mask_width 16
#define cross_reverse_mask_height 15
#define cross_reverse_mask_x_hot 7
#define cross_reverse_mask_y_hot 7
static unsigned char cross_reverse_mask_bits[] = {
0x66, 0x33, 0x6d, 0xdb, 0x7b, 0x6f, 0x76, 0x37, 0x6c, 0x1b, 0x5f, 0xfd, 0x3f, 0xfe, 0x80, 00, 0x3f, 0xfe, 0x5f, 0xfd, 0x6c, 0x1b, 0x76, 0x37, 0x7b, 0x6f, 0x6d, 0xdb, 0x66, 0x33};
#define crosshair_width 16
#define crosshair_height 15
#define crosshair_x_hot 7
#define crosshair_y_hot 7
static unsigned char crosshair_bits[] = {
0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x7f, 0xff, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00, 0x80, 00};
#define crosshair_mask_width 16
#define crosshair_mask_height 16
#define crosshair_mask_x_hot 7
#define crosshair_mask_y_hot 7
static unsigned char crosshair_mask_bits[] = {
0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01};
#define diamond_cross_width 15
#define diamond_cross_height 15
#define diamond_cross_x_hot 7
#define diamond_cross_y_hot 7
static unsigned char diamond_cross_bits[] = {
0x40, 0x81, 0x60, 0x03, 0x50, 0x05, 0x48, 0x09, 0x44, 0x11, 0x42, 0x21, 0x7f, 0x7f, 00, 00, 0x7f, 0x7f, 0x42, 0x21, 0x44, 0x11, 0x48, 0x09, 0x50, 0x05, 0x60, 0x03, 0x40, 0x01};
#define diamond_cross_mask_width 16
#define diamond_cross_mask_height 16
#define diamond_cross_mask_x_hot 7
#define diamond_cross_mask_y_hot 7
static unsigned char diamond_cross_mask_bits[] = {
0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0f, 0xdc, 0x1d, 0xce, 0x39, 0xc7, 0x71, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xc7, 0x71, 0xce, 0x39, 0xdc, 0x1d, 0xf8, 0x0f, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01};
#define dot_width 10
#define dot_height 10
#define dot_x_hot 5
#define dot_y_hot 5
static unsigned char dot_bits[] = {
0x78, 0x90, 0xfe, 0x01, 0xfe, 0x01, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xfe, 0x01, 0xfe, 0x01, 0x78, 00};
#define dot_mask_width 12
#define dot_mask_height 12
#define dot_mask_x_hot 6
#define dot_mask_y_hot 6
static unsigned char dot_mask_bits[] = {
0xf8, 0x21, 0xfe, 0x07, 0xfe, 0x07, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xfe, 0x07, 0xfe, 0x07, 0xf8, 0x01};
#define dotbox_width 12
#define dotbox_height 12
#define dotbox_x_hot 6
#define dotbox_y_hot 5
static unsigned char dotbox_bits[] = {
0xff, 0x9f, 0x01, 0x08, 0x01, 0x08, 0x01, 0x08, 0x01, 0x08, 0x61, 0x08, 0x61, 0x08, 0x01, 0x08, 0x01, 0x08, 0x01, 0x08, 0x01, 0x08, 0xff, 0x0f};
#define dotbox_mask_width 14
#define dotbox_mask_height 14
#define dotbox_mask_x_hot 7
#define dotbox_mask_y_hot 6
static unsigned char dotbox_mask_bits[] = {
0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0x07, 0x38, 0x07, 0x38, 0xe7, 0x39, 0xe7, 0x39, 0xe7, 0x39, 0xe7, 0x39, 0x07, 0x38, 0x07, 0x38, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f};
#define double_arrow_width 10
#define double_arrow_height 14
#define double_arrow_x_hot 5
#define double_arrow_y_hot 7
static unsigned char double_arrow_bits[] = {
0x30, 0x90, 0x78, 00, 0xfc, 00, 0xb6, 0x01, 0x33, 0x03, 0x30, 00, 0x30, 00, 0x30, 00, 0x30, 00, 0x33, 0x03, 0xb6, 0x01, 0xfc, 00, 0x78, 00, 0x30, 00};
#define double_arrow_mask_width 12
#define double_arrow_mask_height 16
#define double_arrow_mask_x_hot 6
#define double_arrow_mask_y_hot 8
static unsigned char double_arrow_mask_bits[] = {
0xf0, 0x20, 0xf8, 0x01, 0xfc, 0x03, 0xfe, 0x07, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xf0, 00, 0xf0, 00, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xfe, 0x07, 0xfc, 0x03, 0xf8, 0x01, 0xf0, 00};
#define draft_large_width 15
#define draft_large_height 15
#define draft_large_x_hot 14
#define draft_large_y_hot 0
static unsigned char draft_large_bits[] = {
00, 0xc0, 00, 0x30, 00, 0x3c, 00, 0x1f, 0xc0, 0x1f, 0xf0, 0x0f, 0xfc, 0x0f, 0x80, 0x07, 0x40, 0x07, 0x20, 0x03, 0x10, 0x03, 0x08, 0x01, 0x04, 0x01, 0x02, 00, 0x01, 00};
#define draft_large_mask_width 15
#define draft_large_mask_height 16
#define draft_large_mask_x_hot 14
#define draft_large_mask_y_hot 0
static unsigned char draft_large_mask_bits[] = {
00, 0x60, 00, 0x78, 00, 0x7e, 0x80, 0x3f, 0xe0, 0x1f, 0xf8, 0x1f, 0xfe, 0x0f, 0xfe, 0x0f, 0xe0, 0x07, 0xf0, 0x07, 0xb8, 0x03, 0x9c, 0x03, 0x8e, 0x01, 0x87, 0x01, 0x03, 00, 0x01, 00};
#define draft_small_width 15
#define draft_small_height 15
#define draft_small_x_hot 14
#define draft_small_y_hot 0
static unsigned char draft_small_bits[] = {
00, 0x40, 00, 0x30, 00, 0x3c, 00, 0x1f, 0xc0, 0x1f, 00, 0x0e, 00, 0x0d, 0x80, 0x04, 0x40, 0x04, 0x20, 00, 0x10, 00, 0x08, 00, 0x04, 00, 0x02, 00, 0x01, 00};
#define draft_small_mask_width 15
#define draft_small_mask_height 15
#define draft_small_mask_x_hot 14
#define draft_small_mask_y_hot 0
static unsigned char draft_small_mask_bits[] = {
00, 0x60, 00, 0x78, 00, 0x3e, 0x80, 0x3f, 0xe0, 0x1f, 0xe0, 0x1f, 0x80, 0x0f, 0xc0, 0x0f, 0xe0, 0x06, 0x70, 0x02, 0x38, 00, 0x1c, 00, 0x0e, 00, 0x07, 00, 0x03, 00};
#define draped_box_width 12
#define draped_box_height 12
#define draped_box_x_hot 6
#define draped_box_y_hot 5
static unsigned char draped_box_bits[] = {
0xff, 0x1f, 0x91, 0x08, 0x99, 0x09, 0x0d, 0x0b, 0x07, 0x0e, 0x61, 0x08, 0x61, 0x08, 0x07, 0x0e, 0x0d, 0x0b, 0x99, 0x09, 0x91, 0x08, 0xff, 0x0f};
#define draped_box_mask_width 14
#define draped_box_mask_height 14
#define draped_box_mask_x_hot 7
#define draped_box_mask_y_hot 6
static unsigned char draped_box_mask_bits[] = {
0xff, 0x3f, 0xff, 0x3f, 0xf3, 0x33, 0xfb, 0x37, 0x3f, 0x3f, 0xdf, 0x3e, 0xef, 0x3d, 0xef, 0x3d, 0xdf, 0x3e, 0x3f, 0x3f, 0xfb, 0x37, 0xf3, 0x33, 0xff, 0x3f, 0xff, 0x3f};
#define exchange_width 14
#define exchange_height 14
#define exchange_x_hot 6
#define exchange_y_hot 6
static unsigned char exchange_bits[] = {
0xf1, 0x03, 0xfb, 0x07, 0x1f, 0x0c, 0x09, 0x08, 0x19, 00, 0x3f, 00, 00, 00, 00, 00, 00, 0x3f, 00, 0x26, 0x04, 0x24, 0x0c, 0x3e, 0xf8, 0x37, 0xf0, 0x23};
#define exchange_mask_width 16
#define exchange_mask_height 16
#define exchange_mask_x_hot 7
#define exchange_mask_y_hot 7
static unsigned char exchange_mask_bits[] = {
0xe3, 0x07, 0xf7, 0x0f, 0xff, 0x1f, 0xff, 0x3f, 0x3f, 0x38, 0xff, 0x30, 0xff, 00, 0xff, 00, 00, 0xff, 00, 0xff, 0x0c, 0xfe, 0x1c, 0xfc, 0xfc, 0xff, 0xf8, 0xff, 0xf0, 0xef, 0xe0, 0xc7};
#define fleur_width 14
#define fleur_height 14
#define fleur_x_hot 7
#define fleur_y_hot 7
static unsigned char fleur_bits[] = {
0xc0, 00, 0xe0, 0x01, 0xf0, 0x03, 0xc0, 00, 0xc4, 0x08, 0xc6, 0x18, 0xff, 0x3f, 0xff, 0x3f, 0xc6, 0x18, 0xc4, 0x08, 0xc0, 00, 0xf0, 0x03, 0xe0, 0x01, 0xc0, 00};
#define fleur_mask_width 16
#define fleur_mask_height 16
#define fleur_mask_x_hot 8
#define fleur_mask_y_hot 8
static unsigned char fleur_mask_bits[] = {
0xc0, 0x03, 0xc0, 0x07, 0xe0, 0x07, 0xf0, 0x0f, 0xe8, 0x17, 0xdc, 0x3b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdc, 0x3b, 0xe8, 0x17, 0xf0, 0x0f, 0xe0, 0x07, 0xc0, 0x03, 0xc0, 0x03};
#define gobbler_width 16
#define gobbler_height 15
#define gobbler_x_hot 14
#define gobbler_y_hot 2
static unsigned char gobbler_bits[] = {
00, 0x1e, 00, 0x0e, 0x01, 0xcc, 0xf9, 0x0d, 0xff, 0x0f, 0x7f, 0x0c, 0x3f, 0x0c, 0x06, 0x1c, 00, 0x0f, 0xf8, 0x07, 0x10, 00, 0x10, 00, 0x10, 00, 0x10, 00, 0x78, 00};
#define gobbler_mask_width 16
#define gobbler_mask_height 16
#define gobbler_mask_x_hot 14
#define gobbler_mask_y_hot 3
static unsigned char gobbler_mask_bits[] = {
00, 0x3f, 00, 0x3f, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xfe, 0x1f, 0xf8, 0x0f, 0x38, 00, 0x38, 00, 0xfc, 00, 0xfc, 00};
#define gumby_width 16
#define gumby_height 16
#define gumby_x_hot 2
#define gumby_y_hot 0
static unsigned char gumby_bits[] = {
0xfc, 00, 0x08, 0x01, 0x13, 0x02, 0x57, 0x05, 0x13, 0x04, 0xd3, 0x05, 0x1f, 0x3c, 0x1c, 0xfc, 0x10, 0xe4, 0x10, 0xe4, 0x90, 0xf4, 0x90, 0xe4, 0x90, 0x04, 0x88, 0x08, 0x84, 0x10, 0x7c, 0x1f};
#define gumby_mask_width 16
#define gumby_mask_height 16
#define gumby_mask_x_hot 2
#define gumby_mask_y_hot 0
static unsigned char gumby_mask_bits[] = {
0xfc, 00, 0xfb, 0x01, 0xf7, 0x03, 0xff, 0x07, 0xf7, 0x07, 0xf7, 0x3f, 0xff, 0x7f, 0xff, 0xff, 0xfc, 0xf7, 0xf0, 0xf7, 0xf0, 0xff, 0xf0, 0xf7, 0xf0, 0xe7, 0xf8, 0x0f, 0xfc, 0x1f, 0x7c, 0x1f};
#define hand1_width 13
#define hand1_height 16
#define hand1_x_hot 12
#define hand1_y_hot 0
static unsigned char hand1_bits[] = {
00, 0x18, 00, 0x1e, 0x80, 0x07, 0xc0, 0x03, 0xe0, 0x01, 0xf0, 0x03, 0xf8, 0x07, 0xfa, 0x03, 0xff, 0x07, 0xfd, 0x07, 0xf0, 0x03, 0xf0, 0x01, 0x29, 00, 0x23, 00, 0x16, 00, 0x0c, 00};
#define hand1_mask_width 13
#define hand1_mask_height 16
#define hand1_mask_x_hot 12
#define hand1_mask_y_hot 0
static unsigned char hand1_mask_bits[] = {
00, 0xdc, 00, 0x1f, 0xc0, 0x0f, 0xe0, 0x07, 0xf0, 0x03, 0xf8, 0x07, 0xfe, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x07, 0xff, 0x03, 0xff, 0x01, 0x7f, 00, 0x3f, 00, 0x1e, 00};
#define hand2_width 15
#define hand2_height 14
#define hand2_x_hot 0
#define hand2_y_hot 0
static unsigned char hand2_bits[] = {
0xfe, 0x01, 0x01, 0x02, 0x7e, 0x04, 0x08, 0x08, 0x70, 0x08, 0x08, 0x08, 0x70, 0x14, 0x08, 0x22, 0x30, 0x41, 0xc0, 0x20, 0x40, 0x12, 0x80, 0x08, 00, 0x05, 00, 0x02};
#define hand2_mask_width 16
#define hand2_mask_height 16
#define hand2_mask_x_hot 0
#define hand2_mask_y_hot 1
static unsigned char hand2_mask_bits[] = {
0xfe, 0x01, 0xff, 0x03, 0xff, 0x07, 0xff, 0x0f, 0xfe, 0x1f, 0xf8, 0x1f, 0xfc, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xf8, 0xff, 0xf0, 0x7f, 0xe0, 0x3f, 0xc0, 0x1f, 0x80, 0x0f, 00, 0x07, 00, 0x02};
#define heart_width 15
#define heart_height 14
#define heart_x_hot 6
#define heart_y_hot 8
static unsigned char heart_bits[] = {
0x7c, 0x1f, 0xc6, 0x31, 0x83, 0x60, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x03, 0x60, 0x06, 0x30, 0x0c, 0x18, 0x18, 0x0c, 0x30, 0x06, 0x60, 0x03, 0xc0, 0x01};
#define heart_mask_width 15
#define heart_mask_height 14
#define heart_mask_x_hot 6
#define heart_mask_y_hot 8
static unsigned char heart_mask_bits[] = {
0x7c, 0x9f, 0xfe, 0x3f, 0xc7, 0x71, 0x83, 0x60, 0x03, 0x60, 0x03, 0x60, 0x43, 0x61, 0x87, 0x70, 0x0e, 0x38, 0x1c, 0x1c, 0x38, 0x0e, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01};
#define icon_width 16
#define icon_height 16
#define icon_x_hot 8
#define icon_y_hot 8
static unsigned char icon_bits[] = {
0xff, 0xff, 0xab, 0xaa, 0x55, 0xd5, 0xab, 0xaa, 0x05, 0xd0, 0x0b, 0xa0, 0x05, 0xd0, 0x0b, 0xa0, 0x05, 0xd0, 0x0b, 0xa0, 0x05, 0xd0, 0x0b, 0xa0, 0x55, 0xd5, 0xab, 0xaa, 0x55, 0xd5, 0xff, 0xff};
#define icon_mask_width 16
#define icon_mask_height 16
#define icon_mask_x_hot 8
#define icon_mask_y_hot 8
static unsigned char icon_mask_bits[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
#define iron_cross_width 14
#define iron_cross_height 14
#define iron_cross_x_hot 7
#define iron_cross_y_hot 6
static unsigned char iron_cross_bits[] = {
0xfe, 0x1f, 0xfc, 0x0f, 0xf9, 0x27, 0xf3, 0x33, 0xe7, 0x39, 0xcf, 0x3c, 0xff, 0x3f, 0xff, 0x3f, 0xcf, 0x3c, 0xe7, 0x39, 0xf3, 0x33, 0xf9, 0x27, 0xfc, 0x0f, 0xfe, 0x1f};
#define iron_cross_mask_width 16
#define iron_cross_mask_height 16
#define iron_cross_mask_x_hot 8
#define iron_cross_mask_y_hot 7
static unsigned char iron_cross_mask_bits[] = {
0xfc, 0x3f, 0xfe, 0x7f, 0xfe, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xfe, 0x7f, 0xfc, 0x3f};
#define left_ptr_width 8
#define left_ptr_height 14
#define left_ptr_x_hot 0
#define left_ptr_y_hot 0
static unsigned char left_ptr_bits[] = {
0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff, 0x1f, 0x1b, 0x31, 0x30, 0x60, 0x60};
#define left_ptr_mask_width 10
#define left_ptr_mask_height 16
#define left_ptr_mask_x_hot 1
#define left_ptr_mask_y_hot 1
static unsigned char left_ptr_mask_bits[] = {
0x03, 0xc0, 0x07, 00, 0x0f, 00, 0x1f, 00, 0x3f, 00, 0x7f, 00, 0xff, 00, 0xff, 0x01, 0xff, 0x03, 0xff, 0x03, 0x7f, 00, 0xf7, 00, 0xf3, 00, 0xe0, 0x01, 0xe0, 0x01, 0xc0, 00};
#define left_side_width 14
#define left_side_height 13
#define left_side_x_hot 0
#define left_side_y_hot 6
static unsigned char left_side_bits[] = {
0x03, 00, 0x03, 00, 0x83, 00, 0x43, 00, 0x23, 00, 0x13, 00, 0xfb, 0x3f, 0x13, 00, 0x23, 00, 0x43, 00, 0x83, 00, 0x03, 00, 0x03, 00};
#define left_side_mask_width 16
#define left_side_mask_height 15
#define left_side_mask_x_hot 1
#define left_side_mask_y_hot 7
static unsigned char left_side_mask_bits[] = {
0x0f, 00, 0x0f, 00, 0x0f, 0x03, 0x8f, 0x03, 0xcf, 0x01, 0xef, 00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 00, 0xcf, 0x01, 0x8f, 0x03, 0x0f, 0x03, 0x0f, 00, 0x0f, 00};
#define left_tee_width 10
#define left_tee_height 14
#define left_tee_x_hot 0
#define left_tee_y_hot 7
static unsigned char left_tee_bits[] = {
0x03, 0x10, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0xff, 0x03, 0xff, 0x03, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00};
#define left_tee_mask_width 12
#define left_tee_mask_height 16
#define left_tee_mask_x_hot 1
#define left_tee_mask_y_hot 8
static unsigned char left_tee_mask_bits[] = {
0x0f, 0xc0, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00};
#define leftbutton_width 16
#define leftbutton_height 16
#define leftbutton_x_hot 8
#define leftbutton_y_hot 8
static unsigned char leftbutton_bits[] = {
0x01, 0xc0, 0xfe, 0xbf, 0xfe, 0xbf, 0x22, 0xa2, 0xa2, 0xaa, 0xa2, 0xaa, 0xa2, 0xaa, 0xa2, 0xaa, 0x22, 0xa2, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0x01, 0xc0};
#define leftbutton_mask_width 15
#define leftbutton_mask_height 16
#define leftbutton_mask_x_hot 8
#define leftbutton_mask_y_hot 8
static unsigned char leftbutton_mask_bits[] = {
0xfe, 0xbf, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xfe, 0x3f};
#define ll_angle_width 10
#define ll_angle_height 10
#define ll_angle_x_hot 0
#define ll_angle_y_hot 9
static unsigned char ll_angle_bits[] = {
0x03, 0x10, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0xff, 0x03, 0xff, 0x03};
#define ll_angle_mask_width 12
#define ll_angle_mask_height 12
#define ll_angle_mask_x_hot 1
#define ll_angle_mask_y_hot 10
static unsigned char ll_angle_mask_bits[] = {
0x0f, 0xc0, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f};
#define lr_angle_width 10
#define lr_angle_height 10
#define lr_angle_x_hot 9
#define lr_angle_y_hot 9
static unsigned char lr_angle_bits[] = {
00, 0x13, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 0xff, 0x03, 0xff, 0x03};
#define lr_angle_mask_width 12
#define lr_angle_mask_height 12
#define lr_angle_mask_x_hot 10
#define lr_angle_mask_y_hot 10
static unsigned char lr_angle_mask_bits[] = {
00, 0xcf, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f};
#define man_width 16
#define man_height 16
#define man_x_hot 14
#define man_y_hot 5
static unsigned char man_bits[] = {
0xc0, 0x01, 0x78, 0x0f, 0x40, 0x01, 0x81, 00, 0xc2, 0xe1, 0x24, 0xd2, 0xb8, 0x0e, 0xa0, 0x02, 0x20, 0x02, 0x40, 0x01, 0x20, 0x02, 0x90, 0x04, 0x48, 0x09, 0x28, 0x0a, 0x1e, 0x3c, 0x1f, 0xfc};
#define man_mask_width 16
#define man_mask_height 16
#define man_mask_x_hot 14
#define man_mask_y_hot 5
static unsigned char man_mask_bits[] = {
0xf8, 0x07, 0xfc, 0x0f, 0xfc, 0x1f, 0xc3, 0x41, 0xe7, 0xe3, 0xfe, 0xff, 0xfc, 0xdf, 0xf8, 0x0f, 0xe0, 0x07, 0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0f, 0xfc, 0x1f, 0x7e, 0x3f, 0x3f, 0xfe, 0x3f, 0xfe};
#define middlebutton_width 16
#define middlebutton_height 16
#define middlebutton_x_hot 8
#define middlebutton_y_hot 8
static unsigned char middlebutton_bits[] = {
0x01, 0xc0, 0xfe, 0xbf, 0xfe, 0xbf, 0x22, 0xa2, 0x2a, 0xaa, 0x2a, 0xaa, 0x2a, 0xaa, 0x2a, 0xaa, 0x22, 0xa2, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0x01, 0xc0};
#define middlebutton_mask_width 15
#define middlebutton_mask_height 16
#define middlebutton_mask_x_hot 8
#define middlebutton_mask_y_hot 8
static unsigned char middlebutton_mask_bits[] = {
0xfe, 0xbf, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xfe, 0x3f};
#define mouse_width 15
#define mouse_height 14
#define mouse_x_hot 4
#define mouse_y_hot 1
static unsigned char mouse_bits[] = {
0xe0, 00, 0x30, 00, 0x60, 00, 0xc0, 00, 0xfe, 0x1f, 0x01, 0x20, 0xcd, 0x6c, 0xcd, 0x6c, 0xcd, 0x6c, 0x01, 0x60, 0x01, 0x60, 0x06, 0x38, 0x18, 0x06, 0xe0, 0x01};
#define mouse_mask_width 16
#define mouse_mask_height 16
#define mouse_mask_x_hot 4
#define mouse_mask_y_hot 1
static unsigned char mouse_mask_bits[] = {
0xf0, 0x01, 0x78, 00, 0xf0, 00, 0xe0, 00, 0xfe, 0x1f, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xef, 0xf8, 0x07, 0xf0, 0x03, 0xe0, 0x01};
#define pencil_width 11
#define pencil_height 16
#define pencil_x_hot 10
#define pencil_y_hot 15
static unsigned char pencil_bits[] = {
0x0e, 0x10, 0x11, 00, 0x31, 00, 0x52, 00, 0x5e, 00, 0x84, 00, 0x88, 00, 0x08, 0x01, 0x10, 0x01, 0x30, 0x02, 0x20, 0x02, 0x40, 0x04, 0x80, 0x07, 00, 0x07, 00, 0x06, 00, 0x04};
#define pencil_mask_width 13
#define pencil_mask_height 16
#define pencil_mask_x_hot 11
#define pencil_mask_y_hot 15
static unsigned char pencil_mask_bits[] = {
0x3f, 0xc0, 0x7f, 00, 0xff, 00, 0xfe, 00, 0xfc, 0x01, 0xfc, 0x01, 0xf8, 0x03, 0xf0, 0x03, 0xf0, 0x07, 0xe0, 0x07, 0xe0, 0x0f, 0xc0, 0x1f, 0x80, 0x1f, 00, 0x1f, 00, 0x1e, 00, 0x1c};
#define pirate_width 15
#define pirate_height 16
#define pirate_x_hot 7
#define pirate_y_hot 12
static unsigned char pirate_bits[] = {
0xe0, 0x01, 0xf0, 0x03, 0xf8, 0x07, 0xcc, 0x0c, 0xcc, 0x0c, 0xf8, 0x07, 0xf0, 0x03, 0xe0, 0x01, 0xe1, 0x21, 0xe1, 0x61, 0xc2, 0x10, 0x1c, 0x0e, 0xe0, 0x01, 0xf8, 0x47, 0x0f, 0x7c, 0x01, 0x20};
#define pirate_mask_width 16
#define pirate_mask_height 16
#define pirate_mask_x_hot 7
#define pirate_mask_y_hot 12
static unsigned char pirate_mask_bits[] = {
0xf0, 0x03, 0xf8, 0x07, 0xfc, 0x0f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfc, 0x0f, 0xf8, 0x07, 0xf1, 0x83, 0xf1, 0xe3, 0xf3, 0xf3, 0xef, 0x39, 0x1e, 0x1e, 0xe0, 0x01, 0xfe, 0xc7, 0xff, 0xff, 0x0f, 0x7c};
#define plus_width 10
#define plus_height 10
#define plus_x_hot 4
#define plus_y_hot 5
static unsigned char plus_bits[] = {
0x30, 0x10, 0x30, 00, 0x30, 00, 0x30, 00, 0xff, 0x03, 0xff, 0x03, 0x30, 00, 0x30, 00, 0x30, 00, 0x30, 00};
#define plus_mask_width 12
#define plus_mask_height 12
#define plus_mask_x_hot 5
#define plus_mask_y_hot 6
static unsigned char plus_mask_bits[] = {
0xf0, 0xc0, 0xf0, 00, 0xf0, 00, 0xf0, 00, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xf0, 00, 0xf0, 00, 0xf0, 00, 0xf0, 00};
#define question_arrow_width 9
#define question_arrow_height 15
#define question_arrow_x_hot 4
#define question_arrow_y_hot 7
static unsigned char question_arrow_bits[] = {
0x7c, 0x10, 0xfe, 00, 0xc7, 0x01, 0x83, 0x01, 0x87, 0x01, 0xc6, 0x01, 0xe0, 00, 0x78, 00, 0x38, 00, 0x28, 00, 0x28, 00, 0xee, 00, 0x6c, 00, 0x38, 00, 0x10, 00};
#define question_arrow_mask_width 11
#define question_arrow_mask_height 16
#define question_arrow_mask_x_hot 5
#define question_arrow_mask_y_hot 8
static unsigned char question_arrow_mask_bits[] = {
0xf8, 0xc0, 0xfc, 0x01, 0xfe, 0x03, 0xff, 0x07, 0x8f, 0x07, 0x9f, 0x07, 0xde, 0x07, 0xfc, 0x03, 0xf8, 0x01, 0xf8, 00, 0xf8, 00, 0xfc, 0x01, 0xfe, 0x03, 0xfc, 0x01, 0xf8, 00, 0x70, 00};
#define right_ptr_width 8
#define right_ptr_height 14
#define right_ptr_x_hot 7
#define right_ptr_y_hot 0
static unsigned char right_ptr_bits[] = {
0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff, 0xf8, 0xd8, 0x8c, 0x0c, 0x06, 0x06};
#define right_ptr_mask_width 10
#define right_ptr_mask_height 16
#define right_ptr_mask_x_hot 8
#define right_ptr_mask_y_hot 1
static unsigned char right_ptr_mask_bits[] = {
00, 0xc3, 0x80, 0x03, 0xc0, 0x03, 0xe0, 0x03, 0xf0, 0x03, 0xf8, 0x03, 0xfc, 0x03, 0xfe, 0x03, 0xff, 0x03, 0xff, 0x03, 0xf8, 0x03, 0xbc, 0x03, 0x3c, 0x03, 0x1e, 00, 0x1e, 00, 0x0c, 00};
#define right_side_width 14
#define right_side_height 13
#define right_side_x_hot 13
#define right_side_y_hot 6
static unsigned char right_side_bits[] = {
00, 0x30, 00, 0x30, 0x40, 0x30, 0x80, 0x30, 00, 0x31, 00, 0x32, 0xff, 0x37, 00, 0x32, 00, 0x31, 0x80, 0x30, 0x40, 0x30, 00, 0x30, 00, 0x30};
#define right_side_mask_width 16
#define right_side_mask_height 15
#define right_side_mask_x_hot 14
#define right_side_mask_y_hot 7
static unsigned char right_side_mask_bits[] = {
00, 0xf0, 00, 0xf0, 0xc0, 0xf0, 0xc0, 0xf1, 0x80, 0xf3, 00, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 00, 0xf7, 0x80, 0xf3, 0xc0, 0xf1, 0xc0, 0xf0, 00, 0xf0, 00, 0xf0};
#define right_tee_width 10
#define right_tee_height 14
#define right_tee_x_hot 9
#define right_tee_y_hot 7
static unsigned char right_tee_bits[] = {
00, 0x13, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 0xff, 0x03, 0xff, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03};
#define right_tee_mask_width 12
#define right_tee_mask_height 16
#define right_tee_mask_x_hot 10
#define right_tee_mask_y_hot 8
static unsigned char right_tee_mask_bits[] = {
00, 0xcf, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f};
#define rightbutton_width 16
#define rightbutton_height 16
#define rightbutton_x_hot 8
#define rightbutton_y_hot 8
static unsigned char rightbutton_bits[] = {
0x01, 0xc0, 0xfe, 0xbf, 0xfe, 0xbf, 0x22, 0xa2, 0xaa, 0xa2, 0xaa, 0xa2, 0xaa, 0xa2, 0xaa, 0xa2, 0x22, 0xa2, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0xfe, 0xbf, 0x01, 0xc0};
#define rightbutton_mask_width 15
#define rightbutton_mask_height 16
#define rightbutton_mask_x_hot 8
#define rightbutton_mask_y_hot 8
static unsigned char rightbutton_mask_bits[] = {
0xfe, 0xbf, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xfe, 0x3f};
#define rtl_logo_width 14
#define rtl_logo_height 14
#define rtl_logo_x_hot 6
#define rtl_logo_y_hot 6
static unsigned char rtl_logo_bits[] = {
0xff, 0x3f, 0x01, 0x22, 0x01, 0x22, 0x01, 0x22, 0xff, 0x23, 0x11, 0x22, 0x11, 0x22, 0x11, 0x22, 0x11, 0x22, 0xf1, 0x3f, 0x11, 0x20, 0x11, 0x20, 0x11, 0x20, 0xff, 0x3f};
#define rtl_logo_mask_width 16
#define rtl_logo_mask_height 16
#define rtl_logo_mask_x_hot 7
#define rtl_logo_mask_y_hot 7
static unsigned char rtl_logo_mask_bits[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xee, 0xff, 0xef, 0xff, 0xef, 0xff, 0xef, 0x77, 0xee, 0x77, 0xee, 0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0x77, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
#define sailboat_width 12
#define sailboat_height 13
#define sailboat_x_hot 6
#define sailboat_y_hot -1
static unsigned char sailboat_bits[] = {
0x80, 0x10, 0x80, 00, 0xa0, 0x01, 0xa0, 0x01, 0xb0, 0x01, 0xb0, 0x03, 0xb8, 0x03, 0xb8, 0x03, 0xbc, 0x07, 0xbc, 0x07, 0xbe, 0x07, 0xbe, 0x0f, 0x1f, 0x07};
#define sailboat_mask_width 16
#define sailboat_mask_height 16
#define sailboat_mask_x_hot 8
#define sailboat_mask_y_hot 0
static unsigned char sailboat_mask_bits[] = {
00, 0x03, 00, 0x07, 0x80, 0x07, 0xc0, 0x0f, 0xc0, 0x0f, 0xe0, 0x0f, 0xe0, 0x1f, 0xf0, 0x1f, 0xf0, 0x1f, 0xf8, 0x3f, 0xf8, 0x3f, 0xfc, 0x3f, 0xfc, 0xff, 0xfe, 0xff, 0xff, 0x1f, 0xfe, 0x07};
#define sb_down_arrow_width 7
#define sb_down_arrow_height 15
#define sb_down_arrow_x_hot 3
#define sb_down_arrow_y_hot 15
static unsigned char sb_down_arrow_bits[] = {
0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x7f, 0x3e, 0x1c, 0x08};
#define sb_down_arrow_mask_width 9
#define sb_down_arrow_mask_height 16
#define sb_down_arrow_mask_x_hot 4
#define sb_down_arrow_mask_y_hot 15
static unsigned char sb_down_arrow_mask_bits[] = {
0x7c, 0xc0, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0xff, 0x01, 0xff, 0x01, 0xfe, 00, 0x7c, 00, 0x38, 00, 0x10, 00};
#define sb_h_double_arrow_width 15
#define sb_h_double_arrow_height 7
#define sb_h_double_arrow_x_hot 7
#define sb_h_double_arrow_y_hot 3
static unsigned char sb_h_double_arrow_bits[] = {
0x08, 0x08, 0x0c, 0x18, 0xfe, 0x3f, 0x0f, 0x78, 0xfe, 0x3f, 0x0c, 0x18, 0x08, 0x08};
#define sb_h_double_arrow_mask_width 15
#define sb_h_double_arrow_mask_height 9
#define sb_h_double_arrow_mask_x_hot 7
#define sb_h_double_arrow_mask_y_hot 4
static unsigned char sb_h_double_arrow_mask_bits[] = {
0x18, 0x8c, 0x1c, 0x1c, 0xfe, 0x3f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xfe, 0x3f, 0x1c, 0x1c, 0x18, 0x0c};
#define sb_left_arrow_width 15
#define sb_left_arrow_height 7
#define sb_left_arrow_x_hot -1
#define sb_left_arrow_y_hot 3
static unsigned char sb_left_arrow_bits[] = {
0x08, 00, 0x0c, 00, 0xfe, 0x7f, 0x0f, 00, 0xfe, 0x7f, 0x0c, 00, 0x08, 00};
#define sb_left_arrow_mask_width 16
#define sb_left_arrow_mask_height 9
#define sb_left_arrow_mask_x_hot 0
#define sb_left_arrow_mask_y_hot 4
static unsigned char sb_left_arrow_mask_bits[] = {
0x30, 00, 0x38, 00, 0xfc, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xfc, 0xff, 0x38, 00, 0x30, 00};
#define sb_right_arrow_width 15
#define sb_right_arrow_height 7
#define sb_right_arrow_x_hot 15
#define sb_right_arrow_y_hot 3
static unsigned char sb_right_arrow_bits[] = {
00, 0x08, 00, 0x18, 0xff, 0x3f, 00, 0x78, 0xff, 0x3f, 00, 0x18, 00, 0x08};
#define sb_right_arrow_mask_width 16
#define sb_right_arrow_mask_height 9
#define sb_right_arrow_mask_x_hot 15
#define sb_right_arrow_mask_y_hot 4
static unsigned char sb_right_arrow_mask_bits[] = {
00, 0x0c, 00, 0x1c, 0xff, 0x3f, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff, 0x3f, 00, 0x1c, 00, 0x0c};
#define sb_up_arrow_width 7
#define sb_up_arrow_height 15
#define sb_up_arrow_x_hot 3
#define sb_up_arrow_y_hot -1
static unsigned char sb_up_arrow_bits[] = {
0x08, 0x9c, 0x3e, 0x7f, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14};
#define sb_up_arrow_mask_width 9
#define sb_up_arrow_mask_height 16
#define sb_up_arrow_mask_x_hot 4
#define sb_up_arrow_mask_y_hot 0
static unsigned char sb_up_arrow_mask_bits[] = {
0x10, 0xc0, 0x38, 00, 0x7c, 00, 0xfe, 00, 0xff, 0x01, 0xff, 0x01, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00};
#define sb_v_double_arrow_width 7
#define sb_v_double_arrow_height 15
#define sb_v_double_arrow_x_hot 3
#define sb_v_double_arrow_y_hot 7
static unsigned char sb_v_double_arrow_bits[] = {
0x08, 0x9c, 0x3e, 0x7f, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x7f, 0x3e, 0x1c, 0x08};
#define sb_v_double_arrow_mask_width 9
#define sb_v_double_arrow_mask_height 15
#define sb_v_double_arrow_mask_x_hot 4
#define sb_v_double_arrow_mask_y_hot 7
static unsigned char sb_v_double_arrow_mask_bits[] = {
0x38, 0xc0, 0x7c, 00, 0xfe, 00, 0xff, 0x01, 0xff, 0x01, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0x7c, 00, 0xff, 0x01, 0xff, 0x01, 0xfe, 00, 0x7c, 00, 0x38, 00};
#define shuttle_width 15
#define shuttle_height 16
#define shuttle_x_hot 10
#define shuttle_y_hot 0
static unsigned char shuttle_bits[] = {
00, 0x84, 00, 0x0e, 00, 0x1f, 0x80, 0x7b, 0xa0, 0x7b, 0x90, 0x7b, 0x88, 0x7b, 0x88, 0x7b, 0x88, 0x7b, 0x88, 0x7b, 0x8c, 0x7b, 0x8e, 0x7b, 0xbf, 0x7b, 0x18, 0x11, 00, 0x1e, 00, 0x0c};
#define shuttle_mask_width 16
#define shuttle_mask_height 16
#define shuttle_mask_x_hot 11
#define shuttle_mask_y_hot 0
static unsigned char shuttle_mask_bits[] = {
00, 0x1c, 00, 0x3e, 00, 0x7f, 00, 0xff, 0x60, 0xff, 0x70, 0xff, 0x78, 0xff, 0x78, 0xff, 0x78, 0xff, 0x78, 0xff, 0x7c, 0xff, 0x7e, 0xff, 0x7f, 0xff, 0x7e, 0x7f, 0x30, 0x7e, 00, 0x3c};
#define sizing_width 14
#define sizing_height 14
#define sizing_x_hot 7
#define sizing_y_hot 7
static unsigned char sizing_bits[] = {
0xff, 0xc0, 0x01, 00, 0x01, 00, 0x01, 00, 0xf1, 0x03, 0x11, 0x02, 0x11, 0x22, 0x11, 0x22, 0x10, 0x22, 0xf0, 0x23, 00, 0x24, 00, 0x28, 00, 0x30, 0xc0, 0x3f};
#define sizing_mask_width 16
#define sizing_mask_height 16
#define sizing_mask_x_hot 8
#define sizing_mask_y_hot 8
static unsigned char sizing_mask_bits[] = {
0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0x07, 00, 0xf7, 0x0f, 0xf7, 0x0f, 0xf7, 0xef, 0x77, 0xee, 0x77, 0xee, 0xf7, 0xef, 0xf0, 0xef, 0xf0, 0xff, 00, 0xf8, 0xc0, 0xff, 0xc0, 0xff, 0xc0, 0xff};
#define spider_width 16
#define spider_height 16
#define spider_x_hot 6
#define spider_y_hot 7
static unsigned char spider_bits[] = {
0x04, 0x08, 0x08, 0x04, 0x08, 0x04, 0x10, 0x02, 0x10, 0x02, 0xe1, 0xe1, 0xe6, 0x19, 0xf8, 0x07, 0xf8, 0x07, 0xe6, 0x19, 0xe1, 0xe1, 0x10, 0x02, 0x10, 0x02, 0x08, 0x04, 0x08, 0x04, 0x04, 0x08};
#define spider_mask_width 16
#define spider_mask_height 16
#define spider_mask_x_hot 6
#define spider_mask_y_hot 7
static unsigned char spider_mask_bits[] = {
0x06, 0x18, 0x0c, 0x0c, 0x08, 0x04, 0x18, 0x06, 0xf1, 0x83, 0xf3, 0xf3, 0xf6, 0x3b, 0xfc, 0x0f, 0xfc, 0x07, 0xf6, 0x1f, 0xf3, 0xf3, 0xf1, 0x83, 0x18, 0x02, 0x18, 0x06, 0x0c, 0x0c, 0x06, 0x18};
#define spraycan_width 11
#define spraycan_height 16
#define spraycan_x_hot 9
#define spraycan_y_hot 2
static unsigned char spraycan_bits[] = {
00, 0xe6, 0x80, 00, 0x2c, 0x06, 0x9e, 00, 0x16, 0x06, 0x3f, 00, 0x21, 00, 0x27, 00, 0x25, 00, 0x27, 00, 0x25, 00, 0x27, 00, 0x27, 00, 0x21, 00, 0x21, 00, 0x3f, 00};
#define spraycan_mask_width 12
#define spraycan_mask_height 16
#define spraycan_mask_x_hot 10
#define spraycan_mask_y_hot 2
static unsigned char spraycan_mask_bits[] = {
00, 0x4c, 0x18, 0x0d, 0x7c, 0x0d, 0x7c, 0x0d, 0x7e, 0x0d, 0xff, 00, 0xff, 00, 0xff, 00, 0xff, 00, 0xff, 00, 0xff, 00, 0xff, 00, 0xff, 00, 0xff, 00, 0xff, 00, 0xff, 00};
#define star_width 15
#define star_height 16
#define star_x_hot 7
#define star_y_hot 7
static unsigned char star_bits[] = {
0x80, 0x80, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x20, 0x02, 0x20, 0x02, 0x20, 0x02, 0x9c, 0x1c, 0x03, 0x60, 0x1c, 0x1c, 0x90, 0x04, 0x48, 0x09, 0x24, 0x12, 0x14, 0x14, 0x0c, 0x18, 0x04, 0x10};
#define star_mask_width 16
#define star_mask_height 16
#define star_mask_x_hot 7
#define star_mask_y_hot 7
static unsigned char star_mask_bits[] = {
0x80, 00, 0xc0, 0x01, 0xc0, 0x01, 0x60, 0x03, 0x60, 0x03, 0x30, 0x06, 0x38, 0x1e, 0x9f, 0x7c, 0x03, 0xe0, 0x1f, 0x7c, 0x9c, 0x1c, 0xcc, 0x19, 0x66, 0x33, 0x36, 0x36, 0x1e, 0x3c, 0x0e, 0x38};
#define target_width 15
#define target_height 13
#define target_x_hot 7
#define target_y_hot 6
static unsigned char target_bits[] = {
0xc0, 0x81, 0xf0, 0x07, 0x38, 0x0e, 0x0c, 0x18, 0x06, 0x30, 0x83, 0x60, 0x43, 0x61, 0x83, 0x60, 0x06, 0x30, 0x0c, 0x18, 0x38, 0x0e, 0xf0, 0x07, 0xc0, 0x01};
#define target_mask_width 16
#define target_mask_height 14
#define target_mask_x_hot 7
#define target_mask_y_hot 7
static unsigned char target_mask_bits[] = {
0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0f, 0x3c, 0x1e, 0x0e, 0x38, 0x87, 0x70, 0xc3, 0xe1, 0x63, 0xe3, 0xc3, 0xe1, 0x87, 0x70, 0x0e, 0x38, 0x3c, 0x1e, 0xf8, 0x0f, 0xe0, 0x03};
#define tcross_width 13
#define tcross_height 13
#define tcross_x_hot 6
#define tcross_y_hot 6
static unsigned char tcross_bits[] = {
0x40, 0xe0, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00, 0xff, 0x1f, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00};
#define tcross_mask_width 15
#define tcross_mask_height 15
#define tcross_mask_x_hot 7
#define tcross_mask_y_hot 7
static unsigned char tcross_mask_bits[] = {
0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01};
#define top_left_arrow_width 14
#define top_left_arrow_height 14
#define top_left_arrow_x_hot 0
#define top_left_arrow_y_hot 0
static unsigned char top_left_arrow_bits[] = {
0x03, 0xc0, 0x0f, 00, 0x3e, 00, 0xfe, 00, 0xfc, 0x03, 0xfc, 0x0f, 0xf8, 00, 0xf8, 00, 0x30, 0x01, 0x30, 0x02, 0x20, 0x04, 0x20, 0x08, 00, 0x10, 00, 0x20};
#define top_left_arrow_mask_width 16
#define top_left_arrow_mask_height 16
#define top_left_arrow_mask_x_hot 1
#define top_left_arrow_mask_y_hot 1
static unsigned char top_left_arrow_mask_bits[] = {
0x07, 00, 0x1f, 00, 0x7f, 00, 0xfe, 0x01, 0xfe, 0x07, 0xfc, 0x3f, 0xfc, 0x3f, 0xf8, 0x3f, 0xf8, 0x03, 0xf0, 0x07, 0xf0, 0x0e, 0xe0, 0x1c, 0xe0, 0x38, 0xe0, 0x70, 00, 0xe0, 00, 0xc0};
#define top_left_corner_width 14
#define top_left_corner_height 14
#define top_left_corner_x_hot 0
#define top_left_corner_y_hot 0
static unsigned char top_left_corner_bits[] = {
0xff, 0xff, 0xff, 0x3f, 0x03, 00, 0x03, 00, 0x03, 00, 0xe3, 0x0f, 0x63, 00, 0xa3, 00, 0x23, 0x01, 0x23, 0x02, 0x23, 0x04, 0x23, 0x08, 0x03, 00, 0x03, 00};
#define top_left_corner_mask_width 16
#define top_left_corner_mask_height 16
#define top_left_corner_mask_x_hot 1
#define top_left_corner_mask_y_hot 1
static unsigned char top_left_corner_mask_bits[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 00, 0xef, 0x3f, 0xef, 0x3f, 0xef, 0x3f, 0xef, 0x03, 0xef, 0x07, 0xef, 0x0e, 0xef, 0x1c, 0xef, 0x38, 0xef, 0x30, 0x0f, 00, 0x0f, 00};
#define top_right_corner_width 14
#define top_right_corner_height 14
#define top_right_corner_x_hot 13
#define top_right_corner_y_hot 0
static unsigned char top_right_corner_bits[] = {
0xff, 0xff, 0xff, 0x3f, 00, 0x30, 00, 0x30, 00, 0x30, 0xfc, 0x31, 0x80, 0x31, 0x40, 0x31, 0x20, 0x31, 0x10, 0x31, 0x08, 0x31, 0x04, 0x31, 00, 0x30, 00, 0x30};
#define top_right_corner_mask_width 16
#define top_right_corner_mask_height 16
#define top_right_corner_mask_x_hot 14
#define top_right_corner_mask_y_hot 1
static unsigned char top_right_corner_mask_bits[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 00, 0xf0, 0xfc, 0xf7, 0xfc, 0xf7, 0xfc, 0xf7, 0xc0, 0xf7, 0xe0, 0xf7, 0x70, 0xf7, 0x38, 0xf7, 0x1c, 0xf7, 0x0c, 0xf7, 00, 0xf0, 00, 0xf0};
#define top_side_width 13
#define top_side_height 14
#define top_side_x_hot 6
#define top_side_y_hot 0
static unsigned char top_side_bits[] = {
0xff, 0xff, 0xff, 0x1f, 00, 00, 0x40, 00, 0xe0, 00, 0x50, 0x01, 0x48, 0x02, 0x44, 0x04, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00};
#define top_side_mask_width 15
#define top_side_mask_height 16
#define top_side_mask_x_hot 7
#define top_side_mask_y_hot 1
static unsigned char top_side_mask_bits[] = {
0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0f, 0xdc, 0x1d, 0xcc, 0x19, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01};
#define top_tee_width 14
#define top_tee_height 10
#define top_tee_x_hot 7
#define top_tee_y_hot 0
static unsigned char top_tee_bits[] = {
0xff, 0xff, 0xff, 0x3f, 0xc0, 00, 0xc0, 00, 0xc0, 00, 0xc0, 00, 0xc0, 00, 0xc0, 00, 0xc0, 00, 0xc0, 00};
#define top_tee_mask_width 16
#define top_tee_mask_height 12
#define top_tee_mask_x_hot 8
#define top_tee_mask_y_hot 1
static unsigned char top_tee_mask_bits[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03};
#define trek_width 7
#define trek_height 16
#define trek_x_hot 3
#define trek_y_hot 0
static unsigned char trek_bits[] = {
0x88, 0x80, 0x1c, 0x3e, 0x7f, 0x77, 0x7f, 0x3e, 0x1c, 0x08, 0x5d, 0x6b, 0x49, 0x41, 0x41, 0x41};
#define trek_mask_width 9
#define trek_mask_height 16
#define trek_mask_x_hot 4
#define trek_mask_y_hot 0
static unsigned char trek_mask_bits[] = {
0x38, 0x40, 0x38, 00, 0x7c, 00, 0xfe, 00, 0xff, 0x01, 0xff, 0x01, 0xff, 0x01, 0xfe, 00, 0x7c, 00, 0xba, 00, 0xff, 0x01, 0xff, 0x01, 0xff, 0x01, 0xd7, 0x01, 0xd7, 0x01, 0xc7, 0x01};
#define ul_angle_width 10
#define ul_angle_height 10
#define ul_angle_x_hot 0
#define ul_angle_y_hot 0
static unsigned char ul_angle_bits[] = {
0xff, 0xe3, 0xff, 0x03, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00};
#define ul_angle_mask_width 12
#define ul_angle_mask_height 12
#define ul_angle_mask_x_hot 1
#define ul_angle_mask_y_hot 1
static unsigned char ul_angle_mask_bits[] = {
0xff, 0x4f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00};
#define umbrella_width 14
#define umbrella_height 14
#define umbrella_x_hot 7
#define umbrella_y_hot 2
static unsigned char umbrella_bits[] = {
0x88, 0xc4, 0x20, 0x0a, 0xc9, 0x32, 0xf2, 0x09, 0x4c, 0x06, 0x43, 0x18, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 00, 0x40, 0x01, 0x40, 0x01, 0x80, 00};
#define umbrella_mask_width 16
#define umbrella_mask_height 16
#define umbrella_mask_x_hot 8
#define umbrella_mask_y_hot 2
static unsigned char umbrella_mask_bits[] = {
0xe8, 0x76, 0xfb, 0xdf, 0xfd, 0x3f, 0xfe, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xcf, 0x79, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0x80, 0x03};
#define ur_angle_width 10
#define ur_angle_height 10
#define ur_angle_x_hot 9
#define ur_angle_y_hot 0
static unsigned char ur_angle_bits[] = {
0xff, 0xe3, 0xff, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03, 00, 0x03};
#define ur_angle_mask_width 12
#define ur_angle_mask_height 12
#define ur_angle_mask_x_hot 10
#define ur_angle_mask_y_hot 1
static unsigned char ur_angle_mask_bits[] = {
0xff, 0x4f, 0xff, 0x0f, 0xff, 0x0f, 0xff, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f, 00, 0x0f};
#define watch_width 16
#define watch_height 16
#define watch_x_hot 15
#define watch_y_hot 9
static unsigned char watch_bits[] = {
0xf8, 0x07, 0xf8, 0x07, 0xf8, 0x07, 0xfc, 0x0f, 0x86, 0x18, 0x83, 0x30, 0x81, 0xe0, 0xc1, 0xe1, 0xc1, 0xe1, 0x21, 0xe0, 0x13, 0x30, 0x06, 0x18, 0xfc, 0x0f, 0xf8, 0x07, 0xf8, 0x07, 0xf8, 0x07};
#define watch_mask_width 16
#define watch_mask_height 16
#define watch_mask_x_hot 15
#define watch_mask_y_hot 9
static unsigned char watch_mask_bits[] = {
0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0xfe, 0x1f, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0x1f, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f};
#define xterm_width 7
#define xterm_height 14
#define xterm_x_hot 3
#define xterm_y_hot 7
static unsigned char xterm_bits[] = {
0xf7, 0x9c, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x1c, 0x77};
#define xterm_mask_width 9
#define xterm_mask_height 16
#define xterm_mask_x_hot 4
#define xterm_mask_y_hot 8
static unsigned char xterm_mask_bits[] = {
0xef, 0x41, 0xff, 0x01, 0xff, 0x01, 0x7c, 00, 0x38, 00, 0x38, 00, 0x38, 00, 0x38, 00, 0x38, 00, 0x38, 00, 0x38, 00, 0x38, 00, 0x7c, 00, 0xff, 0x01, 0xff, 0x01, 0xef, 0x01};

17
gdk/gdk.symbols
View File

@ -776,23 +776,6 @@ gdk_keyval_name G_GNUC_CONST
#endif
#endif
#if IN_HEADER(__GDK_KEYS_H__)
#if IN_FILE(__GDK_KEYS_DIRECTFB_C__)
gdk_keymap_get_direction
gdk_keymap_get_entries_for_keycode
gdk_keymap_get_entries_for_keyval
gdk_keymap_get_for_display
gdk_keymap_get_caps_lock_state
gdk_keymap_get_num_lock_state
gdk_keymap_lookup_key
gdk_keymap_translate_keyboard_state
gdk_keymap_add_virtual_modifiers
gdk_keymap_map_virtual_modifiers
gdk_keyval_from_name
gdk_keyval_name G_GNUC_CONST
#endif
#endif
#if IN_HEADER(__GDK_VISUAL_H__)
#if IN_FILE(__GDK_VISUAL_C__)
gdk_list_visuals

6
gtk/Makefile.am
View File

@ -821,27 +821,23 @@ gtkunixprintinclude_HEADERS = $(gtk_unix_print_public_h_sources)
libgtk_x11_3_0_la_SOURCES = $(gtk_c_sources)
libgtk_win32_3_0_la_SOURCES = $(gtk_c_sources)
libgtk_quartz_3_0_la_SOURCES = $(gtk_c_sources)
libgtk_directfb_3_0_la_SOURCES = $(gtk_c_sources)
libgtk_x11_3_0_la_LDFLAGS = $(libtool_opts)
libgtk_win32_3_0_la_LDFLAGS = $(libtool_opts) -Wl,-luuid
libgtk_quartz_3_0_la_LDFLAGS = $(libtool_opts)
libgtk_directfb_3_0_la_LDFLAGS = $(libtool_opts)
libgtk_x11_3_0_la_LIBADD = $(libadd)
libgtk_win32_3_0_la_LIBADD = $(libadd) -lole32 -lgdi32 -lcomdlg32 -lwinspool -lcomctl32
libgtk_quartz_3_0_la_LIBADD = $(libadd)
libgtk_directfb_3_0_la_LIBADD = $(libadd)
libgtk_x11_3_0_la_DEPENDENCIES = $(deps)
libgtk_win32_3_0_la_DEPENDENCIES = $(gtk_def) $(gtk_win32_res) $(deps)
libgtk_quartz_3_0_la_DEPENDENCIES = $(deps)
libgtk_directfb_3_0_la_DEPENDENCIES = $(deps)
if USE_WIN32
libgtk_target_ldflags = $(gtk_win32_res_ldflag) $(gtk_win32_symbols)
endif
EXTRA_LTLIBRARIES = libgtk-x11-3.0.la libgtk-win32-3.0.la libgtk-quartz-3.0.la libgtk-directfb-3.0.la
EXTRA_LTLIBRARIES = libgtk-x11-3.0.la libgtk-win32-3.0.la libgtk-quartz-3.0.la
install-exec-hook:
if DISABLE_EXPLICIT_DEPS

4
gtk/gtkiconfactory.c
View File

@ -1462,8 +1462,8 @@ render_icon_name_pixbuf (GtkIconSource *icon_source,
names[2] = NULL;
info = gtk_icon_theme_choose_icon (icon_theme,
names,
pixel_size, GTK_ICON_LOOKUP_USE_BUILTIN);
(const char **) names,
pixel_size, GTK_ICON_LOOKUP_USE_BUILTIN);
g_free (names[0]);
if (info)
{

14
gtk/gtkwindow-decorate.c
View File

@ -278,20 +278,6 @@ gtk_decorated_window_realize (GtkWindow *window)
font_desc = pango_font_description_from_string(DECORATION_TITLE_FONT);
pango_layout_set_font_description (deco->title_layout, font_desc);
pango_font_description_free (font_desc);
#if 0
/* What is this code exactly doing? I remember we were using the
decorated windows with the DirectFB port and it did just work,
and there was definitely no code in linux-fb involved. */
gdk_fb_window_set_child_handler (window->frame,
gtk_decorated_window_inner_change,
gtk_decorated_window_inner_get_pos,
window);
/* This is a huge hack to make frames have the same shape as
the window they wrap */
gdk_window_shape_combine_mask (window->frame, GDK_FB_USE_CHILD_SHAPE, 0, 0);
#endif
}

1
po-properties/POTFILES.in
View File

@ -1,6 +1,5 @@
# Files from the Gtk distribution which have already been
# marked to allow runtime translation of messages
gdk/directfb/gdkdisplay-directfb.c
gdk/gdk.c
gdk/gdkdisplaymanager.c
gdk/gdkpango.c

1
po/POTFILES.in
View File

@ -1,6 +1,5 @@
# Files from the Gtk distribution which have already been
# marked to allow runtime translation of messages
gdk/directfb/gdkdisplay-directfb.c
gdk/gdk.c
gdk/gdkdevice.c
gdk/gdkdevicemanager.c