X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fscreen.c;h=8012942beb65a09ebfe0c88d32cab8010995edce;hb=acafa38c8ea210b12ed92fc16281b915ab61542c;hp=5201f78a1d27a9da1c3c2faeb77f82290f896a49;hpb=d5a25283dceb4b0eb7f1dcba1ac15674f6422fbe;p=chaz%2Fopenbox diff --git a/openbox/screen.c b/openbox/screen.c index 5201f78a..8012942b 100644 --- a/openbox/screen.c +++ b/openbox/screen.c @@ -20,13 +20,10 @@ #include "debug.h" #include "openbox.h" #include "dock.h" -#include "xerror.h" -#include "prop.h" #include "grab.h" #include "startupnotify.h" #include "moveresize.h" #include "config.h" -#include "mainloop.h" #include "screen.h" #include "client.h" #include "session.h" @@ -34,9 +31,11 @@ #include "event.h" #include "focus.h" #include "popup.h" -#include "extensions.h" #include "render/render.h" #include "gettext.h" +#include "obt/display.h" +#include "obt/prop.h" +#include "obt/mainloop.h" #include #ifdef HAVE_UNISTD_H @@ -56,20 +55,20 @@ static gboolean replace_wm(void); static void screen_tell_ksplash(void); static void screen_fallback_focus(void); -guint screen_num_desktops; -guint screen_num_monitors; -guint screen_desktop; -guint screen_last_desktop; -gboolean screen_showing_desktop; +guint screen_num_desktops; +guint screen_num_monitors; +guint screen_desktop; +guint screen_last_desktop; +gboolean screen_showing_desktop; ObDesktopLayout screen_desktop_layout; -gchar **screen_desktop_names; -Window screen_support_win; -Time screen_desktop_user_time = CurrentTime; +gchar **screen_desktop_names; +Window screen_support_win; +Time screen_desktop_user_time = CurrentTime; static Size screen_physical_size; static guint screen_old_desktop; static gboolean screen_desktop_timeout = TRUE; -/*! An array of desktops, holding array of areas per monitor */ +/*! An array of desktops, holding an array of areas per monitor */ static Rect *monitor_area = NULL; /*! An array of desktops, holding an array of struts */ static GSList *struts_top = NULL; @@ -91,10 +90,10 @@ static gboolean replace_wm(void) Time timestamp; wm_sn = g_strdup_printf("WM_S%d", ob_screen); - wm_sn_atom = XInternAtom(ob_display, wm_sn, FALSE); + wm_sn_atom = XInternAtom(obt_display, wm_sn, FALSE); g_free(wm_sn); - current_wm_sn_owner = XGetSelectionOwner(ob_display, wm_sn_atom); + current_wm_sn_owner = XGetSelectionOwner(obt_display, wm_sn_atom); if (current_wm_sn_owner == screen_support_win) current_wm_sn_owner = None; if (current_wm_sn_owner) { @@ -103,24 +102,23 @@ static gboolean replace_wm(void) ob_screen); return FALSE; } - xerror_set_ignore(TRUE); - xerror_occured = FALSE; + obt_display_ignore_errors(TRUE); /* We want to find out when the current selection owner dies */ - XSelectInput(ob_display, current_wm_sn_owner, StructureNotifyMask); - XSync(ob_display, FALSE); + XSelectInput(obt_display, current_wm_sn_owner, StructureNotifyMask); + XSync(obt_display, FALSE); - xerror_set_ignore(FALSE); - if (xerror_occured) + obt_display_ignore_errors(FALSE); + if (obt_display_error_occured) current_wm_sn_owner = None; } timestamp = event_get_server_time(); - XSetSelectionOwner(ob_display, wm_sn_atom, screen_support_win, + XSetSelectionOwner(obt_display, wm_sn_atom, screen_support_win, timestamp); - if (XGetSelectionOwner(ob_display, wm_sn_atom) != screen_support_win) { + if (XGetSelectionOwner(obt_display, wm_sn_atom) != screen_support_win) { g_message(_("Could not acquire window manager selection on screen %d"), ob_screen); return FALSE; @@ -133,7 +131,7 @@ static gboolean replace_wm(void) const gulong timeout = G_USEC_PER_SEC * 15; /* wait for 15s max */ while (wait < timeout) { - if (XCheckWindowEvent(ob_display, current_wm_sn_owner, + if (XCheckWindowEvent(obt_display, current_wm_sn_owner, StructureNotifyMask, &event) && event.type == DestroyNotify) break; @@ -148,9 +146,9 @@ static gboolean replace_wm(void) } /* Send client message indicating that we are now the WM */ - prop_message(RootWindow(ob_display, ob_screen), prop_atoms.manager, - timestamp, wm_sn_atom, screen_support_win, 0, - SubstructureNotifyMask); + obt_prop_message(ob_screen, obt_root(ob_screen), OBT_PROP_ATOM(MANAGER), + timestamp, wm_sn_atom, screen_support_win, 0, 0, + SubstructureNotifyMask); return TRUE; } @@ -160,37 +158,33 @@ gboolean screen_annex(void) XSetWindowAttributes attrib; pid_t pid; gint i, num_support; - Atom *prop_atoms_start, *wm_supported_pos; gulong *supported; /* create the netwm support window */ attrib.override_redirect = TRUE; attrib.event_mask = PropertyChangeMask; - screen_support_win = XCreateWindow(ob_display, - RootWindow(ob_display, ob_screen), + screen_support_win = XCreateWindow(obt_display, obt_root(ob_screen), -100, -100, 1, 1, 0, CopyFromParent, InputOutput, CopyFromParent, CWEventMask | CWOverrideRedirect, &attrib); - XMapWindow(ob_display, screen_support_win); - XLowerWindow(ob_display, screen_support_win); + XMapWindow(obt_display, screen_support_win); + XLowerWindow(obt_display, screen_support_win); if (!replace_wm()) { - XDestroyWindow(ob_display, screen_support_win); + XDestroyWindow(obt_display, screen_support_win); return FALSE; } - xerror_set_ignore(TRUE); - xerror_occured = FALSE; - XSelectInput(ob_display, RootWindow(ob_display, ob_screen), - ROOT_EVENTMASK); - xerror_set_ignore(FALSE); - if (xerror_occured) { + obt_display_ignore_errors(TRUE); + XSelectInput(obt_display, obt_root(ob_screen), ROOT_EVENTMASK); + obt_display_ignore_errors(FALSE); + if (obt_display_error_occured) { g_message(_("A window manager is already running on screen %d"), ob_screen); - XDestroyWindow(ob_display, screen_support_win); + XDestroyWindow(obt_display, screen_support_win); return FALSE; } @@ -198,114 +192,113 @@ gboolean screen_annex(void) /* set the OPENBOX_PID hint */ pid = getpid(); - PROP_SET32(RootWindow(ob_display, ob_screen), - openbox_pid, cardinal, pid); + OBT_PROP_SET32(obt_root(ob_screen), OPENBOX_PID, CARDINAL, pid); /* set supporting window */ - PROP_SET32(RootWindow(ob_display, ob_screen), - net_supporting_wm_check, window, screen_support_win); + OBT_PROP_SET32(obt_root(ob_screen), + NET_SUPPORTING_WM_CHECK, WINDOW, screen_support_win); /* set properties on the supporting window */ - PROP_SETS(screen_support_win, net_wm_name, "Openbox"); - PROP_SET32(screen_support_win, net_supporting_wm_check, - window, screen_support_win); + OBT_PROP_SETS(screen_support_win, NET_WM_NAME, utf8, "Openbox"); + OBT_PROP_SET32(screen_support_win, NET_SUPPORTING_WM_CHECK, + WINDOW, screen_support_win); /* set the _NET_SUPPORTED_ATOMS hint */ - /* this is all the atoms after net_supported in the prop_atoms struct */ - prop_atoms_start = (Atom*)&prop_atoms; - wm_supported_pos = (Atom*)&(prop_atoms.net_supported); - num_support = sizeof(prop_atoms) / sizeof(Atom) - - (wm_supported_pos - prop_atoms_start) - 1; + /* this is all the atoms after NET_SUPPORTED in the ObtPropAtoms enum */ + num_support = OBT_PROP_NUM_ATOMS - OBT_PROP_NET_SUPPORTED - 1; i = 0; supported = g_new(gulong, num_support); - supported[i++] = prop_atoms.net_supporting_wm_check; - supported[i++] = prop_atoms.net_wm_full_placement; - supported[i++] = prop_atoms.net_current_desktop; - supported[i++] = prop_atoms.net_number_of_desktops; - supported[i++] = prop_atoms.net_desktop_geometry; - supported[i++] = prop_atoms.net_desktop_viewport; - supported[i++] = prop_atoms.net_active_window; - supported[i++] = prop_atoms.net_workarea; - supported[i++] = prop_atoms.net_client_list; - supported[i++] = prop_atoms.net_client_list_stacking; - supported[i++] = prop_atoms.net_desktop_names; - supported[i++] = prop_atoms.net_close_window; - supported[i++] = prop_atoms.net_desktop_layout; - supported[i++] = prop_atoms.net_showing_desktop; - supported[i++] = prop_atoms.net_wm_name; - supported[i++] = prop_atoms.net_wm_visible_name; - supported[i++] = prop_atoms.net_wm_icon_name; - supported[i++] = prop_atoms.net_wm_visible_icon_name; - supported[i++] = prop_atoms.net_wm_desktop; - supported[i++] = prop_atoms.net_wm_strut; - supported[i++] = prop_atoms.net_wm_strut_partial; - supported[i++] = prop_atoms.net_wm_icon; - supported[i++] = prop_atoms.net_wm_icon_geometry; - supported[i++] = prop_atoms.net_wm_window_type; - supported[i++] = prop_atoms.net_wm_window_type_desktop; - supported[i++] = prop_atoms.net_wm_window_type_dock; - supported[i++] = prop_atoms.net_wm_window_type_toolbar; - supported[i++] = prop_atoms.net_wm_window_type_menu; - supported[i++] = prop_atoms.net_wm_window_type_utility; - supported[i++] = prop_atoms.net_wm_window_type_splash; - supported[i++] = prop_atoms.net_wm_window_type_dialog; - supported[i++] = prop_atoms.net_wm_window_type_normal; - supported[i++] = prop_atoms.net_wm_allowed_actions; - supported[i++] = prop_atoms.net_wm_action_move; - supported[i++] = prop_atoms.net_wm_action_resize; - supported[i++] = prop_atoms.net_wm_action_minimize; - supported[i++] = prop_atoms.net_wm_action_shade; - supported[i++] = prop_atoms.net_wm_action_maximize_horz; - supported[i++] = prop_atoms.net_wm_action_maximize_vert; - supported[i++] = prop_atoms.net_wm_action_fullscreen; - supported[i++] = prop_atoms.net_wm_action_change_desktop; - supported[i++] = prop_atoms.net_wm_action_close; - supported[i++] = prop_atoms.net_wm_action_above; - supported[i++] = prop_atoms.net_wm_action_below; - supported[i++] = prop_atoms.net_wm_state; - supported[i++] = prop_atoms.net_wm_state_modal; - supported[i++] = prop_atoms.net_wm_state_maximized_vert; - supported[i++] = prop_atoms.net_wm_state_maximized_horz; - supported[i++] = prop_atoms.net_wm_state_shaded; - supported[i++] = prop_atoms.net_wm_state_skip_taskbar; - supported[i++] = prop_atoms.net_wm_state_skip_pager; - supported[i++] = prop_atoms.net_wm_state_hidden; - supported[i++] = prop_atoms.net_wm_state_fullscreen; - supported[i++] = prop_atoms.net_wm_state_above; - supported[i++] = prop_atoms.net_wm_state_below; - supported[i++] = prop_atoms.net_wm_state_demands_attention; - supported[i++] = prop_atoms.net_moveresize_window; - supported[i++] = prop_atoms.net_wm_moveresize; - supported[i++] = prop_atoms.net_wm_user_time; + supported[i++] = OBT_PROP_ATOM(NET_SUPPORTING_WM_CHECK); + supported[i++] = OBT_PROP_ATOM(NET_WM_FULL_PLACEMENT); + supported[i++] = OBT_PROP_ATOM(NET_CURRENT_DESKTOP); + supported[i++] = OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS); + supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_GEOMETRY); + supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_VIEWPORT); + supported[i++] = OBT_PROP_ATOM(NET_ACTIVE_WINDOW); + supported[i++] = OBT_PROP_ATOM(NET_WORKAREA); + supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST); + supported[i++] = OBT_PROP_ATOM(NET_CLIENT_LIST_STACKING); + supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_NAMES); + supported[i++] = OBT_PROP_ATOM(NET_CLOSE_WINDOW); + supported[i++] = OBT_PROP_ATOM(NET_DESKTOP_LAYOUT); + supported[i++] = OBT_PROP_ATOM(NET_SHOWING_DESKTOP); + supported[i++] = OBT_PROP_ATOM(NET_WM_NAME); + supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_NAME); + supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_NAME); + supported[i++] = OBT_PROP_ATOM(NET_WM_VISIBLE_ICON_NAME); + supported[i++] = OBT_PROP_ATOM(NET_WM_DESKTOP); + supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT); + supported[i++] = OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL); + supported[i++] = OBT_PROP_ATOM(NET_WM_ICON); + supported[i++] = OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DESKTOP); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DOCK); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_TOOLBAR); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_MENU); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_UTILITY); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_SPLASH); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_DIALOG); + supported[i++] = OBT_PROP_ATOM(NET_WM_WINDOW_TYPE_NORMAL); + supported[i++] = OBT_PROP_ATOM(NET_WM_ALLOWED_ACTIONS); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MOVE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_RESIZE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MINIMIZE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_SHADE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_HORZ); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_MAXIMIZE_VERT); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_FULLSCREEN); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CHANGE_DESKTOP); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_CLOSE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_ABOVE); + supported[i++] = OBT_PROP_ATOM(NET_WM_ACTION_BELOW); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MODAL); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_VERT); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_MAXIMIZED_HORZ); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SHADED); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_TASKBAR); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_SKIP_PAGER); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_HIDDEN); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_FULLSCREEN); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_ABOVE); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_BELOW); + supported[i++] = OBT_PROP_ATOM(NET_WM_STATE_DEMANDS_ATTENTION); + supported[i++] = OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW); + supported[i++] = OBT_PROP_ATOM(NET_WM_MOVERESIZE); + supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME); /* - supported[i++] = prop_atoms.net_wm_user_time_window; + supported[i++] = OBT_PROP_ATOM(NET_WM_USER_TIME_WINDOW); */ - supported[i++] = prop_atoms.net_frame_extents; - supported[i++] = prop_atoms.net_request_frame_extents; - supported[i++] = prop_atoms.net_restack_window; - supported[i++] = prop_atoms.net_startup_id; + supported[i++] = OBT_PROP_ATOM(NET_FRAME_EXTENTS); + supported[i++] = OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS); + supported[i++] = OBT_PROP_ATOM(NET_RESTACK_WINDOW); + supported[i++] = OBT_PROP_ATOM(NET_STARTUP_ID); #ifdef SYNC - supported[i++] = prop_atoms.net_wm_sync_request; - supported[i++] = prop_atoms.net_wm_sync_request_counter; + supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST); + supported[i++] = OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER); #endif - supported[i++] = prop_atoms.net_wm_pid; - supported[i++] = prop_atoms.net_wm_ping; - - supported[i++] = prop_atoms.kde_wm_change_state; - supported[i++] = prop_atoms.kde_net_wm_frame_strut; - supported[i++] = prop_atoms.kde_net_wm_window_type_override; - - supported[i++] = prop_atoms.ob_wm_action_undecorate; - supported[i++] = prop_atoms.ob_wm_state_undecorated; - supported[i++] = prop_atoms.openbox_pid; - supported[i++] = prop_atoms.ob_theme; - supported[i++] = prop_atoms.ob_config_file; - supported[i++] = prop_atoms.ob_control; + supported[i++] = OBT_PROP_ATOM(NET_WM_PID); + supported[i++] = OBT_PROP_ATOM(NET_WM_PING); + + supported[i++] = OBT_PROP_ATOM(KDE_WM_CHANGE_STATE); + supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_FRAME_STRUT); + supported[i++] = OBT_PROP_ATOM(KDE_NET_WM_WINDOW_TYPE_OVERRIDE); + + supported[i++] = OBT_PROP_ATOM(OB_WM_ACTION_UNDECORATE); + supported[i++] = OBT_PROP_ATOM(OB_WM_STATE_UNDECORATED); + supported[i++] = OBT_PROP_ATOM(OPENBOX_PID); + supported[i++] = OBT_PROP_ATOM(OB_THEME); + supported[i++] = OBT_PROP_ATOM(OB_CONFIG_FILE); + supported[i++] = OBT_PROP_ATOM(OB_CONTROL); + supported[i++] = OBT_PROP_ATOM(OB_ROLE); + supported[i++] = OBT_PROP_ATOM(OB_NAME); + supported[i++] = OBT_PROP_ATOM(OB_CLASS); g_assert(i == num_support); - PROP_SETA32(RootWindow(ob_display, ob_screen), - net_supported, atom, supported, num_support); + OBT_PROP_SETA32(obt_root(ob_screen), + NET_SUPPORTED, ATOM, supported, num_support); g_free(supported); screen_tell_ksplash(); @@ -337,14 +330,14 @@ static void screen_tell_ksplash(void) hear it anyways. perhaps it is for old ksplash. or new ksplash. or something. oh well. */ e.xclient.type = ClientMessage; - e.xclient.display = ob_display; - e.xclient.window = RootWindow(ob_display, ob_screen); + e.xclient.display = obt_display; + e.xclient.window = obt_root(ob_screen); e.xclient.message_type = - XInternAtom(ob_display, "_KDE_SPLASH_PROGRESS", False ); + XInternAtom(obt_display, "_KDE_SPLASH_PROGRESS", False); e.xclient.format = 8; strcpy(e.xclient.data.b, "wm started"); - XSendEvent(ob_display, RootWindow(ob_display, ob_screen), - False, SubstructureNotifyMask, &e ); + XSendEvent(obt_display, obt_root(ob_screen), + False, SubstructureNotifyMask, &e); } void screen_startup(gboolean reconfig) @@ -368,9 +361,7 @@ void screen_startup(gboolean reconfig) screen_resize(); /* have names already been set for the desktops? */ - if (PROP_GETSS(RootWindow(ob_display, ob_screen), - net_desktop_names, utf8, &names)) - { + if (OBT_PROP_GETSS(obt_root(ob_screen), NET_DESKTOP_NAMES, utf8, &names)) { g_strfreev(names); namesexist = TRUE; } @@ -391,7 +382,8 @@ void screen_startup(gboolean reconfig) names[i] = g_strdup(it->data); /* set the root window property */ - PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names,names); + OBT_PROP_SETSS(obt_root(ob_screen), + NET_DESKTOP_NAMES, utf8, (const gchar**)names); g_strfreev(names); } @@ -401,11 +393,15 @@ void screen_startup(gboolean reconfig) this will also set the default names from the config file up for desktops that don't have names yet */ screen_num_desktops = 0; - if (PROP_GET32(RootWindow(ob_display, ob_screen), - net_number_of_desktops, cardinal, &d)) + if (OBT_PROP_GET32(obt_root(ob_screen), + NET_NUMBER_OF_DESKTOPS, CARDINAL, &d)) { if (d != config_desktops_num) { - g_warning(_("Openbox is configured for %d desktops, but the current session has %d. Overriding the Openbox configuration."), + /* TRANSLATORS: If you need to specify a different order of the + arguments, you can use %1$d for the first one and %2$d for the + second one. For example, + "The current session has %2$d desktops, but Openbox is configured for %1$d ..." */ + g_warning(ngettext("Openbox is configured for %d desktop, but the current session has %d. Overriding the Openbox configuration.", "Openbox is configured for %d desktops, but the current session has %d. Overriding the Openbox configuration.", config_desktops_num), config_desktops_num, d); } screen_set_num_desktops(d); @@ -418,8 +414,8 @@ void screen_startup(gboolean reconfig) screen_desktop = screen_num_desktops; /* something invalid */ /* start on the current desktop when a wm was already running */ - if (PROP_GET32(RootWindow(ob_display, ob_screen), - net_current_desktop, cardinal, &d) && + if (OBT_PROP_GET32(obt_root(ob_screen), + NET_CURRENT_DESKTOP, CARDINAL, &d) && d < screen_num_desktops) { screen_set_desktop(d, FALSE); @@ -433,8 +429,8 @@ void screen_startup(gboolean reconfig) /* don't start in showing-desktop mode */ screen_showing_desktop = FALSE; - PROP_SET32(RootWindow(ob_display, ob_screen), - net_showing_desktop, cardinal, screen_showing_desktop); + OBT_PROP_SET32(obt_root(ob_screen), + NET_SHOWING_DESKTOP, CARDINAL, screen_showing_desktop); if (session_desktop_layout_present && screen_validate_layout(&session_desktop_layout)) @@ -452,17 +448,16 @@ void screen_shutdown(gboolean reconfig) if (reconfig) return; - XSelectInput(ob_display, RootWindow(ob_display, ob_screen), - NoEventMask); + XSelectInput(obt_display, obt_root(ob_screen), NoEventMask); /* we're not running here no more! */ - PROP_ERASE(RootWindow(ob_display, ob_screen), openbox_pid); + OBT_PROP_ERASE(obt_root(ob_screen), OPENBOX_PID); /* not without us */ - PROP_ERASE(RootWindow(ob_display, ob_screen), net_supported); + OBT_PROP_ERASE(obt_root(ob_screen), NET_SUPPORTED); /* don't keep this mode */ - PROP_ERASE(RootWindow(ob_display, ob_screen), net_showing_desktop); + OBT_PROP_ERASE(obt_root(ob_screen), NET_SHOWING_DESKTOP); - XDestroyWindow(ob_display, screen_support_win); + XDestroyWindow(obt_display, screen_support_win); g_strfreev(screen_desktop_names); screen_desktop_names = NULL; @@ -475,8 +470,8 @@ void screen_resize(void) GList *it; gulong geometry[2]; - w = WidthOfScreen(ScreenOfDisplay(ob_display, ob_screen)); - h = HeightOfScreen(ScreenOfDisplay(ob_display, ob_screen)); + w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)); + h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)); if (w == oldw && h == oldh) return; @@ -485,10 +480,10 @@ void screen_resize(void) /* Set the _NET_DESKTOP_GEOMETRY hint */ screen_physical_size.width = geometry[0] = w; screen_physical_size.height = geometry[1] = h; - PROP_SETA32(RootWindow(ob_display, ob_screen), - net_desktop_geometry, cardinal, geometry, 2); + OBT_PROP_SETA32(obt_root(ob_screen), + NET_DESKTOP_GEOMETRY, CARDINAL, geometry, 2); - if (ob_state() == OB_STATE_STARTING) + if (ob_state() != OB_STATE_RUNNING) return; screen_update_areas(); @@ -500,7 +495,6 @@ void screen_resize(void) void screen_set_num_desktops(guint num) { - guint old; gulong *viewport; GList *it, *stacking_copy; @@ -508,15 +502,13 @@ void screen_set_num_desktops(guint num) if (screen_num_desktops == num) return; - old = screen_num_desktops; screen_num_desktops = num; - PROP_SET32(RootWindow(ob_display, ob_screen), - net_number_of_desktops, cardinal, num); + OBT_PROP_SET32(obt_root(ob_screen), NET_NUMBER_OF_DESKTOPS, CARDINAL, num); /* set the viewport hint */ viewport = g_new0(gulong, num * 2); - PROP_SETA32(RootWindow(ob_display, ob_screen), - net_desktop_viewport, cardinal, viewport, num * 2); + OBT_PROP_SETA32(obt_root(ob_screen), + NET_DESKTOP_VIEWPORT, CARDINAL, viewport, num * 2); g_free(viewport); /* the number of rows/columns will differ */ @@ -538,12 +530,13 @@ void screen_set_num_desktops(guint num) stacking_raise(CLIENT_AS_WINDOW(c)); } } + g_list_free(stacking_copy); /* change our struts/area to match (after moving windows) */ screen_update_areas(); /* may be some unnamed desktops that we need to fill in with names - (after updating the areas so the popup can resize) */ + (after updating the areas so the popup can resize) */ screen_update_desktop_names(); /* change our desktop if we're on one that no longer exists! */ @@ -611,8 +604,7 @@ void screen_set_desktop(guint num, gboolean dofocus) if (previous == num) return; - PROP_SET32(RootWindow(ob_display, ob_screen), - net_current_desktop, cardinal, num); + OBT_PROP_SET32(obt_root(ob_screen), NET_CURRENT_DESKTOP, CARDINAL, num); /* This whole thing decides when/how to save the screen_last_desktop so that it can be restored later if you want */ @@ -678,11 +670,14 @@ void screen_set_desktop(guint num, gboolean dofocus) } } screen_desktop_timeout = FALSE; - ob_main_loop_timeout_remove(ob_main_loop, last_desktop_func); - ob_main_loop_timeout_add(ob_main_loop, REMEMBER_LAST_DESKTOP_TIME, - last_desktop_func, NULL, NULL, NULL); + obt_main_loop_timeout_remove(ob_main_loop, last_desktop_func); + obt_main_loop_timeout_add(ob_main_loop, REMEMBER_LAST_DESKTOP_TIME, + last_desktop_func, NULL, NULL, NULL); + + ob_debug("Moving to desktop %d", num+1); - ob_debug("Moving to desktop %d\n", num+1); + if (ob_state() == OB_STATE_RUNNING) + screen_show_desktop_popup(screen_desktop); /* ignore enter events caused by the move */ ignore_start = event_start_ignore_all_enters(); @@ -707,6 +702,15 @@ void screen_set_desktop(guint num, gboolean dofocus) if (WINDOW_IS_CLIENT(it->data)) { ObClient *c = it->data; client_hide(c); + if (c == focus_client) { + /* c was focused and we didn't do fallback clearly so make sure + openbox doesnt still consider the window focused. + this happens when using NextWindow with allDesktops, since + it doesnt want to move focus on desktop change, but the + focus is not going to stay with the current window, which + has now disappeared */ + focus_set_client(NULL); + } } } @@ -714,9 +718,6 @@ void screen_set_desktop(guint num, gboolean dofocus) if (event_curtime != CurrentTime) screen_desktop_user_time = event_curtime; - - if (ob_state() == OB_STATE_RUNNING) - screen_show_desktop_popup(screen_desktop); } void screen_add_desktop(gboolean current) @@ -739,7 +740,7 @@ void screen_add_desktop(gboolean current) parent - which will have to be on the same desktop */ !client_direct_parent(c)) { - ob_debug("moving window %s\n", c->title); + ob_debug("moving window %s", c->title); client_set_desktop(c, c->desktop+1, FALSE, TRUE); } } @@ -780,7 +781,7 @@ void screen_remove_desktop(gboolean current) parent - which will have to be on the same desktop */ !client_direct_parent(c)) { - ob_debug("moving window %s\n", c->title); + ob_debug("moving window %s", c->title); client_set_desktop(c, c->desktop - 1, TRUE, TRUE); } /* raise all the windows that are on the current desktop which @@ -790,15 +791,16 @@ void screen_remove_desktop(gboolean current) (d == DESKTOP_ALL || d == screen_desktop)) { stacking_raise(CLIENT_AS_WINDOW(c)); - ob_debug("raising window %s\n", c->title); + ob_debug("raising window %s", c->title); } } } + g_list_free(stacking_copy); /* fallback focus like we're changing desktops */ if (screen_desktop < screen_num_desktops - 1) { screen_fallback_focus(); - ob_debug("fake desktop change\n"); + ob_debug("fake desktop change"); } screen_set_num_desktops(screen_num_desktops-1); @@ -927,7 +929,7 @@ void screen_show_desktop_popup(guint d) /* 0 means don't show the popup */ if (!config_desktop_popup_time) return; - a = screen_physical_area_active(); + a = screen_physical_area_primary(); pager_popup_position(desktop_popup, CenterGravity, a->x + a->width / 2, a->y + a->height / 2); pager_popup_icon_size_multiplier(desktop_popup, @@ -939,15 +941,17 @@ void screen_show_desktop_popup(guint d) MAX(a->width/3, POPUP_WIDTH)); pager_popup_show(desktop_popup, screen_desktop_names[d], d); - ob_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func); - ob_main_loop_timeout_add(ob_main_loop, config_desktop_popup_time * 1000, - hide_desktop_popup_func, NULL, NULL, NULL); + obt_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func); + obt_main_loop_timeout_add(ob_main_loop, config_desktop_popup_time * 1000, + hide_desktop_popup_func, desktop_popup, + g_direct_equal, NULL); g_free(a); } void screen_hide_desktop_popup(void) { - ob_main_loop_timeout_remove(ob_main_loop, hide_desktop_popup_func); + obt_main_loop_timeout_remove_data(ob_main_loop, hide_desktop_popup_func, + desktop_popup, FALSE); pager_popup_hide(desktop_popup); } @@ -1106,13 +1110,13 @@ void screen_update_layout(void) screen_desktop_layout.rows = 1; screen_desktop_layout.columns = screen_num_desktops; - if (PROP_GETA32(RootWindow(ob_display, ob_screen), - net_desktop_layout, cardinal, &data, &num)) { + if (OBT_PROP_GETA32(obt_root(ob_screen), + NET_DESKTOP_LAYOUT, CARDINAL, &data, &num)) { if (num == 3 || num == 4) { - if (data[0] == prop_atoms.net_wm_orientation_vert) + if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_VERT)) l.orientation = OB_ORIENTATION_VERT; - else if (data[0] == prop_atoms.net_wm_orientation_horz) + else if (data[0] == OBT_PROP_ATOM(NET_WM_ORIENTATION_HORZ)) l.orientation = OB_ORIENTATION_HORZ; else return; @@ -1120,13 +1124,13 @@ void screen_update_layout(void) if (num < 4) l.start_corner = OB_CORNER_TOPLEFT; else { - if (data[3] == prop_atoms.net_wm_topleft) + if (data[3] == OBT_PROP_ATOM(NET_WM_TOPLEFT)) l.start_corner = OB_CORNER_TOPLEFT; - else if (data[3] == prop_atoms.net_wm_topright) + else if (data[3] == OBT_PROP_ATOM(NET_WM_TOPRIGHT)) l.start_corner = OB_CORNER_TOPRIGHT; - else if (data[3] == prop_atoms.net_wm_bottomright) + else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMRIGHT)) l.start_corner = OB_CORNER_BOTTOMRIGHT; - else if (data[3] == prop_atoms.net_wm_bottomleft) + else if (data[3] == OBT_PROP_ATOM(NET_WM_BOTTOMLEFT)) l.start_corner = OB_CORNER_BOTTOMLEFT; else return; @@ -1151,8 +1155,8 @@ void screen_update_desktop_names(void) g_strfreev(screen_desktop_names); screen_desktop_names = NULL; - if (PROP_GETSS(RootWindow(ob_display, ob_screen), - net_desktop_names, utf8, &screen_desktop_names)) + if (OBT_PROP_GETSS(obt_root(ob_screen), + NET_DESKTOP_NAMES, utf8, &screen_desktop_names)) for (i = 0; screen_desktop_names[i] && i < screen_num_desktops; ++i); else i = 0; @@ -1178,8 +1182,8 @@ void screen_update_desktop_names(void) /* if we changed any names, then set the root property so we can all agree on the names */ - PROP_SETSS(RootWindow(ob_display, ob_screen), net_desktop_names, - screen_desktop_names); + OBT_PROP_SETSS(obt_root(ob_screen), NET_DESKTOP_NAMES, + utf8, (const gchar**)screen_desktop_names); } /* resize the pager for these names */ @@ -1246,24 +1250,23 @@ void screen_show_desktop(gboolean show, ObClient *show_only) } show = !!show; /* make it boolean */ - PROP_SET32(RootWindow(ob_display, ob_screen), - net_showing_desktop, cardinal, show); + OBT_PROP_SET32(obt_root(ob_screen), NET_SHOWING_DESKTOP, CARDINAL, show); } void screen_install_colormap(ObClient *client, gboolean install) { if (client == NULL || client->colormap == None) { if (install) - XInstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst)); + XInstallColormap(obt_display, RrColormap(ob_rr_inst)); else - XUninstallColormap(RrDisplay(ob_rr_inst), RrColormap(ob_rr_inst)); + XUninstallColormap(obt_display, RrColormap(ob_rr_inst)); } else { - xerror_set_ignore(TRUE); + obt_display_ignore_errors(TRUE); if (install) - XInstallColormap(RrDisplay(ob_rr_inst), client->colormap); + XInstallColormap(obt_display, client->colormap); else - XUninstallColormap(RrDisplay(ob_rr_inst), client->colormap); - xerror_set_ignore(FALSE); + XUninstallColormap(obt_display, client->colormap); + obt_display_ignore_errors(FALSE); } } @@ -1305,6 +1308,55 @@ typedef struct { } \ } +static void get_xinerama_screens(Rect **xin_areas, guint *nxin) +{ + guint i; + gint n, l, r, t, b; +#ifdef XINERAMA + XineramaScreenInfo *info; +#endif + + if (ob_debug_xinerama) { + gint w = WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)); + gint h = HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen)); + *nxin = 2; + *xin_areas = g_new(Rect, *nxin + 1); + RECT_SET((*xin_areas)[0], 0, 0, w/2, h); + RECT_SET((*xin_areas)[1], w/2, 0, w-(w/2), h); + } +#ifdef XINERAMA + else if (obt_display_extension_xinerama && + (info = XineramaQueryScreens(obt_display, &n))) { + *nxin = n; + *xin_areas = g_new(Rect, *nxin + 1); + for (i = 0; i < *nxin; ++i) + RECT_SET((*xin_areas)[i], info[i].x_org, info[i].y_org, + info[i].width, info[i].height); + XFree(info); + } +#endif + else { + *nxin = 1; + *xin_areas = g_new(Rect, *nxin + 1); + RECT_SET((*xin_areas)[0], 0, 0, + WidthOfScreen(ScreenOfDisplay(obt_display, ob_screen)), + HeightOfScreen(ScreenOfDisplay(obt_display, ob_screen))); + } + + /* returns one extra with the total area in it */ + l = (*xin_areas)[0].x; + t = (*xin_areas)[0].y; + r = (*xin_areas)[0].x + (*xin_areas)[0].width - 1; + b = (*xin_areas)[0].y + (*xin_areas)[0].height - 1; + for (i = 1; i < *nxin; ++i) { + l = MIN(l, (*xin_areas)[i].x); + t = MIN(l, (*xin_areas)[i].y); + r = MAX(r, (*xin_areas)[i].x + (*xin_areas)[i].width - 1); + b = MAX(b, (*xin_areas)[i].y + (*xin_areas)[i].height - 1); + } + RECT_SET((*xin_areas)[*nxin], l, t, r - l + 1, b - t + 1); +} + void screen_update_areas(void) { guint i, j; @@ -1313,7 +1365,7 @@ void screen_update_areas(void) GSList *sit; g_free(monitor_area); - extensions_xinerama_screens(&monitor_area, &screen_num_monitors); + get_xinerama_screens(&monitor_area, &screen_num_monitors); /* set up the user-specified margins */ config_margins.top_start = RECT_LEFT(monitor_area[screen_num_monitors]); @@ -1412,6 +1464,18 @@ void screen_update_areas(void) b = MAX(b, s->strut->bottom); } + /* if the monitor is not against the edge of the root window, + the struts will include the distance from the root window's edge + to the monitor, so add that back into the monitor's work area */ + if (l) l += RECT_LEFT (monitor_area[screen_num_monitors]) + - RECT_LEFT (monitor_area[i]); + if (t) t += RECT_TOP (monitor_area[screen_num_monitors]) + - RECT_TOP (monitor_area[i]); + if (r) r -= RECT_RIGHT (monitor_area[screen_num_monitors]) + - RECT_RIGHT (monitor_area[i]); + if (b) b -= RECT_BOTTOM(monitor_area[screen_num_monitors]) + - RECT_BOTTOM(monitor_area[i]); + /* based on these margins, set the work area for the monitor/desktop */ dims[(i * screen_num_desktops + j) * 4 + 0] += l; @@ -1422,8 +1486,8 @@ void screen_update_areas(void) /* all the work areas are not used here, only the ones for the first monitor are */ - PROP_SETA32(RootWindow(ob_display, ob_screen), net_workarea, cardinal, - dims, 4 * screen_num_desktops); + OBT_PROP_SETA32(obt_root(ob_screen), NET_WORKAREA, CARDINAL, + dims, 4 * screen_num_desktops); /* the area has changed, adjust all the windows if they need it */ for (it = client_list; it; it = g_list_next(it)) @@ -1489,7 +1553,7 @@ Rect* screen_area(guint desktop, guint head, Rect *search) { Rect *a; GSList *it; - gint l, r, t, b, al, ar, at, ab; + gint l, r, t, b; guint i, d; gboolean us = search != NULL; /* user provided search */ @@ -1515,30 +1579,30 @@ Rect* screen_area(guint desktop, guint head, Rect *search) /* only include monitors which the search area lines up with */ if (RECT_INTERSECTS_RECT(monitor_area[screen_num_monitors], *search)) { - al = l = RECT_RIGHT(monitor_area[screen_num_monitors]); - at = t = RECT_BOTTOM(monitor_area[screen_num_monitors]); - ar = r = RECT_LEFT(monitor_area[screen_num_monitors]); - ab = b = RECT_TOP(monitor_area[screen_num_monitors]); + l = RECT_RIGHT(monitor_area[screen_num_monitors]); + t = RECT_BOTTOM(monitor_area[screen_num_monitors]); + r = RECT_LEFT(monitor_area[screen_num_monitors]); + b = RECT_TOP(monitor_area[screen_num_monitors]); for (i = 0; i < screen_num_monitors; ++i) { /* add the monitor if applicable */ if (RANGES_INTERSECT(search->x, search->width, monitor_area[i].x, monitor_area[i].width)) { - at = t = MIN(t, RECT_TOP(monitor_area[i])); - ab = b = MAX(b, RECT_BOTTOM(monitor_area[i])); + t = MIN(t, RECT_TOP(monitor_area[i])); + b = MAX(b, RECT_BOTTOM(monitor_area[i])); } if (RANGES_INTERSECT(search->y, search->height, monitor_area[i].y, monitor_area[i].height)) { - al = l = MIN(l, RECT_LEFT(monitor_area[i])); - ar = r = MAX(r, RECT_RIGHT(monitor_area[i])); + l = MIN(l, RECT_LEFT(monitor_area[i])); + r = MAX(r, RECT_RIGHT(monitor_area[i])); } } } else { - al = l = RECT_LEFT(monitor_area[screen_num_monitors]); - at = t = RECT_TOP(monitor_area[screen_num_monitors]); - ar = r = RECT_RIGHT(monitor_area[screen_num_monitors]); - ab = b = RECT_BOTTOM(monitor_area[screen_num_monitors]); + l = RECT_LEFT(monitor_area[screen_num_monitors]); + t = RECT_TOP(monitor_area[screen_num_monitors]); + r = RECT_RIGHT(monitor_area[screen_num_monitors]); + b = RECT_BOTTOM(monitor_area[screen_num_monitors]); } for (d = 0; d < screen_num_desktops; ++d) { @@ -1552,28 +1616,32 @@ Rect* screen_area(guint desktop, guint head, Rect *search) if ((s->desktop == d || s->desktop == DESKTOP_ALL) && STRUT_LEFT_IN_SEARCH(s->strut, search) && !STRUT_LEFT_IGNORE(s->strut, us, search)) - l = MAX(l, al + s->strut->left); + l = MAX(l, RECT_LEFT(monitor_area[screen_num_monitors]) + + s->strut->left); } for (it = struts_top; it; it = g_slist_next(it)) { ObScreenStrut *s = it->data; if ((s->desktop == d || s->desktop == DESKTOP_ALL) && STRUT_TOP_IN_SEARCH(s->strut, search) && !STRUT_TOP_IGNORE(s->strut, us, search)) - t = MAX(t, at + s->strut->top); + t = MAX(t, RECT_TOP(monitor_area[screen_num_monitors]) + + s->strut->top); } for (it = struts_right; it; it = g_slist_next(it)) { ObScreenStrut *s = it->data; if ((s->desktop == d || s->desktop == DESKTOP_ALL) && STRUT_RIGHT_IN_SEARCH(s->strut, search) && !STRUT_RIGHT_IGNORE(s->strut, us, search)) - r = MIN(r, ar - s->strut->right); + r = MIN(r, RECT_RIGHT(monitor_area[screen_num_monitors]) + - s->strut->right); } for (it = struts_bottom; it; it = g_slist_next(it)) { ObScreenStrut *s = it->data; if ((s->desktop == d || s->desktop == DESKTOP_ALL) && STRUT_BOTTOM_IN_SEARCH(s->strut, search) && !STRUT_BOTTOM_IGNORE(s->strut, us, search)) - b = MIN(b, ab - s->strut->bottom); + b = MIN(b, RECT_BOTTOM(monitor_area[screen_num_monitors]) + - s->strut->bottom); } /* limit to this monitor */ @@ -1641,36 +1709,61 @@ gboolean screen_physical_area_monitor_contains(guint head, Rect *search) return RECT_INTERSECTS_RECT(monitor_area[head], *search); } -Rect* screen_physical_area_active(void) +guint screen_monitor_active(void) { - Rect *a; - gint x, y; - if (moveresize_client) - a = screen_physical_area_monitor(client_monitor(focus_client)); + return client_monitor(moveresize_client); else if (focus_client) - a = screen_physical_area_monitor(client_monitor(focus_client)); - else { - Rect mon; - if (screen_pointer_pos(&x, &y)) - RECT_SET(mon, x, y, 1, 1); + return client_monitor(focus_client); + else + return screen_monitor_pointer(); +} + +Rect* screen_physical_area_active(void) +{ + return screen_physical_area_monitor(screen_monitor_active()); +} + +guint screen_monitor_primary(void) +{ + if (config_primary_monitor_index > 0) { + if (config_primary_monitor_index-1 < screen_num_monitors) + return config_primary_monitor_index - 1; else - RECT_SET(mon, 0, 0, 1, 1); - a = screen_physical_area_monitor(screen_find_monitor(&mon)); + return 0; } - return a; + else if (config_primary_monitor == OB_PLACE_MONITOR_ACTIVE) + return screen_monitor_active(); + else /* config_primary_monitor == OB_PLACE_MONITOR_MOUSE */ + return screen_monitor_pointer(); +} + +Rect *screen_physical_area_primary(void) +{ + return screen_physical_area_monitor(screen_monitor_primary()); } void screen_set_root_cursor(void) { if (sn_app_starting()) - XDefineCursor(ob_display, RootWindow(ob_display, ob_screen), + XDefineCursor(obt_display, obt_root(ob_screen), ob_cursor(OB_CURSOR_BUSYPOINTER)); else - XDefineCursor(ob_display, RootWindow(ob_display, ob_screen), + XDefineCursor(obt_display, obt_root(ob_screen), ob_cursor(OB_CURSOR_POINTER)); } +guint screen_monitor_pointer() +{ + Rect mon; + gint x, y; + if (screen_pointer_pos(&x, &y)) + RECT_SET(mon, x, y, 1, 1); + else + RECT_SET(mon, 0, 0, 1, 1); + return screen_find_monitor(&mon); +} + gboolean screen_pointer_pos(gint *x, gint *y) { Window w; @@ -1678,12 +1771,12 @@ gboolean screen_pointer_pos(gint *x, gint *y) guint u; gboolean ret; - ret = !!XQueryPointer(ob_display, RootWindow(ob_display, ob_screen), + ret = !!XQueryPointer(obt_display, obt_root(ob_screen), &w, &w, x, y, &i, &i, &u); if (!ret) { - for (i = 0; i < ScreenCount(ob_display); ++i) + for (i = 0; i < ScreenCount(obt_display); ++i) if (i != ob_screen) - if (XQueryPointer(ob_display, RootWindow(ob_display, i), + if (XQueryPointer(obt_display, obt_root(i), &w, &w, x, y, &i, &i, &u)) break; }