Lerking/gtk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removed GdkScreen from gdk_pango_get_gc

Browse Source 
removed all the move resize data from GdkDisplay put it into local variable in and attached it to
GdkDisplay Object.
This commit is contained in:
Erwann Chenede
2001-06-13 21:51:38 +00:00
parent 8ba19314c6
commit 845b1f3211
10 changed files with 160 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
gdk/gdkcolor.h
View File

@@ -63,8 +63,9 @@ GdkColormap* gdk_colormap_new (GdkVisual *visual,
gboolean allocate);
GdkColormap* gdk_colormap_ref (GdkColormap *cmap);
void gdk_colormap_unref (GdkColormap *cmap);
#ifndef GDK_MULTIHEAD_SAFE
GdkColormap* gdk_colormap_get_system (void);
#endif
gint gdk_colormap_get_system_size (void);
GdkColormap* gdk_colormap_get_system_for_screen (GdkScreen * screen);

2
gdk/gdkcursor.h
View File

@@ -26,7 +26,9 @@ struct _GdkCursor
*/
GdkCursor* gdk_cursor_new_for_screen (GdkScreen * screen,
GdkCursorType cursor_type);
#ifndef GDK_MULTIHEAD_SAFE
GdkCursor* gdk_cursor_new (GdkCursorType cursor_type);
#endif
GdkCursor* gdk_cursor_new_from_pixmap (GdkPixmap *source,
GdkPixmap *mask,
GdkColor *fg,

16
gdk/gdkpango.c
View File

@@ -77,8 +77,7 @@ gdk_pango_context_get_info (PangoContext *context, gboolean create)
}
static GdkGC *
gdk_pango_get_gc (GdkScreen *screen,
PangoContext *context,
gdk_pango_get_gc (PangoContext *context,
PangoColor *fg_color,
GdkBitmap *stipple,
GdkGC *base_gc)
@@ -86,9 +85,12 @@ gdk_pango_get_gc (GdkScreen *screen,
GdkGC *result;
GdkPangoContextInfo *info;
GdkWindow *root_window;
GdkScreen *screen;
g_return_val_if_fail (context != NULL, NULL);
screen = g_object_get_data (G_OBJECT (context), "gdk-screen");
info = gdk_pango_context_get_info (context, FALSE);
if (info == NULL || info->colormap == NULL)
@@ -97,7 +99,7 @@ gdk_pango_get_gc (GdkScreen *screen,
return NULL;
}
root_window = GDK_SCREEN_GET_CLASS (screen)->get_root_window (screen);
root_window = gdk_screen_get_root_window (screen);
result = gdk_gc_new (root_window);
gdk_gc_copy (result, base_gc);
@@ -243,7 +245,7 @@ gdk_draw_layout_line_with_colors (GdkDrawable *drawable,
tmp.green = background->green;
}
bg_gc = gdk_pango_get_gc (screen, context, &tmp, stipple, gc);
bg_gc = gdk_pango_get_gc (context, &tmp, stipple, gc);
gdk_draw_rectangle (drawable, bg_gc, TRUE,
x + (x_off + logical_rect.x) / PANGO_SCALE,
@@ -268,8 +270,7 @@ gdk_draw_layout_line_with_colors (GdkDrawable *drawable,
tmp.green = foreground->green;
}
fg_gc = gdk_pango_get_gc (screen,
context,
fg_gc = gdk_pango_get_gc (context,
fg_set ? &tmp : NULL,
stipple, gc);
}
@@ -286,8 +287,7 @@ gdk_draw_layout_line_with_colors (GdkDrawable *drawable,
if (embossed)
{
PangoColor color = { 65535, 65535, 65535 };
GdkGC *white_gc = gdk_pango_get_gc (screen,
context,
GdkGC *white_gc = gdk_pango_get_gc (context,
&color,
stipple,
fg_gc);

2
gdk/gdkpango.h
View File

@@ -35,7 +35,9 @@ extern "C" {
* A colormap is not sufficient.
*/
PangoContext *gdk_pango_context_get_for_screen (GdkScreen * screen);
#ifndef GDK_MULTIHEAD_SAFE
PangoContext *gdk_pango_context_get (void);
#endif
void gdk_pango_context_set_colormap (PangoContext *context,
GdkColormap *colormap);

2
gdk/gdkpixbuf.h
View File

@@ -45,10 +45,12 @@ void gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf,
GdkRgbDither dither,
int x_dither,
int y_dither);
#ifndef GDK_MULTIHEAD_SAFE
void gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf,
GdkPixmap **pixmap_return,
GdkBitmap **mask_return,
int alpha_threshold);
#endif
void gdk_pixbuf_render_pixmap_and_mask_for_screen (GdkPixbuf *pixbuf,
GdkScreen *screen,
GdkPixmap **pixmap_return,

9
gdk/gdkrgb.h
View File

@@ -128,17 +128,20 @@ void gdk_rgb_cmap_free (GdkRgbCmap *cmap);
/* Below are some functions which are primarily useful for debugging
and experimentation. */
gboolean gdk_rgb_ditherable (void);
gboolean gdk_rgb_ditherable_for_screen (GdkScreen *screen);
void gdk_rgb_set_verbose (gboolean verbose);
/* experimental colormap stuff */
void gdk_rgb_set_install (gboolean install);
void gdk_rgb_set_min_colors (gint min_colors);
#ifndef GDK_MULTIHEAD_SAFE
GdkColormap *gdk_rgb_get_colormap (void);
GdkColormap *gdk_rgb_get_colormap_for_screen (GdkScreen *screen);
gboolean gdk_rgb_ditherable (void);
GdkVisual * gdk_rgb_get_visual (void);
#endif
gboolean gdk_rgb_ditherable_for_screen (GdkScreen *screen);
GdkColormap *gdk_rgb_get_colormap_for_screen (GdkScreen *screen);
GdkVisual * gdk_rgb_get_visual_for_screen (GdkScreen *screen);
#ifdef __cplusplus

19
gdk/x11/gdkdisplay-x11.h
View File

@@ -112,25 +112,8 @@ extern "C"
GList **motif_target_lists;
gint motif_n_target_lists;
/* data needed for _NET_WM_MOVERESIZE spec impl */
GdkWindow *_gdk_moveresize_window;
GdkWindow *moveresize_emulation_window;
gboolean is_resize;
GdkWindowEdge resize_edge;
gint moveresize_button;
gint moveresize_x;
gint moveresize_y;
gint moveresize_orig_x;
gint moveresize_orig_y;
gint moveresize_orig_width;
gint moveresize_orig_height;
GdkWindowHints moveresize_geom_mask;
GdkGeometry moveresize_geometry;
Time moveresize_process_time;
XEvent *moveresize_pending_event;
/* Misc Settings */
XSettingsClient *xsettings_client;
};

4
gdk/x11/gdkevents-x11.c
View File

@@ -501,7 +501,7 @@ gdk_event_translate (GdkEvent *event,
if (window != NULL)
gdk_window_ref (window);
if (dpy_impl->_gdk_moveresize_window &&
if (g_object_get_data (G_OBJECT(dpy), "moveresize_window") &&
(xevent->xany.type == MotionNotify ||
xevent->xany.type == ButtonRelease))
{
@@ -1321,7 +1321,7 @@ gdk_event_translate (GdkEvent *event,
window_private->resize_count -= 1;
if (window_private->resize_count == 0 &&
window == dpy_impl->_gdk_moveresize_window)
window == g_object_get_data (G_OBJECT(dpy), "moveresize_window"))
_gdk_moveresize_configure_done_for_display (dpy);
}
}

7
gdk/x11/gdkpango-x11.c
View File

@@ -32,6 +32,7 @@
PangoContext *
gdk_pango_context_get_for_screen (GdkScreen * screen)
{
PangoContext *context;
#ifdef HAVE_XFT
static gint use_xft = -1;
if (use_xft == -1) {
@@ -41,11 +42,13 @@ gdk_pango_context_get_for_screen (GdkScreen * screen)
}
if (use_xft)
return pango_xft_get_context (GDK_SCREEN_XDISPLAY (screen),
context = pango_xft_get_context (GDK_SCREEN_XDISPLAY (screen),
GDK_SCREEN_IMPL_X11 (screen)->scr_num);
else
#endif /* HAVE_XFT */
return pango_x_get_context (GDK_SCREEN_XDISPLAY (screen));
context = pango_x_get_context (GDK_SCREEN_XDISPLAY (screen));
g_object_set_data (G_OBJECT (context), "gdk-screen", screen);
return context;
}
PangoContext *

203
gdk/x11/gdkwindow-x11.c
View File

@@ -3529,6 +3529,24 @@ wmspec_moveresize (GdkWindow *window,
&xev);
}
typedef struct {
GdkWindow *_gdk_moveresize_window;
GdkWindow *moveresize_emulation_window;
gboolean is_resize;
GdkWindowEdge resize_edge;
gint moveresize_button;
gint moveresize_x;
gint moveresize_y;
gint moveresize_orig_x;
gint moveresize_orig_y;
gint moveresize_orig_width;
gint moveresize_orig_height;
GdkWindowHints moveresize_geom_mask;
GdkGeometry moveresize_geometry;
Time moveresize_process_time;
XEvent *moveresize_pending_event;
} _MoveResizeData;
/* From the WM spec */
#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT 0
#define _NET_WM_MOVERESIZE_SIZE_TOP 1
@@ -3603,19 +3621,21 @@ update_pos_for_display (GdkDisplay *display,
gint new_root_y)
{
gint dx, dy;
GdkDisplayImplX11 * dpy = GDK_DISPLAY_IMPL_X11 (display);
_MoveResizeData * mv_resize = NULL;
mv_resize = g_object_get_data (G_OBJECT (display), "moveresize");
g_assert (mv_resize != NULL);
dx = new_root_x - dpy->moveresize_x;
dy = new_root_y - dpy->moveresize_y;
dx = new_root_x - mv_resize->moveresize_x;
dy = new_root_y - mv_resize->moveresize_y;
if (dpy->is_resize)
if (mv_resize->is_resize)
{
gint w, h;
w = dpy->moveresize_orig_width;
h = dpy->moveresize_orig_height;
w = mv_resize->moveresize_orig_width;
h = mv_resize->moveresize_orig_height;
switch (dpy->resize_edge)
switch (mv_resize->resize_edge)
{
case GDK_WINDOW_EDGE_SOUTH_EAST:
w += dx;
@@ -3628,39 +3648,42 @@ update_pos_for_display (GdkDisplay *display,
w = MAX (w, 1);
h = MAX (h, 1);
if (dpy->moveresize_geom_mask)
if (mv_resize->moveresize_geom_mask)
{
gdk_window_constrain_size (&dpy->moveresize_geometry,
dpy->moveresize_geom_mask,
gdk_window_constrain_size (&mv_resize->moveresize_geometry,
mv_resize->moveresize_geom_mask,
w, h,
&w, &h);
}
gdk_window_resize (dpy->_gdk_moveresize_window, w, h);
gdk_window_resize (mv_resize->_gdk_moveresize_window, w, h);
}
else
{
gint x, y;
x = dpy->moveresize_orig_x + dx;
y = dpy->moveresize_orig_y + dy;
x = mv_resize->moveresize_orig_x + dx;
y = mv_resize->moveresize_orig_y + dy;
gdk_window_move (dpy->_gdk_moveresize_window, x, y);
gdk_window_move (mv_resize->_gdk_moveresize_window, x, y);
}
}
static void
finish_drag_for_display (GdkDisplay *display)
{
GdkDisplayImplX11 * dpy = GDK_DISPLAY_IMPL_X11 (display);
gdk_window_destroy (dpy->moveresize_emulation_window);
dpy->moveresize_emulation_window = NULL;
dpy->_gdk_moveresize_window = NULL;
_MoveResizeData * mv_resize = NULL;
mv_resize = g_object_steal_data (G_OBJECT (display), "moveresize");
g_object_steal_data (G_OBJECT (display), "moveresize_window");
g_assert (mv_resize != NULL);
gdk_window_destroy (mv_resize->moveresize_emulation_window);
mv_resize->moveresize_emulation_window = NULL;
mv_resize->_gdk_moveresize_window = NULL;
if (dpy->moveresize_pending_event)
if (mv_resize->moveresize_pending_event)
{
g_free (dpy->moveresize_pending_event);
dpy->moveresize_pending_event = NULL;
g_free (mv_resize->moveresize_pending_event);
mv_resize->moveresize_pending_event = NULL;
}
}
@@ -3669,9 +3692,12 @@ lookahead_motion_predicate (Display *display,
XEvent *event,
XPointer arg)
{
GdkDisplayImplX11 *dpy = gdk_lookup_xdisplay (display);
gboolean *seen_release = (gboolean *)arg;
_MoveResizeData * mv_resize = NULL;
GdkDisplayImplX11 *dpy = gdk_lookup_xdisplay (display);
mv_resize = g_object_get_data (G_OBJECT (dpy), "moveresize");
g_assert (mv_resize != NULL);
if (*seen_release)
return False;
@@ -3682,7 +3708,7 @@ lookahead_motion_predicate (Display *display,
*seen_release = TRUE;
break;
case MotionNotify:
dpy->moveresize_process_time = event->xmotion.time;
mv_resize->moveresize_process_time = event->xmotion.time;
break;
default:
break;
@@ -3696,13 +3722,16 @@ moveresize_lookahead (XEvent *event)
{
XEvent tmp_event;
gboolean seen_release = FALSE;
_MoveResizeData * mv_resize = NULL;
GdkDisplayImplX11 *dpy = gdk_lookup_xdisplay (event->xany.display);
mv_resize = g_object_get_data (G_OBJECT (dpy), "moveresize");
g_assert (mv_resize != NULL);
if (dpy->moveresize_process_time)
if (mv_resize->moveresize_process_time)
{
if (event->xmotion.time == dpy->moveresize_process_time)
if (event->xmotion.time == mv_resize->moveresize_process_time)
{
dpy->moveresize_process_time = 0;
mv_resize->moveresize_process_time = 0;
return TRUE;
}
else
@@ -3712,27 +3741,32 @@ moveresize_lookahead (XEvent *event)
XCheckIfEvent (dpy->xdisplay, &tmp_event,
lookahead_motion_predicate, (XPointer)&seen_release);
return dpy->moveresize_process_time == 0;
return mv_resize->moveresize_process_time == 0;
}
void
_gdk_moveresize_handle_event (XEvent *event)
{
guint button_mask = 0;
_MoveResizeData * mv_resize = NULL;
GdkWindowObject *window_private;
GdkDisplayImplX11 *dpy = gdk_lookup_xdisplay (event->xany.display);
GdkWindowObject *window_private = (GdkWindowObject *) dpy->_gdk_moveresize_window;
mv_resize = g_object_get_data (G_OBJECT (dpy), "moveresize");
g_assert (mv_resize != NULL);
button_mask = GDK_BUTTON1_MASK << (dpy->moveresize_button - 1);
window_private = (GdkWindowObject *) mv_resize->_gdk_moveresize_window;
button_mask = GDK_BUTTON1_MASK << (mv_resize->moveresize_button - 1);
switch (event->xany.type)
{
case MotionNotify:
if (window_private->resize_count > 0)
{
if (dpy->moveresize_pending_event)
*dpy->moveresize_pending_event = *event;
if (mv_resize->moveresize_pending_event)
*mv_resize->moveresize_pending_event = *event;
else
dpy->moveresize_pending_event = g_memdup (event, sizeof (XEvent));
mv_resize->moveresize_pending_event = g_memdup (event, sizeof (XEvent));
break;
}
@@ -3756,7 +3790,7 @@ _gdk_moveresize_handle_event (XEvent *event)
update_pos_for_display ((GdkDisplay*)dpy, event->xbutton.x_root,
event->xbutton.y_root);
if (event->xbutton.button == dpy->moveresize_button)
if (event->xbutton.button == mv_resize->moveresize_button)
finish_drag_for_display ((GdkDisplay*)dpy);
break;
}
@@ -3766,12 +3800,14 @@ void
_gdk_moveresize_configure_done_for_display (GdkDisplay *dpy)
{
XEvent *tmp_event;
GdkDisplayImplX11 * dpy_impl = GDK_DISPLAY_IMPL_X11 (dpy);
_MoveResizeData * mv_resize = NULL;
mv_resize = g_object_get_data (G_OBJECT (dpy), "moveresize");
g_assert (mv_resize != NULL);
if (dpy_impl->moveresize_pending_event)
if (mv_resize->moveresize_pending_event)
{
tmp_event = dpy_impl->moveresize_pending_event;
dpy_impl->moveresize_pending_event = NULL;
tmp_event = mv_resize->moveresize_pending_event;
mv_resize->moveresize_pending_event = NULL;
_gdk_moveresize_handle_event (tmp_event);
g_free (tmp_event);
}
@@ -3783,10 +3819,11 @@ create_moveresize_window_for_screen (GdkScreen *scr, guint32 timestamp)
GdkWindowAttr attributes;
gint attributes_mask;
GdkGrabStatus status;
GdkScreenImplX11 *scr_impl = GDK_SCREEN_IMPL_X11 (scr);
GdkDisplayImplX11 *dpy_impl = GDK_DISPLAY_IMPL_X11 (scr_impl->display);
g_assert (dpy_impl->moveresize_emulation_window == NULL);
_MoveResizeData * mv_resize = NULL;
mv_resize = g_object_get_data (G_OBJECT (gdk_screen_get_display (scr)),
"moveresize");
g_assert (mv_resize != NULL);
g_assert (mv_resize->moveresize_emulation_window == NULL);
attributes.x = -100;
attributes.y = -100;
@@ -3799,12 +3836,12 @@ create_moveresize_window_for_screen (GdkScreen *scr, guint32 timestamp)
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_NOREDIR;
dpy_impl->moveresize_emulation_window =
mv_resize->moveresize_emulation_window =
gdk_window_new_for_screen (scr, NULL, &attributes, attributes_mask);
gdk_window_show (dpy_impl->moveresize_emulation_window);
gdk_window_show (mv_resize->moveresize_emulation_window);
status = gdk_pointer_grab (dpy_impl->moveresize_emulation_window,
status = gdk_pointer_grab (mv_resize->moveresize_emulation_window,
FALSE,
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
@@ -3817,11 +3854,11 @@ create_moveresize_window_for_screen (GdkScreen *scr, guint32 timestamp)
/* If this fails, some other client has grabbed the window
* already.
*/
gdk_window_destroy (dpy_impl->moveresize_emulation_window);
dpy_impl->moveresize_emulation_window = NULL;
gdk_window_destroy (mv_resize->moveresize_emulation_window);
mv_resize->moveresize_emulation_window = NULL;
}
dpy_impl->moveresize_process_time = 0;
mv_resize->moveresize_process_time = 0;
}
static void
@@ -3832,22 +3869,25 @@ emulate_resize_drag (GdkWindow *window,
gint root_y,
guint32 timestamp)
{
GdkDisplayImplX11 * dpy = GDK_DISPLAY_IMPL_X11 (GDK_WINDOW_DISPLAY (window));
dpy->is_resize = TRUE;
dpy->moveresize_button = button;
dpy->resize_edge = edge;
dpy->moveresize_x = root_x;
dpy->moveresize_y = root_y;
dpy->_gdk_moveresize_window = GDK_WINDOW (g_object_ref (G_OBJECT (window)));
_MoveResizeData * mv_resize = NULL;
mv_resize = g_object_get_data (G_OBJECT (GDK_WINDOW_DISPLAY (window)),
"moveresize");
g_assert (mv_resize != NULL);
mv_resize->is_resize = TRUE;
mv_resize->moveresize_button = button;
mv_resize->resize_edge = edge;
mv_resize->moveresize_x = root_x;
mv_resize->moveresize_y = root_y;
mv_resize->_gdk_moveresize_window = GDK_WINDOW (g_object_ref (G_OBJECT (window)));
gdk_window_get_size (window,
&dpy->moveresize_orig_width,
&dpy->moveresize_orig_height);
&mv_resize->moveresize_orig_width,
&mv_resize->moveresize_orig_height);
dpy->moveresize_geom_mask = 0;
mv_resize->moveresize_geom_mask = 0;
gdk_window_get_geometry_hints (window,
&dpy->moveresize_geometry,
&dpy->moveresize_geom_mask);
&mv_resize->moveresize_geometry,
&mv_resize->moveresize_geom_mask);
create_moveresize_window_for_screen (GDK_WINDOW_SCREEN(window), timestamp);
}
@@ -3859,17 +3899,20 @@ emulate_move_drag (GdkWindow *window,
gint root_y,
guint32 timestamp)
{
GdkDisplayImplX11 * dpy = GDK_DISPLAY_IMPL_X11 (GDK_WINDOW_DISPLAY (window));
dpy->is_resize = FALSE;
dpy->moveresize_button = button;
dpy->moveresize_x = root_x;
dpy->moveresize_y = root_y;
_MoveResizeData * mv_resize = NULL;
mv_resize = g_object_get_data (G_OBJECT (GDK_WINDOW_DISPLAY (window)),
"moveresize");
g_assert (mv_resize != NULL);
mv_resize->is_resize = FALSE;
mv_resize->moveresize_button = button;
mv_resize->moveresize_x = root_x;
mv_resize->moveresize_y = root_y;
dpy->_gdk_moveresize_window = GDK_WINDOW (g_object_ref (G_OBJECT (window)));
mv_resize->_gdk_moveresize_window = GDK_WINDOW (g_object_ref (G_OBJECT (window)));
gdk_window_get_deskrelative_origin (dpy->_gdk_moveresize_window,
&dpy->moveresize_orig_x,
&dpy->moveresize_orig_y);
gdk_window_get_deskrelative_origin (mv_resize->_gdk_moveresize_window,
&mv_resize->moveresize_orig_x,
&mv_resize->moveresize_orig_y);
create_moveresize_window_for_screen (GDK_WINDOW_SCREEN(window), timestamp);
}
@@ -3882,13 +3925,20 @@ gdk_window_begin_resize_drag (GdkWindow *window,
gint root_y,
guint32 timestamp)
{
GdkDisplayImplX11 * dpy = GDK_DISPLAY_IMPL_X11 (GDK_WINDOW_DISPLAY (window));
_MoveResizeData * moveresize;
g_return_if_fail (GDK_IS_WINDOW (window));
g_return_if_fail (dpy->moveresize_emulation_window == NULL);
if (GDK_WINDOW_DESTROYED (window))
return;
moveresize = g_new0 (_MoveResizeData, 1);
g_object_set_data (G_OBJECT (GDK_WINDOW_DISPLAY (window)),
"moveresize",
moveresize);
g_object_set_data (G_OBJECT (GDK_WINDOW_DISPLAY (window)),
"moveresize_window",
moveresize->_gdk_moveresize_window);
if (gdk_net_wm_supports_for_screen (GDK_WINDOW_SCREEN(window),
gdk_display_atom (GDK_WINDOW_DISPLAY(window), "_NET_WM_MOVERESIZE", FALSE)))
wmspec_resize_drag (window, edge, button, root_x, root_y, timestamp);
@@ -3903,12 +3953,19 @@ gdk_window_begin_move_drag (GdkWindow *window,
gint root_y,
guint32 timestamp)
{
GdkDisplayImplX11 * dpy = GDK_DISPLAY_IMPL_X11 (GDK_WINDOW_DISPLAY (window));
_MoveResizeData * moveresize;
g_return_if_fail (GDK_IS_WINDOW (window));
g_return_if_fail (dpy->moveresize_emulation_window == NULL);
if (GDK_WINDOW_DESTROYED (window))
return;
moveresize = g_new0 (_MoveResizeData, 1);
g_object_set_data (G_OBJECT (GDK_WINDOW_DISPLAY (window)),
"moveresize",
moveresize);
g_object_set_data (G_OBJECT (GDK_WINDOW_DISPLAY (window)),
"moveresize_window",
moveresize->_gdk_moveresize_window);
if (gdk_net_wm_supports_for_screen (GDK_WINDOW_SCREEN(window),
gdk_display_atom (GDK_WINDOW_DISPLAY(window), "_NET_WM_MOVERESIZE", FALSE)))