gtk2/gdk/gdkwindowimpl.h

294 lines
14 KiB
C
Raw Normal View History

/* 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
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* 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/.
*/
#ifndef __GDK_WINDOW_IMPL_H__
#define __GDK_WINDOW_IMPL_H__
#include <gdk/gdkwindow.h>
#include <gdk/gdkproperty.h>
G_BEGIN_DECLS
#define GDK_TYPE_WINDOW_IMPL (gdk_window_impl_get_type ())
#define GDK_WINDOW_IMPL(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW_IMPL, GdkWindowImpl))
#define GDK_WINDOW_IMPL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_IMPL, GdkWindowImplClass))
#define GDK_IS_WINDOW_IMPL(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW_IMPL))
#define GDK_IS_WINDOW_IMPL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_IMPL))
#define GDK_WINDOW_IMPL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW_IMPL, GdkWindowImplClass))
typedef struct _GdkWindowImpl GdkWindowImpl;
typedef struct _GdkWindowImplClass GdkWindowImplClass;
struct _GdkWindowImpl
{
GObject parent;
};
struct _GdkWindowImplClass
{
GObjectClass parent_class;
cairo_surface_t *
(* ref_cairo_surface) (GdkWindow *window);
cairo_surface_t *
(* create_similar_image_surface) (GdkWindow * window,
cairo_format_t format,
int width,
int height);
void (* show) (GdkWindow *window,
gboolean already_mapped);
void (* hide) (GdkWindow *window);
void (* withdraw) (GdkWindow *window);
void (* raise) (GdkWindow *window);
void (* lower) (GdkWindow *window);
void (* restack_toplevel) (GdkWindow *window,
GdkWindow *sibling,
gboolean above);
void (* move_resize) (GdkWindow *window,
gboolean with_move,
gint x,
gint y,
gint width,
gint height);
void (* move_to_rect) (GdkWindow *window,
const GdkRectangle *rect,
GdkGravity rect_anchor,
GdkGravity window_anchor,
GdkAnchorHints anchor_hints,
gint rect_anchor_dx,
gint rect_anchor_dy);
GdkEventMask (* get_events) (GdkWindow *window);
void (* set_events) (GdkWindow *window,
GdkEventMask event_mask);
2010-05-25 22:38:44 +00:00
void (* set_device_cursor) (GdkWindow *window,
GdkDevice *device,
GdkCursor *cursor);
void (* get_geometry) (GdkWindow *window,
gint *x,
gint *y,
gint *width,
gint *height);
void (* get_root_coords) (GdkWindow *window,
gint x,
gint y,
gint *root_x,
gint *root_y);
2010-05-25 22:38:44 +00:00
gboolean (* get_device_state) (GdkWindow *window,
GdkDevice *device,
gdouble *x,
gdouble *y,
2010-05-25 22:38:44 +00:00
GdkModifierType *mask);
gboolean (* begin_paint) (GdkWindow *window);
void (* end_paint) (GdkWindow *window);
void (* shape_combine_region) (GdkWindow *window,
const cairo_region_t *shape_region,
gint offset_x,
gint offset_y);
2008-12-17 10:24:46 +00:00
void (* input_shape_combine_region) (GdkWindow *window,
const cairo_region_t *shape_region,
2008-12-17 10:24:46 +00:00
gint offset_x,
gint offset_y);
/* Called before processing updates for a window. This gives the windowing
* layer a chance to save the region for later use in avoiding duplicate
* exposes.
*/
void (* queue_antiexpose) (GdkWindow *window,
cairo_region_t *update_area);
/* Called to do the windowing system specific part of gdk_window_destroy(),
*
* window: The window being destroyed
* recursing: If TRUE, then this is being called because a parent
* was destroyed. This generally means that the call to the windowing
* system to destroy the window can be omitted, since it will be
* destroyed as a result of the parent being destroyed.
* Unless @foreign_destroy
* foreign_destroy: If TRUE, the window or a parent was destroyed by some
* external agency. The window has already been destroyed and no
* windowing system calls should be made. (This may never happen
* for some windowing systems.)
*/
void (* destroy) (GdkWindow *window,
gboolean recursing,
gboolean foreign_destroy);
2010-12-11 02:55:41 +00:00
/* optional */
gboolean (* beep) (GdkWindow *window);
void (* focus) (GdkWindow *window,
guint32 timestamp);
void (* set_type_hint) (GdkWindow *window,
GdkWindowTypeHint hint);
GdkWindowTypeHint (* get_type_hint) (GdkWindow *window);
void (* set_modal_hint) (GdkWindow *window,
gboolean modal);
void (* set_skip_taskbar_hint) (GdkWindow *window,
gboolean skips_taskbar);
void (* set_skip_pager_hint) (GdkWindow *window,
gboolean skips_pager);
void (* set_urgency_hint) (GdkWindow *window,
gboolean urgent);
void (* set_geometry_hints) (GdkWindow *window,
const GdkGeometry *geometry,
GdkWindowHints geom_mask);
void (* set_title) (GdkWindow *window,
const gchar *title);
void (* set_role) (GdkWindow *window,
const gchar *role);
void (* set_startup_id) (GdkWindow *window,
const gchar *startup_id);
void (* set_transient_for) (GdkWindow *window,
GdkWindow *parent);
void (* get_frame_extents) (GdkWindow *window,
GdkRectangle *rect);
void (* set_accept_focus) (GdkWindow *window,
gboolean accept_focus);
void (* set_focus_on_map) (GdkWindow *window,
gboolean focus_on_map);
void (* set_icon_list) (GdkWindow *window,
GList *pixbufs);
void (* set_icon_name) (GdkWindow *window,
const gchar *name);
void (* iconify) (GdkWindow *window);
void (* deiconify) (GdkWindow *window);
void (* stick) (GdkWindow *window);
void (* unstick) (GdkWindow *window);
void (* maximize) (GdkWindow *window);
void (* unmaximize) (GdkWindow *window);
void (* fullscreen) (GdkWindow *window);
void (* fullscreen_on_monitor) (GdkWindow *window, gint monitor);
void (* apply_fullscreen_mode) (GdkWindow *window);
void (* unfullscreen) (GdkWindow *window);
void (* set_keep_above) (GdkWindow *window,
gboolean setting);
void (* set_keep_below) (GdkWindow *window,
gboolean setting);
GdkWindow * (* get_group) (GdkWindow *window);
void (* set_group) (GdkWindow *window,
GdkWindow *leader);
void (* set_decorations) (GdkWindow *window,
GdkWMDecoration decorations);
gboolean (* get_decorations) (GdkWindow *window,
GdkWMDecoration *decorations);
void (* set_functions) (GdkWindow *window,
GdkWMFunction functions);
void (* begin_resize_drag) (GdkWindow *window,
GdkWindowEdge edge,
GdkDevice *device,
gint button,
gint root_x,
gint root_y,
guint32 timestamp);
void (* begin_move_drag) (GdkWindow *window,
GdkDevice *device,
gint button,
gint root_x,
gint root_y,
guint32 timestamp);
void (* enable_synchronized_configure) (GdkWindow *window);
void (* configure_finished) (GdkWindow *window);
void (* set_opacity) (GdkWindow *window,
gdouble opacity);
void (* destroy_notify) (GdkWindow *window);
GdkDragProtocol (* get_drag_protocol) (GdkWindow *window,
GdkWindow **target);
void (* register_dnd) (GdkWindow *window);
GdkDragContext * (*drag_begin) (GdkWindow *window,
GdkDevice *device,
GList *targets,
gint x_root,
gint y_root);
void (*process_updates_recurse) (GdkWindow *window,
cairo_region_t *region);
2010-12-16 06:21:49 +00:00
void (*sync_rendering) (GdkWindow *window);
gboolean (*simulate_key) (GdkWindow *window,
gint x,
gint y,
guint keyval,
GdkModifierType modifiers,
GdkEventType event_type);
gboolean (*simulate_button) (GdkWindow *window,
gint x,
gint y,
guint button,
GdkModifierType modifiers,
GdkEventType event_type);
gboolean (*get_property) (GdkWindow *window,
GdkAtom property,
GdkAtom type,
gulong offset,
gulong length,
gint pdelete,
GdkAtom *actual_type,
gint *actual_format,
gint *actual_length,
guchar **data);
void (*change_property) (GdkWindow *window,
GdkAtom property,
GdkAtom type,
gint format,
GdkPropMode mode,
const guchar *data,
gint n_elements);
void (*delete_property) (GdkWindow *window,
GdkAtom property);
gint (* get_scale_factor) (GdkWindow *window);
void (* get_unscaled_size) (GdkWindow *window,
int *unscaled_width,
int *unscaled_height);
void (* set_opaque_region) (GdkWindow *window,
cairo_region_t *region);
void (* set_shadow_width) (GdkWindow *window,
gint left,
gint right,
gint top,
gint bottom);
gboolean (* show_window_menu) (GdkWindow *window,
GdkEvent *event);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
GdkGLContext *(*create_gl_context) (GdkWindow *window,
gboolean attached,
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
GdkGLContext *share,
GError **error);
};
/* Interface Functions */
GType gdk_window_impl_get_type (void) G_GNUC_CONST;
G_END_DECLS
#endif /* __GDK_WINDOW_IMPL_H__ */