#endif

rect->height = expand_to->height;

}

/* Run over all struts */

for (strut_iter = all_struts; strut_iter; strut_iter = strut_iter->next)

{

return overlaps;

}

void

meta_rectangle_clamp_to_fit_into_region (const GList *spanning_rects,

FixedDirections fixed_directions,

meta_workspace_get_onxinerama_region (cur_workspace,

xinerama_info->number);

/* Log all this information for debugging */

meta_topic (META_DEBUG_GEOMETRY,

"Setting up constraint info:\n"

meta_workspace_get_onxinerama_region (cur_workspace,

xinerama_info->number);

info->current.x = placed_rect.x;

info->current.y = placed_rect.y;

window);

}

void

meta_window_kill (MetaWindow *window)

{

typedef void (*MetaWindowPingFunc) (MetaDisplay* display, Window xwindow, guint32 timestamp, gpointer user_data);

#define _NET_WM_STATE_REMOVE 0 /* remove/unset property */

#define _NET_WM_STATE_ADD 1 /* add/set property */

#define _NET_WM_STATE_TOGGLE 2 /* toggle property */

g_slist_free (dead);

}

#ifdef HAVE_STARTUP_NOTIFICATION

static void

sn_error_trap_push (SnDisplay *sn_display,

meta_verbose ("Not compiled with Xsync support\n");

#endif /* !HAVE_XSYNC */

#ifdef HAVE_SHAPE

{

the_display->have_shape = FALSE;

window = NULL;

}

frame_was_receiver = FALSE;

if (window &&

window->frame &&

event->xselectionclear.window,

event->xselectionclear.selection);

if (screen != NULL)

{

meta_verbose ("Got selection clear for screen %d on display %s\n",

run_handler (effect);

}

/* old ugly minimization effect */

#ifdef HAVE_SHAPE

box_width = text_width + 2 * LINE_WIDTH;

box_height = text_height + 2 * LINE_WIDTH;

box_x = shrunk_rect.x + (shrunk_rect.width - box_width) / 2;

box_y = shrunk_rect.y + (shrunk_rect.height - box_height) / 2;

#endif

frame->rect.x, frame->rect.y,

frame->rect.width, frame->rect.height);

frame->xwindow = meta_ui_create_frame_window (window->screen->ui,

window->display->xdisplay,

window->xvisual,

meta_window_queue (window, META_QUEUE_MOVE_RESIZE);

}

MetaFrameFlags

meta_frame_get_flags (MetaFrame *frame)

{

#endif

static MetaGroupPropHooks* find_hooks (MetaDisplay *display,

Atom property);

void

meta_group_reload_property (MetaGroup *group,

Atom property)

#endif

#endif

}

}

static int

count_bindings (const MetaKeyPref *prefs,

int n_prefs)

* even when only the keymap changes */

reload_modmap (display);

if (keymap_changed)

reload_keycodes (display);

}

}

void

meta_display_init_keys (MetaDisplay *display)

{

return retval;

}

static void

handle_run_command (MetaDisplay *display,

MetaScreen *screen,

}

}

static void

handle_maximize_vertically (MetaDisplay *display,

MetaScreen *screen,

window->rect.height);

}

static void

handle_move_to_monitor (MetaDisplay *display,

MetaScreen *screen,

"Ending grab so we can focus on the target workspace\n");

meta_display_end_grab_op (display, event->xkey.time);

if(display->grab_op == META_GRAB_OP_KEYBOARD_WORKSPACE_SWITCHING)

{

meta_topic (META_DEBUG_KEYBINDINGS,

event->xkey.time);

}

return TRUE; /* we already ended the grab */

}

}

backwards, FALSE);

}

static void

handle_toggle_fullscreen (MetaDisplay *display,

MetaScreen *screen,

return FALSE;

}

if (cond & G_IO_ERR )

{

meta_warning ("handle_rename_workspace_callback: error. G_IO_ERR.\n");

return FALSE;

}

meta_topic (META_DEBUG_KEYBINDINGS, "handle_rename_workspace_callback: workspace_index=%d\n", *workspace_index);

if (*workspace_index < 0 || *workspace_index > 36)

{

return FALSE;

}

if (cond & (!G_IO_IN & !G_IO_PRI))

{

meta_warning ("handle_rename_workspace_callback: unknown error\n");

#define ARROW_DOWN 116

#define ARROW_DOWN_PAD 88

#include "display-private.h"

#include "window.h"

#endif

meta_prefs_init ();

meta_prefs_add_listener (prefs_changed_callback, NULL);

#if 1

for (i=0; i<G_N_ELEMENTS(log_domains); i++)

used in advertising or otherwise to promote the sale, use or other dealings

in this Software without prior written authorization from The Open Group.

Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.

All Rights Reserved

#define UNSIGNEDINT unsigned long

#define RESOURCEID unsigned long

/* this structure may be extended, but do not change the order */

typedef struct {

UNSIGNEDINT flags;

#define OldNumPropStandardColormapElements 8 /* pre-ICCCM */

#define NumPropStandardColormapElements 10 /* ICCCM version 1 */

/* this structure may be extended, but do not change the order */

typedef struct {

UNSIGNEDINT flags;

{

MetaIntPreference *cursor = preferences_int;

while (cursor->key!=NULL)

{

gint value;

}

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

/* Listeners. */

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

changed_idle_handler, NULL, NULL);

}

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

/* Initialisation. */

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

const MetaXineramaScreenInfo* meta_screen_get_xinerama_for_window (MetaScreen *screen,

MetaWindow *window);

const MetaXineramaScreenInfo* meta_screen_get_xinerama_neighbor (MetaScreen *screen,

int which_xinerama,

MetaScreenDirection dir);

"Marco compiled without Solaris Xinerama support\n");

#endif /* HAVE_SOLARIS_XINERAMA */

/* If no Xinerama, fill in the single screen info so

* we can use the field unconditionally

*/

if (screen->work_area_idle != 0)

g_source_remove (screen->work_area_idle);

if (XGetGCValues (screen->display->xdisplay,

screen->root_xor_gc,

GCFont,

}

}

static char*

get_screen_name (MetaDisplay *display,

int number)

}

}

#ifdef WITH_VERBOSE_MODE

static char *

meta_screen_corner_to_string (MetaScreenCorner corner)

* in the above grids could be missing

*/

grid = g_new (int, grid_area);

i = 0;

windows = windows->next;

}

meta_screen_update_showing_desktop_hint (screen);

}

meta_screen_update_showing_desktop_hint (screen);

}

#ifdef HAVE_STARTUP_NOTIFICATION

static gboolean startup_sequence_timeout (void *data);

save_yourself_possibly_done (shutdown, successful);

}

static void

die_callback (SmcConn smc_conn, SmPointer client_data)

{

}

prop3.num_vals = i;

props[0] = &prop1;

props[1] = &prop2;

props[2] = &prop3;

&error))

goto error;

error = NULL;

if (!g_markup_parse_context_end_parse (context, &error))

goto error;

void meta_session_init (const char *client_id,

const char *save_file);

void meta_session_shutdown (void);

#endif

}

}

#define ELAPSED(start_time, current_time) \

(((((double)current_time.tv_sec - start_time.tv_sec) * 1000000 + \

(current_time.tv_usec - start_time.tv_usec))) / 1000.0)

}

argvl[i] = NULL;

unsetenv ("WINDOWID"); /* start in current workspace */

g_spawn_async_with_pipes (

"/",

int h,

int gravity);

/* Return whether the window would be showing if we were on its workspace */

gboolean meta_window_showing_on_its_workspace (MetaWindow *window);

Atom atom,

guint32 timestamp);

void meta_window_move_resize_request(MetaWindow *window,

guint value_mask,

int gravity,

void *data);

MetaWindow* meta_window_find_root_ancestor (MetaWindow *window);

void meta_window_begin_grab_op (MetaWindow *window,

MetaGrabOp op,

gboolean frame_action,

static MetaWindowPropHooks* find_hooks (MetaDisplay *display,

Atom property);

void

meta_window_reload_property (MetaWindow *window,

Atom property,

NoEventMask);

}

/* Obtain the new NET_WM_USER_TIME_WINDOW and register it */

window->user_time_window = value->v.xwindow;

if (window->user_time_window != None)

Atom property,

gboolean initial);

/**

* Requests the current values of a set of properties for a given

* window from the server, and deals with them appropriately.

static int destroying_windows_disallowed = 0;

static void update_sm_hints (MetaWindow *window);

static void update_net_frame_extents (MetaWindow *window);

static void recalc_window_type (MetaWindow *window);

static void ensure_mru_position_after (MetaWindow *window,

MetaWindow *after_this_one);

static void meta_window_move_resize_now (MetaWindow *window);

static void meta_window_unqueue (MetaWindow *window, guint queuebits);

const MetaRectangle *from_monitor,

const MetaRectangle *to_monitor);

static gboolean update_resize_timeout (gpointer data);

static void meta_window_flush_calc_showing (MetaWindow *window);

static gboolean queue_calc_showing_func (MetaWindow *window,

return NULL;

}

meta_error_trap_pop (display, FALSE);

meta_display_ungrab (display);

meta_display_register_x_window (display, &window->xwindow, window);

/* assign the window to its group, or create a new group if needed

*/

window->group = NULL;

meta_display_unregister_x_window (window->display, window->xwindow);

meta_error_trap_push (window->display);

/* Put back anything we messed up */

else

meta_window_save_rect(window);

window->tiled = TRUE;

/* move_resize with new tiling constraints

*/

meta_compositor_unmaximize_window (window->display->compositor, window);

}

void

meta_window_move_to_monitor(MetaWindow *window,

const MetaXineramaScreenInfo *from_monitor,

}

void

meta_window_make_above (MetaWindow *window)

{

new_y = old.y;

}

/* Do any edge resistance/snapping */

meta_window_edge_resistance_for_move (window,

old.x,

meta_window_move (window, TRUE, new_x, new_y);

}

static MetaTileMode calculate_tiling_mode(int x,

int y,

MetaWindow *window,

}

static gboolean

update_resize_timeout (gpointer data)

{

"focus window may not be correct.\n");

}

if (meta_prefs_get_focus_mode () == META_FOCUS_MODE_CLICK ||

!workspace->screen->display->mouse_mode)

focus_ancestor_or_top_window (workspace, not_this_one, timestamp);

void meta_workspace_invalidate_work_area (MetaWorkspace *workspace);

void meta_workspace_get_work_area_for_xinerama (MetaWorkspace *workspace,

int which_xinerama,

MetaRectangle *area);

#endif

*/

#include <config.h>

#include "xprops.h"

#include "errors.h"