static gboolean
wnck_window_timeout_cb (WnckWindow *window)
{
const gchar *game;
gint x, y;
gint width, height;
gchar *sql;
GError *error = NULL;
if (wnck_window_is_fullscreen (window))
goto exit;
game = wnck_window_get_game (window);
wnck_window_get_geometry (window, &x, &y, &width, &height);
if (wnck_window_is_maximized (window))
sql = g_strdup_printf (
"UPDATE window SET maximized = 1 "
"WHERE name = '%s'", game);
else
sql = g_strdup_printf (
"UPDATE window SET x = %d, y = %d, width = %d, "
"height = %d, maximized = 0 WHERE name = '%s'",
x, y, width, height, game);
gva_db_execute (sql, &error);
gva_error_handle (&error);
g_free (sql);
exit:
g_object_set_data (G_OBJECT (window), TIMEOUT_SOURCE_ID_KEY, NULL);
return FALSE;
}
int c_xywh(lua_State *lua)
{
int top = lua_gettop(lua);
if (top == 0) {
// Return the xywh settings of the window
WnckWindow *window = get_current_window();
if (window != NULL) {
int x, y, width, height;
wnck_window_get_geometry(window, &x, &y, &width, &height);
lua_pushnumber(lua, x);
lua_pushnumber(lua, y);
lua_pushnumber(lua, width);
lua_pushnumber(lua, height);
return 4;
}
} else if (top == 4) {
// Set the xywh settings in the window
int type1 = lua_type(lua, 1);
int type2 = lua_type(lua, 2);
int type3 = lua_type(lua, 3);
int type4 = lua_type(lua, 4);
if ((type1 != LUA_TNUMBER) ||
(type2 != LUA_TNUMBER) ||
(type3 != LUA_TNUMBER) ||
(type4 != LUA_TNUMBER)) {
luaL_error(lua, "xywh: %s", four_indata_expected_error);
return 0;
}
int x = lua_tonumber(lua, 1);
int y = lua_tonumber(lua, 2);
int xsize = lua_tonumber(lua, 3);
int ysize = lua_tonumber(lua, 4);
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
set_window_geometry(window, x, y, xsize, ysize);
}
return 0;
} else {
luaL_error(lua, "xywh: %s", four_indata_expected_error);
return 0;
}
return 0;
}
int c_center(lua_State *lua)
{
int top = lua_gettop(lua);
int workspace_width, workspace_height, window_width, window_height;
int xoffset, yoffset;
WnckScreen *screen;
WnckWorkspace *workspace;
if (top != 0) {
luaL_error(lua, "center: %s", no_indata_expected_error);
return 0;
}
WnckWindow *window = get_current_window();
if (!window) {
lua_pushboolean(lua, FALSE);
return 1;
}
wnck_window_get_geometry(window, NULL, NULL, &window_width, &window_height);
screen = wnck_window_get_screen(window);
workspace = wnck_screen_get_active_workspace(screen);
if (workspace == NULL) {
workspace = wnck_screen_get_workspace(screen,0);
}
if (workspace == NULL) {
g_printerr(_("Could not get workspace"));
lua_pushboolean(lua, FALSE);
return 1;
}
workspace_width = wnck_workspace_get_width(workspace);
workspace_height = wnck_workspace_get_height(workspace);
xoffset = (workspace_width - window_width) / 2;
yoffset = (workspace_height - window_height) / 2;
devilspie2_error_trap_push();
XMoveWindow (gdk_x11_get_default_xdisplay(),
wnck_window_get_xid(window),
xoffset, yoffset);
if (devilspie2_error_trap_pop()) {
g_printerr("center: %s", failed_string);
lua_pushboolean(lua, FALSE);
return 1;
}
lua_pushboolean(lua, TRUE);
return 1;
}
static int windowScreen(WnckWindow *window)
{
// Check the window screen
int x, y, width, height;
wnck_window_get_geometry(window, &x, &y, &width, &height);
const QRect windowRect(x, y, width, height);
const QPoint pos = windowRect.center();
return QApplication::desktop()->screenNumber(pos);
}
/**
* ww_window_center
* @win:
* @center_x:
* @center_y:
*
* Return value: The return value is written to @center_x and @center_y and
* represents the center of gravity for @win
*/
static void
ww_window_center (WnckWindow *win, int *center_x, int *center_y)
{
int x, y, w, h;
wnck_window_get_geometry (win, &x, &y, &w, &h);
*center_x = x + (w/2);
*center_y = y + (h/2);
}
int c_xy(lua_State *lua)
{
int top = lua_gettop(lua);
if (top == 0) {
// return the xy coordinates of the window
WnckWindow *window = get_current_window();
if (window != NULL) {
int x, y, width, height;
wnck_window_get_geometry(window, &x, &y, &width, &height);
lua_pushnumber(lua, x);
lua_pushnumber(lua, y);
return 2;
}
} else if (top == 2) {
// set the coordinates of the window
int type1 = lua_type(lua, 1);
int type2 = lua_type(lua, 2);
if ((type1 != LUA_TNUMBER) ||
(type2 != LUA_TNUMBER)) {
luaL_error(lua, "xy: %s", two_indata_expected_error);
return 0;
}
int x = lua_tonumber(lua, 1);
int y = lua_tonumber(lua, 2);
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_set_geometry(window,
WNCK_WINDOW_GRAVITY_CURRENT,
WNCK_WINDOW_CHANGE_X + WNCK_WINDOW_CHANGE_Y,
x, y, -1, -1);
}
}
} else {
luaL_error(lua, "xy: %s", two_indata_expected_error);
return 0;
}
return 0;
}
/**
* return the geometry of the current window to the LUA script
*/
int c_get_window_geometry(lua_State *lua)
{
int top = lua_gettop(lua);
if (top != 0) {
luaL_error(lua, "get_window_geometry: %s", no_indata_expected_error);
return 0;
}
int x, y, width, height;
WnckWindow *window = get_current_window();
if (window)
{
wnck_window_get_geometry(window, &x, &y, &width, &height);
}
lua_pushnumber(lua, x);
lua_pushnumber(lua, y);
lua_pushnumber(lua, width);
lua_pushnumber(lua, height);
return 4;
}
static void
item_activated_callback (GtkWidget *menu_item,
gpointer data)
{
WnckActionMenu *menu;
WnckWindow *window;
WindowAction action = GPOINTER_TO_INT (data);
WnckScreen *screen;
gboolean viewport_mode;
menu = get_action_menu (menu_item);
if (menu == NULL)
return;
window = menu->priv->window;
screen = wnck_window_get_screen (window);
viewport_mode = wnck_screen_get_workspace_count (screen) == 1 &&
wnck_workspace_is_virtual (wnck_screen_get_workspace (screen,
0));
switch (action)
{
case CLOSE:
/* In an activate callback, so gtk_get_current_event_time() suffices */
wnck_window_close (window,
gtk_get_current_event_time ());
break;
case MINIMIZE:
if (wnck_window_is_minimized (window))
wnck_window_unminimize (window,
gtk_get_current_event_time ());
else
wnck_window_minimize (window);
break;
case MAXIMIZE:
if (wnck_window_is_maximized (window))
wnck_window_unmaximize (window);
else
wnck_window_maximize (window);
break;
case ABOVE:
if (wnck_window_is_above (window))
wnck_window_unmake_above (window);
else
wnck_window_make_above (window);
break;
case MOVE:
wnck_window_keyboard_move (window);
break;
case RESIZE:
wnck_window_keyboard_size (window);
break;
case PIN:
if (!viewport_mode)
wnck_window_pin (window);
else
wnck_window_stick (window);
break;
case UNPIN:
if (!viewport_mode)
wnck_window_unpin (window);
else
wnck_window_unstick (window);
break;
case LEFT:
if (!viewport_mode)
{
WnckWorkspace *workspace;
workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window),
WNCK_MOTION_LEFT);
wnck_window_move_to_workspace (window, workspace);
}
else
{
int width, xw, yw, ww, hw;
width = wnck_screen_get_width (screen);
wnck_window_get_geometry (window, &xw, &yw, &ww, &hw);
wnck_window_unstick (window);
wnck_window_set_geometry (window, 0,
WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y,
xw - width, yw,
ww, hw);
}
break;
case RIGHT:
if (!viewport_mode)
{
WnckWorkspace *workspace;
workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window),
WNCK_MOTION_RIGHT);
wnck_window_move_to_workspace (window, workspace);
}
else
{
int width, xw, yw, ww, hw;
width = wnck_screen_get_width (screen);
wnck_window_get_geometry (window, &xw, &yw, &ww, &hw);
wnck_window_unstick (window);
wnck_window_set_geometry (window, 0,
WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y,
xw + width, yw,
ww, hw);
}
break;
case UP:
if (!viewport_mode)
{
WnckWorkspace *workspace;
workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window),
WNCK_MOTION_UP);
wnck_window_move_to_workspace (window, workspace);
}
else
{
int height, xw, yw, ww, hw;
height = wnck_screen_get_height (screen);
wnck_window_get_geometry (window, &xw, &yw, &ww, &hw);
wnck_window_unstick (window);
wnck_window_set_geometry (window, 0,
WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y,
xw, yw - height,
ww, hw);
}
break;
case DOWN:
if (!viewport_mode)
{
WnckWorkspace *workspace;
workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window),
WNCK_MOTION_DOWN);
wnck_window_move_to_workspace (window, workspace);
}
else
{
int height, xw, yw, ww, hw;
height = wnck_screen_get_height (screen);
wnck_window_get_geometry (window, &xw, &yw, &ww, &hw);
wnck_window_unstick (window);
wnck_window_set_geometry (window, 0,
WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y,
xw, yw + height,
ww, hw);
}
break;
case MOVE_TO_WORKSPACE:
if (!viewport_mode)
{
int workspace_index;
WnckWorkspace *workspace;
workspace_index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item),
"workspace"));
workspace = wnck_screen_get_workspace (screen, workspace_index);
wnck_window_move_to_workspace (window, workspace);
}
else
{
WnckWorkspace *workspace;
int new_viewport_x, new_viewport_y;
int width, height;
int xw, yw, ww, hw;
int viewport_x, viewport_y;
new_viewport_x = GPOINTER_TO_INT (
g_object_get_data (G_OBJECT (menu_item),
"viewport_x"));
new_viewport_y = GPOINTER_TO_INT (
g_object_get_data (G_OBJECT (menu_item),
"viewport_y"));
workspace = wnck_screen_get_workspace (screen, 0);
width = wnck_screen_get_width (screen);
height = wnck_screen_get_height (screen);
wnck_window_get_geometry (window, &xw, &yw, &ww, &hw);
viewport_x = wnck_workspace_get_viewport_x (workspace);
viewport_y = wnck_workspace_get_viewport_y (workspace);
wnck_window_unstick (window);
wnck_window_set_geometry (window, 0,
WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y,
xw + new_viewport_x - viewport_x,
yw + new_viewport_y - viewport_y,
ww, hw);
}
break;
default:
g_assert_not_reached ();
}
}
int c_set_viewport(lua_State *lua)
{
int top = lua_gettop(lua);
WnckScreen *screen;
int x,y,width,height, viewport_start;
if (top != 1) {
luaL_error(lua, "set_viewport: %s", one_indata_expected_error);
return 0;
}
int type = lua_type(lua, 1);
if (type != LUA_TNUMBER) {
luaL_error(lua, "set_viewport: %s", number_expected_as_indata_error);
return 0;
}
int num = lua_tonumber(lua,1);
if (num <= 0) {
g_error("set_viewport: %s", integer_greater_than_zero_expected_error);
lua_pushboolean(lua, FALSE);
return 1;
}
WnckWindow *window = get_current_window();
if (!window) {
lua_pushboolean(lua, FALSE);
return 1;
}
screen = wnck_window_get_screen(window);
wnck_window_get_geometry(window, &x, &y, &width, &height);
gulong xid = wnck_window_get_xid(window);
viewport_start = devilspie2_get_viewport_start(xid);
if (viewport_start < 0) {
g_printerr("set_viewport: %s", could_not_find_current_viewport_error);
lua_pushboolean(lua, FALSE);
return 1;
}
x=((num-1) * wnck_screen_get_width(screen)) - viewport_start + x;
devilspie2_error_trap_push();
XMoveResizeWindow(gdk_x11_get_default_xdisplay(),
wnck_window_get_xid(window),
x, y, width, height);
if (devilspie2_error_trap_pop()) {
g_printerr("set_viewport: %s", setting_viewport_failed_error);
lua_pushboolean(lua, FALSE);
return 1;
}
lua_pushboolean(lua, TRUE);
return 1;
}
static void
wnck_window_initialize (WnckWindow *window)
{
const gchar *game;
sqlite3_stmt *stmt;
gchar *sql;
gint errcode;
gboolean success;
GError *error = NULL;
game = wnck_window_get_game (window);
sql = g_strdup_printf (SQL_SELECT_GAME_WINDOW, game);
success = gva_db_prepare (sql, &stmt, &error);
gva_error_handle (&error);
g_free (sql);
if (!success)
return;
errcode = sqlite3_step (stmt);
/* Restore the window's previous geometry. */
if (errcode == SQLITE_ROW)
{
gint x, y;
gint width, height;
gboolean maximized;
x = sqlite3_column_int (stmt, COLUMN_X);
y = sqlite3_column_int (stmt, COLUMN_Y);
width = sqlite3_column_int (stmt, COLUMN_WIDTH);
height = sqlite3_column_int (stmt, COLUMN_HEIGHT);
maximized = sqlite3_column_int (stmt, COLUMN_MAXIMIZED);
wnck_window_set_geometry (
window, WNCK_WINDOW_GRAVITY_CURRENT,
WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y |
WNCK_WINDOW_CHANGE_WIDTH | WNCK_WINDOW_CHANGE_HEIGHT,
x, y, width, height);
if (maximized)
wnck_window_maximize (window);
else
wnck_window_unmaximize (window);
}
/* Create a new record using the current geometry. */
else if (errcode == SQLITE_DONE)
{
gint x, y;
gint width, height;
gboolean maximized;
maximized = wnck_window_is_maximized (window);
wnck_window_get_geometry (window, &x, &y, &width, &height);
sql = g_strdup_printf (
"INSERT INTO window VALUES "
"('%s', %d, %d, %d, %d, %d)",
game, x, y, width, height, maximized);
gva_db_execute (sql, &error);
gva_error_handle (&error);
g_free (sql);
}
/* Something went wrong. */
else
{
gva_db_set_error (&error, 0, NULL);
gva_error_handle (&error);
}
sqlite3_finalize (stmt);
}
/**
* ww_find_neighbour
* @screen:
* @windows:
* @active:
* @direction:
*
* Return value: The neighbouring window from @windows in the given direction
* or %NULL in case no window is found or @active is %NULL
*/
WnckWindow*
ww_find_neighbour (WnckScreen *screen,
GList *windows,
WnckWindow *active,
WwDirection direction)
{
WnckWindow *neighbour;
GList *next;
int ax, ay, aw, ah; /* active window geometry */
int wx, wy; /* geometry for currently checked window */
int nx, ny; /* geometry of neighbour */
double wdist, ndist; /* distance to active window */
neighbour = NULL;
g_return_val_if_fail (WNCK_IS_SCREEN(screen), NULL);
if (g_list_length(windows) == 0)
{
return NULL;
}
/* If there is no active window, do nothing */
if (active == NULL
|| wnck_window_is_skip_tasklist (active)) {
g_debug ("No active window");
return NULL;
}
nx = ny = 0;
ndist = 100000;
wnck_window_get_geometry (active, &ax, &ay, &aw, &ah);
g_debug("Active window '%s' (%d, %d) @ %d x %d",
wnck_window_get_name (active), ax, ay, aw, ah);
/* Set ax and ay to the center of grav. for active */
ww_window_center (active, &ax, &ay);
if ( direction == LEFT )
{
for ( next = windows; next; next = next->next )
{
ww_window_center (WNCK_WINDOW (next->data), &wx, &wy);
wdist = ww_y_weighted_distance (wx, wy, ax, ay);
if ( wx < ax )
{
if ( wdist < ndist )
{
neighbour = WNCK_WINDOW (next->data);
ndist = wdist;
}
}
}
}
else if ( direction == RIGHT )
{
for ( next = windows; next; next = next->next )
{
ww_window_center (WNCK_WINDOW (next->data), &wx, &wy);
wdist = ww_y_weighted_distance (wx, wy, ax, ay);
if ( wx > ax )
{
if ( wdist < ndist )
{
neighbour = WNCK_WINDOW (next->data);
ndist = wdist;
}
}
}
}
else if ( direction == DOWN )
{
for ( next = windows; next; next = next->next )
{
ww_window_center (WNCK_WINDOW (next->data), &wx, &wy);
wdist = ww_x_weighted_distance (wx, wy, ax, ay);
if ( wy > ay )
{
if ( wdist < ndist )
{
neighbour = WNCK_WINDOW (next->data);
ndist = wdist;
}
}
}
}
else if ( direction == UP )
{
for ( next = windows; next; next = next->next )
{
ww_window_center (WNCK_WINDOW (next->data), &wx, &wy);
wdist = ww_x_weighted_distance (wx, wy, ax, ay);
if ( wy < ay )
{
if ( wdist < ndist )
{
neighbour = WNCK_WINDOW (next->data);
ndist = wdist;
}
}
}
}
if (neighbour)
g_debug ("Found neighbour '%s'",
wnck_window_get_name (neighbour));
return neighbour;
}
/**
* ww_calc_bounds
* @screen: The screen for which to calculate the bounds
* @struts: A list of %WnckWindow<!---->s that should be treated as
* blocking elements on the desktop. Eg. panels and docks
* @x: Return value for the left side of the bounding box
* @y: Return value for the top of the box
* @right: Return coordinate for the right side of the bounding box
* @bottom: Return value for the bottom coordinate of the bounding box
*
* Calculate the maximal rect within a set of blocking windows.
* For simplicity this method assumes that all struts are along the screen
* edges and expand over the entire screen edge. Ie a standard panel setup.
*/
void
ww_calc_bounds (WnckScreen *screen,
GList *struts,
int *left,
int *top,
int *right,
int *bottom)
{
GList *next;
WnckWindow *win;
int wx, wy, ww, wh; /* current window geom */
int edge_l, edge_t, edge_b, edge_r;
int screen_w, screen_h;
edge_l = 0;
edge_t = 0;
edge_r = wnck_screen_get_width (screen);
edge_b = wnck_screen_get_height (screen);
screen_w = edge_r;
screen_h = edge_b;
for (next = struts; next; next = next->next)
{
win = WNCK_WINDOW (next->data);
wnck_window_get_geometry (win, &wx, &wy, &ww, &wh);
/* Left side strut */
if (is_high(ww, wh) && wx == 0) {
edge_l = MAX(edge_l, ww);
}
/* Top struct */
else if (is_broad(ww, wh) && wy == 0) {
edge_t = MAX (edge_t, wh);
}
/* Right side strut */
else if (is_high(ww, wh) && (wx+ww) == screen_w) {
edge_r = MIN(edge_r, wx);
}
/* Bottom struct */
else if (is_broad(ww, wh) && (wy+wh) == screen_h) {
edge_b = MIN (edge_b, wy);
}
else {
g_warning ("Desktop layout contains floating element at "
"(%d, %d)@%dx%d", wx, wy, ww, wh);
}
}
g_debug ("Calculated desktop bounds (%d, %d), (%d, %d)",
edge_l, edge_t, edge_r, edge_b);
*left = edge_l;
*top = edge_t;
*right = edge_r;
*bottom = edge_b;
}
static void
task_manager_dalog_disp_preview (TaskManagerDialog *dialog)
{
gint height;
gint width;
gint data_length;
gint win_x,win_y,win_width,win_height;
GtkAllocation allocation;
GList * iter = NULL;
gint win_count = 0;
int i = 0;
TaskManagerDialogPrivate * priv = GET_PRIVATE (dialog);
GtkPositionType pos_type = awn_applet_get_pos_type (priv->applet);
GtkOrientation current_orientation;
gdouble scale;
glong total_width = 0;
glong screen_width = gdk_screen_get_width (gdk_screen_get_default ());
glong screen_height = gdk_screen_get_height (gdk_screen_get_default ());
current_orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (priv->items_box));
if ( (current_orientation == GTK_ORIENTATION_VERTICAL) &&
(( pos_type == GTK_POS_BOTTOM) || (pos_type == GTK_POS_TOP)) )
{
gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->items_box),GTK_ORIENTATION_HORIZONTAL);
}
else if ( (current_orientation == GTK_ORIENTATION_HORIZONTAL)&&
(( pos_type == GTK_POS_LEFT) || (pos_type == GTK_POS_RIGHT)) )
{
gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->items_box),GTK_ORIENTATION_VERTICAL);
}
for (iter = g_list_first(priv->children); iter; iter=iter->next)
{
if (TASK_IS_WINDOW(iter->data))
{
win_count++;
}
}
if (priv->data)
{
g_free (priv->data);
}
data_length = win_count*6 +1;
priv->data = g_new0 (long, data_length);
priv->data[0] = (long) win_count;
scale = priv->dialog_scale;
scaled_down:
total_width = 0;
if (screen_width && screen_height)
{
for (iter = g_list_first(priv->children); iter; iter=iter->next)
{
if (TASK_IS_WINDOW(iter->data))
{
wnck_window_get_geometry (task_window_get_window (iter->data),
&win_x,
&win_y,
&win_width,
&win_height);
gtk_widget_get_allocation (GTK_WIDGET(iter->data), &allocation);
if ((pos_type == GTK_POS_TOP) || (pos_type == GTK_POS_BOTTOM))
{
/*conditional operator alert*/
height = gdk_screen_height () / (win_count?1.0/scale:1.0/scale+(win_count-2));
width = ((float)win_width) / ((float)win_height) * height;
total_width = total_width + width;
if (total_width > screen_width * 0.9)
{
scale = scale * 0.9;
goto scaled_down;
}
}
else
{
/*conditional operator alert*/
width = gdk_screen_width () / (win_count<4?1.0/scale+1:1.0/scale+1+(win_count-3));
height = ((float)win_height) / ((float)win_width) * width;
total_width = total_width + height;
if (total_width > screen_height * 0.9)
{
scale = scale * 0.9;
goto scaled_down;
}
}
}
}
}
for (iter = g_list_first(priv->children); iter; iter=iter->next)
{
if (TASK_IS_WINDOW(iter->data))
{
wnck_window_get_geometry (task_window_get_window (iter->data),
&win_x,
&win_y,
&win_width,
&win_height);
gtk_widget_get_allocation (GTK_WIDGET(iter->data), &allocation);
gtk_widget_set_tooltip_text (GTK_WIDGET (iter->data),
task_window_get_name(TASK_WINDOW(iter->data)));
/* Change these calculations. Ultimately we can be much smarter about
layout. After a certain point it will involve adding some more
containers in our container....*/
if ((pos_type == GTK_POS_TOP) || (pos_type == GTK_POS_BOTTOM))
{
/*conditional operator alert*/
height = gdk_screen_height () / (win_count?1.0/scale:1.0/scale+(win_count-2));
width = ((float)win_width) / ((float)win_height) * height;
gtk_widget_set_size_request (GTK_WIDGET(iter->data), width, height);
}
else
{
/*conditional operator alert*/
width = gdk_screen_width () / (win_count<4?1.0/scale+1:1.0/scale+1+(win_count-3));
height = ((float)win_height) / ((float)win_width) * width;
gtk_widget_set_size_request (GTK_WIDGET(iter->data), width, height);
}
priv->data[i*6+1] = (long) 5;
priv->data[i*6+2] = (long) task_window_get_xid (TASK_WINDOW(iter->data));
priv->data[i*6+3] = (long) allocation.x+4;
priv->data[i*6+4] = (long) allocation.y+4;
priv->data[i*6+5] = (long) width-8;
priv->data[i*6+6] = (long) height-8;
i++;
}
}
gdk_property_change ((GTK_WIDGET(dialog))->window,
priv->kde_a,
priv->kde_a,
32,
GDK_PROP_MODE_REPLACE,
(guchar*) priv->data,
data_length);
}
static gboolean
update_menu_state (WnckActionMenu *menu)
{
WnckActionMenuPrivate *priv;
WnckWindowActions actions;
WnckScreen *screen;
WnckWorkspace *workspace;
gboolean viewport_mode;
gboolean move_workspace_sensitive;
priv = menu->priv;
priv->idle_handler = 0;
actions = wnck_window_get_actions (priv->window);
screen = wnck_window_get_screen (priv->window);
viewport_mode = wnck_screen_get_workspace_count (screen) == 1 &&
wnck_workspace_is_virtual (wnck_screen_get_workspace (screen,
0));
move_workspace_sensitive = viewport_mode ||
(actions & WNCK_WINDOW_ACTION_CHANGE_WORKSPACE) != 0;
if (wnck_window_is_minimized (priv->window))
{
set_item_text (priv->minimize_item, _("Unmi_nimize"));
set_item_stock (priv->minimize_item, NULL);
gtk_widget_set_sensitive (priv->minimize_item,
(actions & WNCK_WINDOW_ACTION_UNMINIMIZE) != 0);
}
else
{
set_item_text (priv->minimize_item, _("Mi_nimize"));
set_item_stock (priv->minimize_item, WNCK_STOCK_MINIMIZE);
gtk_widget_set_sensitive (priv->minimize_item,
(actions & WNCK_WINDOW_ACTION_MINIMIZE) != 0);
}
if (wnck_window_is_maximized (priv->window))
{
set_item_text (priv->maximize_item, _("Unma_ximize"));
set_item_stock (priv->maximize_item, NULL);
gtk_widget_set_sensitive (priv->maximize_item,
(actions & WNCK_WINDOW_ACTION_UNMAXIMIZE) != 0);
}
else
{
set_item_text (priv->maximize_item, _("Ma_ximize"));
set_item_stock (priv->maximize_item, WNCK_STOCK_MAXIMIZE);
gtk_widget_set_sensitive (priv->maximize_item,
(actions & WNCK_WINDOW_ACTION_MAXIMIZE) != 0);
}
g_signal_handlers_block_by_func (G_OBJECT (priv->above_item),
item_activated_callback,
GINT_TO_POINTER (ABOVE));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->above_item),
wnck_window_is_above (priv->window));
g_signal_handlers_unblock_by_func (G_OBJECT (priv->above_item),
item_activated_callback,
GINT_TO_POINTER (ABOVE));
gtk_widget_set_sensitive (priv->above_item,
(actions & WNCK_WINDOW_ACTION_ABOVE) != 0);
g_signal_handlers_block_by_func (G_OBJECT (priv->pin_item),
item_activated_callback,
GINT_TO_POINTER (PIN));
g_signal_handlers_block_by_func (G_OBJECT (priv->unpin_item),
item_activated_callback,
GINT_TO_POINTER (UNPIN));
if ((viewport_mode && wnck_window_is_sticky (priv->window)) ||
(!viewport_mode && wnck_window_is_pinned (priv->window)))
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->pin_item),
TRUE);
else
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->unpin_item),
TRUE);
g_signal_handlers_unblock_by_func (G_OBJECT (priv->pin_item),
item_activated_callback,
GINT_TO_POINTER (PIN));
g_signal_handlers_unblock_by_func (G_OBJECT (priv->unpin_item),
item_activated_callback,
GINT_TO_POINTER (UNPIN));
gtk_widget_set_sensitive (priv->pin_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->unpin_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->close_item,
(actions & WNCK_WINDOW_ACTION_CLOSE) != 0);
gtk_widget_set_sensitive (priv->move_item,
(actions & WNCK_WINDOW_ACTION_MOVE) != 0);
gtk_widget_set_sensitive (priv->resize_item,
(actions & WNCK_WINDOW_ACTION_RESIZE) != 0);
gtk_widget_set_sensitive (priv->workspace_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->left_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->right_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->up_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->down_item,
move_workspace_sensitive);
workspace = wnck_window_get_workspace (priv->window);
if (viewport_mode && !wnck_window_is_sticky (priv->window))
{
int window_x, window_y;
int viewport_x, viewport_y;
int viewport_width, viewport_height;
int screen_width, screen_height;
if (!workspace)
workspace = wnck_screen_get_workspace (screen, 0);
wnck_window_get_geometry (priv->window, &window_x, &window_y, NULL, NULL);
viewport_x = wnck_workspace_get_viewport_x (workspace);
viewport_y = wnck_workspace_get_viewport_y (workspace);
window_x += viewport_x;
window_y += viewport_y;
viewport_width = wnck_workspace_get_width (workspace);
viewport_height = wnck_workspace_get_height (workspace);
screen_width = wnck_screen_get_width (screen);
screen_height = wnck_screen_get_height (screen);
if (window_x >= screen_width)
gtk_widget_show (priv->left_item);
else
gtk_widget_hide (priv->left_item);
if (window_x < viewport_width - screen_width)
gtk_widget_show (priv->right_item);
else
gtk_widget_hide (priv->right_item);
if (window_y >= screen_height)
gtk_widget_show (priv->up_item);
else
gtk_widget_hide (priv->up_item);
if (window_y < viewport_height - screen_height)
gtk_widget_show (priv->down_item);
else
gtk_widget_hide (priv->down_item);
}
else if (!viewport_mode && workspace && !wnck_window_is_pinned (priv->window))
{
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_LEFT))
gtk_widget_show (priv->left_item);
else
gtk_widget_hide (priv->left_item);
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_RIGHT))
gtk_widget_show (priv->right_item);
else
gtk_widget_hide (priv->right_item);
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_UP))
gtk_widget_show (priv->up_item);
else
gtk_widget_hide (priv->up_item);
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_DOWN))
gtk_widget_show (priv->down_item);
else
gtk_widget_hide (priv->down_item);
}
else
{
gtk_widget_hide (priv->left_item);
gtk_widget_hide (priv->right_item);
gtk_widget_hide (priv->up_item);
gtk_widget_hide (priv->down_item);
}
if (viewport_mode)
{
int viewport_width, viewport_height;
int screen_width, screen_height;
viewport_width = wnck_workspace_get_width (workspace);
viewport_height = wnck_workspace_get_height (workspace);
screen_width = wnck_screen_get_width (screen);
screen_height = wnck_screen_get_height (screen);
gtk_widget_show (priv->workspace_separator);
gtk_widget_show (priv->pin_item);
gtk_widget_show (priv->unpin_item);
if (viewport_width >= 2 * screen_width ||
viewport_height >= 2 * screen_height)
{
gtk_widget_show (priv->workspace_item);
refill_submenu_viewport (menu);
}
else
{
gtk_widget_hide (priv->workspace_item);
gtk_menu_popdown (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (priv->workspace_item))));
}
}
else if (wnck_screen_get_workspace_count (screen) > 1)
{
gtk_widget_show (priv->workspace_separator);
gtk_widget_show (priv->pin_item);
gtk_widget_show (priv->unpin_item);
gtk_widget_show (priv->workspace_item);
refill_submenu_workspace (menu);
}
else
{
gtk_widget_hide (priv->workspace_separator);
gtk_widget_hide (priv->pin_item);
gtk_widget_hide (priv->unpin_item);
gtk_widget_hide (priv->workspace_item);
gtk_menu_popdown (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (priv->workspace_item))));
}
gtk_menu_reposition (GTK_MENU (menu));
return FALSE;
}
static gboolean
on_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
GdkGC *gc;
XTransform transform;
double scale;
int wx, wy, ww, wh;
int frame_left, frame_right, frame_top, frame_bottom;
int thumbnail_width, thumbnail_height;
int offset_x, offset_y;
SSWindow *window;
SSThumbnailer *thumbnailer;
Display *display;
display = gdk_x11_get_default_xdisplay ();
thumbnailer = (SSThumbnailer *) data;
window = thumbnailer->window;
if (thumbnailer->thumbnail_pixmap == NULL) {
initialize_thumbnailer_pictures (thumbnailer);
}
gc = gdk_gc_new (thumbnailer->thumbnail_pixmap);
ss_xinerama_get_frame_extents (
// TODO - should we cut out the ->workspace in the line below?
window->workspace->screen->xinerama, window,
&frame_left, &frame_right, &frame_top, &frame_bottom);
wnck_window_get_geometry (window->wnck_window, &wx, &wy, &ww, &wh);
scale = ww > wh ? ww : wh;
scale /= (double) THUMBNAIL_SIZE;
thumbnail_width = thumbnail_height = THUMBNAIL_SIZE;
if (ww > wh) {
thumbnail_height = wh * THUMBNAIL_SIZE / ww;
} else {
thumbnail_width = ww * THUMBNAIL_SIZE / wh;
}
transform.matrix[0][0] = XDoubleToFixed (scale);
transform.matrix[0][1] = XDoubleToFixed (0.0);
transform.matrix[0][2] = XDoubleToFixed (-frame_left * (scale - 1.0));
transform.matrix[1][0] = XDoubleToFixed (0.0);
transform.matrix[1][1] = XDoubleToFixed (scale);
transform.matrix[1][2] = XDoubleToFixed (-frame_top * (scale - 1.0));
transform.matrix[2][0] = XDoubleToFixed (0.0);
transform.matrix[2][1] = XDoubleToFixed (0.0);
transform.matrix[2][2] = XDoubleToFixed (1.0);
XRenderSetPictureTransform (display, thumbnailer->window_picture,
&transform);
XRenderComposite (display, PictOpSrc,
thumbnailer->window_picture, None, thumbnailer->thumbnail_picture,
0, 0, 0, 0, 0, 0, THUMBNAIL_SIZE, THUMBNAIL_SIZE);
offset_x = widget->allocation.x + (THUMBNAIL_SIZE - thumbnail_width) / 2;
offset_y = widget->allocation.y + (THUMBNAIL_SIZE - thumbnail_height) / 2;
gdk_draw_drawable (thumbnailer->drawing_area->window, gc,
thumbnailer->thumbnail_pixmap, 0, 0,
offset_x, offset_y, thumbnail_width, thumbnail_height);
gdk_draw_rectangle (thumbnailer->drawing_area->window,
thumbnailer->drawing_area->style->black_gc, FALSE,
offset_x, offset_y, thumbnail_width - 1, thumbnail_height - 1);
g_object_unref (gc);
return FALSE;
}
static void
refill_submenu_viewport (WnckActionMenu *menu)
{
GtkWidget *submenu;
GList *children;
GList *l;
WnckScreen *screen;
WnckWorkspace *workspace;
int window_x, window_y;
int viewport_x, viewport_y;
int viewport_width, viewport_height;
int screen_width, screen_height;
int x, y;
int number;
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu->priv->workspace_item));
/* Remove existing items */
children = gtk_container_get_children (GTK_CONTAINER (submenu));
for (l = children; l; l = l->next)
gtk_container_remove (GTK_CONTAINER (submenu), l->data);
g_list_free (children);
screen = wnck_window_get_screen (menu->priv->window);
workspace = wnck_screen_get_workspace (screen, 0);
wnck_window_get_geometry (menu->priv->window,
&window_x, &window_y, NULL, NULL);
viewport_x = wnck_workspace_get_viewport_x (workspace);
viewport_y = wnck_workspace_get_viewport_y (workspace);
window_x += viewport_x;
window_y += viewport_y;
viewport_width = wnck_workspace_get_width (workspace);
viewport_height = wnck_workspace_get_height (workspace);
screen_width = wnck_screen_get_width (screen);
screen_height = wnck_screen_get_height (screen);
number = 1;
for (y = 0; y < viewport_height; y += screen_height)
{
char *label;
GtkWidget *item;
for (x = 0; x < viewport_width; x += screen_width)
{
/* Keep this in sync with what is in get_workspace_name_with_accel()
*/
if (number == 10)
label = g_strdup_printf (_("Workspace 1_0"));
else
label = g_strdup_printf (_("Workspace %s%d"),
number < 10 ? "_" : "",
number);
number++;
item = make_menu_item (MOVE_TO_WORKSPACE);
g_object_set_data (G_OBJECT (item), "viewport_x",
GINT_TO_POINTER (x));
g_object_set_data (G_OBJECT (item), "viewport_y",
GINT_TO_POINTER (y));
if (window_x >= x && window_x < x + screen_width &&
window_y >= y && window_y < y + screen_height)
gtk_widget_set_sensitive (item, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
set_item_text (item, label);
set_item_stock (item, NULL);
g_free (label);
}
}
gtk_menu_reposition (GTK_MENU (submenu));
}
static gboolean
on_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
SSWorkspace *workspace;
int screen_width, screen_height;
double width_ratio, height_ratio;
int x, y, w, h;
int viewport_x;
GList *i;
SSWindow *active_window;
WnckWindow *wnck_window;
int state;
GdkRectangle r;
workspace = (SSWorkspace *) data;
screen_width = workspace->screen->screen_width;
screen_height = workspace->screen->screen_height;
active_window = workspace->screen->active_window;
x = widget->allocation.x;
y = widget->allocation.y;
w = widget->allocation.width;
h = widget->allocation.height;
state = (workspace == workspace->screen->active_workspace) ? GTK_STATE_SELECTED : GTK_STATE_NORMAL;
gdk_draw_rectangle (widget->window,
widget->style->dark_gc[state], TRUE,
1, 1, w-2, h-2);
gdk_draw_rectangle (widget->window,
widget->style->base_gc[state], FALSE,
0, 0, w-1, h-1);
width_ratio = (double) w / (double) screen_width;
height_ratio = (double) h / (double) screen_height;
viewport_x = 0;
if (window_manager_uses_viewports) {
viewport_x = wnck_workspace_get_viewport_x (workspace->wnck_workspace);
}
for (i = workspace->screen->wnck_windows_in_stacking_order; i; i = i->next) {
wnck_window = (WnckWindow *) i->data;
if (wnck_window_get_workspace (wnck_window) != workspace->wnck_workspace) {
continue;
}
if (wnck_window_is_minimized (wnck_window)) {
continue;
}
state = GTK_STATE_ACTIVE;
if ((active_window != NULL) &&
((wnck_window_get_xid (wnck_window) == wnck_window_get_xid (active_window->wnck_window)))) {
state = GTK_STATE_SELECTED;
}
wnck_window_get_geometry (wnck_window, &r.x, &r.y, &r.width, &r.height);
if (window_manager_uses_viewports) {
r.x += viewport_x - (workspace->viewport * workspace->screen->screen_width);
}
r.x = 0.5 + r.x * width_ratio;
r.y = 0.5 + r.y * height_ratio;
r.width = 0.5 + r.width * width_ratio;
r.height = 0.5 + r.height * height_ratio;
if (r.width < 3) {
r.width = 3;
}
if (r.height < 3) {
r.height = 3;
}
gdk_draw_rectangle (widget->window,
widget->style->bg_gc[state], TRUE,
r.x+1, r.y+1, r.width-2, r.height-2);
gdk_draw_rectangle (widget->window,
widget->style->fg_gc[state], FALSE,
r.x, r.y, r.width-1, r.height-1);
}
on_expose_event_draw_text (widget, workspace);
return FALSE;
}
