Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
openSUSE:Evergreen:11.4
gnome-do-plugins
gnome-do-plugins-wink.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File gnome-do-plugins-wink.patch of Package gnome-do-plugins
=== modified file 'WindowManager/Makefile.am' --- WindowManager/Makefile.am 2009-06-22 04:05:16 +0000 +++ WindowManager/Makefile.am 2010-03-08 02:43:56 +0000 @@ -1,4 +1,6 @@ +if HAVE_WNCK include $(top_srcdir)/build.rules.mk +endif ASSEMBLY=WindowManager @@ -22,7 +24,17 @@ src/WindowActions/WindowFocusAction.cs \ src/WindowActions/WindowMaximizeAction.cs \ src/WindowActions/WindowMinimizeAction.cs \ - src/WindowActions/WindowMoveAction.cs + src/WindowActions/WindowMoveAction.cs \ + src/Wink/ScreenUtils.cs \ + src/Wink/WindowControl.cs \ + src/Wink/WnckWindow_Extensions.cs \ + src/Wink/Position.cs \ + src/Wink/Viewport.cs \ + src/Wink/WindowUtils.cs \ + src/Xlib/X11Atoms.cs \ + src/Xlib/Xlib.cs + + RESOURCES = \ @@ -31,10 +43,10 @@ REFERENCES = \ System \ System.Core \ + Mono.Posix \ $(WNCK_SHARP_10_LIBS) \ $(GTK_SHARP_20_LIBS) \ $(GLIB_SHARP_20_LIBS) \ $(GNOME_DESKTOP_SHARP_20_LIBS) \ $(DO_PLATFORM_LIBS) \ - $(DO_UNIVERSE_LIBS) \ - $(DO_INTERFACE_WINK_LIBS) + $(DO_UNIVERSE_LIBS) === modified file 'WindowManager/src/CurrentApplicationItem.cs' --- WindowManager/src/CurrentApplicationItem.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/CurrentApplicationItem.cs 2009-10-11 20:48:44 +0000 @@ -23,7 +23,7 @@ using Mono.Addins; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; namespace WindowManager { === modified file 'WindowManager/src/CurrentWindowItem.cs' --- WindowManager/src/CurrentWindowItem.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/CurrentWindowItem.cs 2009-10-11 20:48:44 +0000 @@ -23,7 +23,7 @@ using Mono.Addins; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; namespace WindowManager { === modified file 'WindowManager/src/IWindowList.cs' --- WindowManager/src/IWindowList.cs 2009-03-30 00:03:03 +0000 +++ WindowManager/src/IWindowList.cs 2009-10-11 20:48:44 +0000 @@ -25,7 +25,7 @@ using Wnck; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; namespace WindowManager { === modified file 'WindowManager/src/Screen/CurrentScreenItem.cs' --- WindowManager/src/Screen/CurrentScreenItem.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/Screen/CurrentScreenItem.cs 2009-10-11 20:48:44 +0000 @@ -23,7 +23,7 @@ using Mono.Addins; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; namespace WindowManager { @@ -65,4 +65,4 @@ } } } -} \ No newline at end of file +} === modified file 'WindowManager/src/Screen/ScreenActionAction.cs' --- WindowManager/src/Screen/ScreenActionAction.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/Screen/ScreenActionAction.cs 2009-10-11 20:48:44 +0000 @@ -22,7 +22,7 @@ using System.Threading; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/Screen/ScreenCascadeAction.cs' --- WindowManager/src/Screen/ScreenCascadeAction.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/Screen/ScreenCascadeAction.cs 2009-10-11 20:48:44 +0000 @@ -22,7 +22,7 @@ using System.Threading; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/Screen/ScreenItem.cs' --- WindowManager/src/Screen/ScreenItem.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/Screen/ScreenItem.cs 2009-10-11 20:48:44 +0000 @@ -23,7 +23,7 @@ using Mono.Addins; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; namespace WindowManager { === modified file 'WindowManager/src/Screen/ScreenItemSource.cs' --- WindowManager/src/Screen/ScreenItemSource.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/Screen/ScreenItemSource.cs 2009-10-11 20:48:44 +0000 @@ -24,7 +24,7 @@ using System.Collections.Generic; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/Screen/ScreenRestoreAction.cs' --- WindowManager/src/Screen/ScreenRestoreAction.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/Screen/ScreenRestoreAction.cs 2009-10-11 20:48:44 +0000 @@ -27,7 +27,7 @@ using System.Threading; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/Screen/ScreenSwapAction.cs' --- WindowManager/src/Screen/ScreenSwapAction.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/Screen/ScreenSwapAction.cs 2009-10-11 20:48:44 +0000 @@ -22,7 +22,7 @@ using System.Threading; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/Screen/ScreenTileAction.cs' --- WindowManager/src/Screen/ScreenTileAction.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/Screen/ScreenTileAction.cs 2009-10-11 20:48:44 +0000 @@ -22,7 +22,7 @@ using System.Threading; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/WindowActions/WindowActionAction.cs' --- WindowManager/src/WindowActions/WindowActionAction.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/WindowActions/WindowActionAction.cs 2009-10-11 20:48:44 +0000 @@ -27,7 +27,7 @@ using System.Threading; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/WindowActions/WindowCloseAction.cs' --- WindowManager/src/WindowActions/WindowCloseAction.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/WindowActions/WindowCloseAction.cs 2009-10-11 20:48:44 +0000 @@ -20,7 +20,7 @@ using System.Linq; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/WindowActions/WindowFocusAction.cs' --- WindowManager/src/WindowActions/WindowFocusAction.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/WindowActions/WindowFocusAction.cs 2009-10-11 20:48:44 +0000 @@ -20,7 +20,7 @@ using System.Linq; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/WindowActions/WindowMaximizeAction.cs' --- WindowManager/src/WindowActions/WindowMaximizeAction.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/WindowActions/WindowMaximizeAction.cs 2009-10-11 20:48:44 +0000 @@ -20,7 +20,7 @@ using System.Linq; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/WindowActions/WindowMinimizeAction.cs' --- WindowManager/src/WindowActions/WindowMinimizeAction.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/WindowActions/WindowMinimizeAction.cs 2009-10-11 20:48:44 +0000 @@ -20,7 +20,7 @@ using System.Linq; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === modified file 'WindowManager/src/WindowActions/WindowMoveAction.cs' --- WindowManager/src/WindowActions/WindowMoveAction.cs 2009-04-04 04:53:33 +0000 +++ WindowManager/src/WindowActions/WindowMoveAction.cs 2009-10-11 20:48:44 +0000 @@ -23,7 +23,7 @@ using Do.Platform; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; namespace WindowManager { === modified file 'WindowManager/src/WindowItem.cs' --- WindowManager/src/WindowItem.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/WindowItem.cs 2009-10-11 20:48:44 +0000 @@ -28,7 +28,7 @@ using Mono.Addins; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; namespace WindowManager { === modified file 'WindowManager/src/WindowItemSource.cs' --- WindowManager/src/WindowItemSource.cs 2009-06-22 04:05:16 +0000 +++ WindowManager/src/WindowItemSource.cs 2009-10-11 20:48:44 +0000 @@ -25,7 +25,7 @@ using System.Linq; using Do.Universe; -using Do.Interface.Wink; +using WindowManager.Wink; using Wnck; using Mono.Addins; === added directory 'WindowManager/src/Wink' === added file 'WindowManager/src/Wink/Position.cs' --- WindowManager/src/Wink/Position.cs 1970-01-01 00:00:00 +0000 +++ WindowManager/src/Wink/Position.cs 2009-10-11 20:48:44 +0000 @@ -0,0 +1,30 @@ +// +// Copyright (C) 2009 GNOME Do +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see <http://www.gnu.org/licenses/>. +// + +using System; + +namespace WindowManager.Wink +{ + + + public enum Position { + Left = 0, + Right, + Top, + Bottom, + } +} === added file 'WindowManager/src/Wink/ScreenUtils.cs' --- WindowManager/src/Wink/ScreenUtils.cs 1970-01-01 00:00:00 +0000 +++ WindowManager/src/Wink/ScreenUtils.cs 2009-10-11 20:48:44 +0000 @@ -0,0 +1,160 @@ +// +// Copyright (C) 2009 GNOME Do +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see <http://www.gnu.org/licenses/>. +// + +using System; +using System.Collections.Generic; +using System.Linq; + +using Mono.Unix; + +using Wnck; + +namespace WindowManager.Wink +{ + + + public static class ScreenUtils + { + static bool initialized; + static string ViewportFormatString = Catalog.GetString ("Desktop") + " {0}"; + static Dictionary<Workspace, Viewport [,]> layouts; + + public static event EventHandler ViewportsChanged; + + public static Viewport ActiveViewport { + get { + Workspace wsp = Wnck.Screen.Default.ActiveWorkspace; + Gdk.Rectangle geo = new Gdk.Rectangle (wsp.ViewportX, wsp.ViewportY, wsp.Screen.Width, wsp.Screen.Height); + if (Viewports.Any (vp => vp.IsActive)) + return Viewports.First (vp => vp.IsActive); + return null; + } + } + + public static IEnumerable<Viewport> Viewports { + get { + foreach (Viewport [,] layout in layouts.Values) { + foreach (Viewport viewport in layout) + yield return viewport; + } + } + } + + public static void Initialize () + { + if (initialized) + return; + + initialized = true; + Wnck.Global.ClientType = Wnck.ClientType.Pager; + + Wnck.Screen.Default.ViewportsChanged += HandleViewportsChanged; + Wnck.Screen.Default.WorkspaceCreated += HandleWorkspaceCreated; + Wnck.Screen.Default.WorkspaceDestroyed += HandleWorkspaceDestroyed; + + UpdateViewports (); + } + + static void HandleWorkspaceDestroyed(object o, WorkspaceDestroyedArgs args) + { + UpdateViewports (); + } + + static void HandleWorkspaceCreated(object o, WorkspaceCreatedArgs args) + { + UpdateViewports (); + } + + static void HandleViewportsChanged(object sender, EventArgs e) + { + UpdateViewports (); + } + + public static bool DesktopShown (Screen screen) + { + return screen.ShowingDesktop; + } + + public static void ShowDesktop (Screen screen) + { + if (!screen.ShowingDesktop) + screen.ToggleShowingDesktop (true); + } + + public static void UnshowDesktop (Screen screen) + { + if (screen.ShowingDesktop) + screen.ToggleShowingDesktop (false); + } + + public static Viewport [,] ViewportLayout () + { + return ViewportLayout (Wnck.Screen.Default.ActiveWorkspace); + } + + public static Viewport [,] ViewportLayout (Workspace workspace) + { + if (!layouts.ContainsKey (workspace)) + return new Viewport [0,0]; + + return layouts [workspace]; + } + + static void UpdateViewports () + { + layouts = new Dictionary<Workspace, Viewport [,]> (); + + int currentViewport = 1; + foreach (Wnck.Workspace workspace in Wnck.Screen.Default.Workspaces) { + + if (workspace.IsVirtual) { + int viewportWidth; + int viewportHeight; + viewportWidth = workspace.Screen.Width; + viewportHeight = workspace.Screen.Height; + + int rows = workspace.Height / viewportHeight; + int columns = workspace.Width / viewportWidth; + + layouts [workspace] = new Viewport [rows, columns]; + + for (int i = 0; i < rows; i++) { + for (int j = 0; j < columns; j++) { + Gdk.Rectangle area = new Gdk.Rectangle (j * viewportWidth, + i * viewportHeight, + viewportWidth, + viewportHeight); + layouts [workspace] [i, j] = new Viewport (string.Format (ViewportFormatString, currentViewport), + area, + workspace); + currentViewport++; + } + } + } else { + layouts [workspace] = new Viewport [1,1]; + Viewport viewport = new Viewport (string.Format (ViewportFormatString, currentViewport), + new Gdk.Rectangle (0, 0, workspace.Width, workspace.Height), + workspace); + layouts [workspace] [0,0] = viewport; + currentViewport++; + } + } + if (ViewportsChanged != null) + ViewportsChanged (new object (), EventArgs.Empty); + } + } +} === added file 'WindowManager/src/Wink/Viewport.cs' --- WindowManager/src/Wink/Viewport.cs 1970-01-01 00:00:00 +0000 +++ WindowManager/src/Wink/Viewport.cs 2009-10-11 21:50:55 +0000 @@ -0,0 +1,280 @@ +// +// Copyright (C) 2009 GNOME Do +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see <http://www.gnu.org/licenses/>. +// + +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Linq; + + +using Gdk; +using Wnck; + +using Do.Platform; +using WindowManager.Xlib; + +namespace WindowManager.Wink +{ + public class Viewport + { + static Dictionary<Wnck.Window, WindowState> window_states = new Dictionary<Wnck.Window, WindowState> (); + + private class WindowState { + public Gdk.Rectangle Area; + public Wnck.WindowState State; + + public WindowState (Gdk.Rectangle area, Wnck.WindowState state) + { + Area = area; + State = state; + } + } + + Workspace parent; + Rectangle area; + + public string Name { get; private set; } + + public Rectangle Area { + get { return area; } + } + + public bool IsActive { + get { + if (!parent.IsVirtual) + return Wnck.Screen.Default.ActiveWorkspace == parent; + else + return Wnck.Screen.Default.ActiveWorkspace.ViewportX == area.X && Wnck.Screen.Default.ActiveWorkspace.ViewportY == area.Y; + } + } + + WindowMoveResizeMask MoveMask { + get { + return WindowMoveResizeMask.X | WindowMoveResizeMask.Y; + } + } + + WindowMoveResizeMask ResizeMask { + get { + return WindowMoveResizeMask.Width | WindowMoveResizeMask.Height; + } + } + + WindowMoveResizeMask MoveResizeMask { + get { + return WindowMoveResizeMask.X | + WindowMoveResizeMask.Y | + WindowMoveResizeMask.Height | + WindowMoveResizeMask.Width; + } + } + + internal Viewport(string name, Rectangle area, Workspace parent) + { + this.area = area; + this.parent = parent; + Name = name; + } + + public void Present () + { + parent.Screen.MoveViewport (area.X, area.Y); + } + + public bool Contains (Gdk.Point point) + { + return area.Contains (point); + } + + private IEnumerable<Wnck.Window> RawWindows () + { + foreach (Wnck.Window window in WindowUtils.GetWindows ()) { + if (WindowCenterInViewport (window) || window.IsSticky) + yield return window; + } + } + + public IEnumerable<Wnck.Window> Windows () + { + return RawWindows ().Where (w => !w.IsSkipTasklist && w.WindowType != Wnck.WindowType.Dock); + } + + public IEnumerable<Wnck.Window> UnprocessedWindows () + { + return RawWindows ().Where (w => w.WindowType != Wnck.WindowType.Dock); + } + + public void MoveWindowInto (Wnck.Window window) + { + if (parent.IsVirtual) { + Rectangle geo = window.EasyGeometry (); + + geo.X += window.Workspace.ViewportX; + geo.Y += window.Workspace.ViewportY; + + int x = area.X + (geo.X % area.Width); + int y = area.Y + (geo.Y % area.Height); + + x -= window.Workspace.ViewportX; + y -= window.Workspace.ViewportY; + + window.SetWorkaroundGeometry (WindowGravity.Current, MoveMask, x, y, 0, 0); + } else { + window.MoveToWorkspace (parent); + } + } + + bool WindowCenterInViewport (Wnck.Window window) + { + if (!window.IsOnWorkspace (parent)) + return false; + + Rectangle geo = window.EasyGeometry (); + geo.X += parent.ViewportX; + geo.Y += parent.ViewportY; + + Point center = new Point (geo.X + geo.Width / 2, geo.Y + geo.Height / 2); + return Contains (center); + } + + public void RestoreLayout () + { + foreach (Wnck.Window window in Windows ()) + RestoreTemporaryWindowGeometry (window); + } + + public void Cascade () + { + IEnumerable<Wnck.Window> windows = Windows ().Where (w => !w.IsMinimized); + if (windows.Count () <= 1) return; + + Gdk.Rectangle screenGeo = GetScreenGeoMinusStruts (); + + int titleBarSize = windows.First ().FrameExtents () [(int) Position.Top]; + int windowHeight = screenGeo.Height - ((windows.Count () - 1) * titleBarSize); + int windowWidth = screenGeo.Width - ((windows.Count () - 1) * titleBarSize); + + int count = 0; + int x, y; + foreach (Wnck.Window window in windows) { + x = screenGeo.X + titleBarSize * count - parent.ViewportX; + y = screenGeo.Y + titleBarSize * count - parent.ViewportY; + + SetTemporaryWindowGeometry (window, new Gdk.Rectangle (x, y, windowWidth, windowHeight)); + count++; + } + } + + public void ShowDesktop () + { + if (!ScreenUtils.DesktopShown (parent.Screen)) + ScreenUtils.ShowDesktop (parent.Screen); + else + ScreenUtils.UnshowDesktop (parent.Screen); + } + + public void Tile () + { + IEnumerable<Wnck.Window> windows = Windows ().Where (w => !w.IsMinimized); + if (windows.Count () <= 1) return; + + Gdk.Rectangle screenGeo = GetScreenGeoMinusStruts (); + + int width, height; + //We are going to tile to a square, so what we want is to find + //the smallest perfect square all our windows will fit into + width = (int) Math.Ceiling (Math.Sqrt (windows.Count ())); + + //Our height is at least one (e.g. a 2x1) + height = 1; + while (width * height < windows.Count ()) + height++; + + int windowWidth, windowHeight; + windowWidth = screenGeo.Width / width; + windowHeight = screenGeo.Height / height; + + int row = 0, column = 0; + int x, y; + + foreach (Wnck.Window window in windows) { + x = screenGeo.X + (column * windowWidth) - parent.ViewportX; + y = screenGeo.Y + (row * windowHeight) - parent.ViewportY; + + Gdk.Rectangle windowArea = new Gdk.Rectangle (x, y, windowWidth, windowHeight);; + + if (window == windows.Last ()) + windowArea.Width *= width - column; + + SetTemporaryWindowGeometry (window, windowArea); + + column++; + if (column == width) { + column = 0; + row++; + } + } + } + + Gdk.Rectangle GetScreenGeoMinusStruts () + { + IEnumerable<int []> struts = RawWindows () + .Where (w => w.WindowType == Wnck.WindowType.Dock) + .Select (w => w.GetCardinalProperty (X11Atoms.Instance._NET_WM_STRUT_PARTIAL)); + + int [] offsets = new int [4]; + for (int i = 0; i < 4; i++) + offsets [i] = struts.Max (a => a[i]); + + Gdk.Rectangle screenGeo = Area; + screenGeo.Width -= offsets [(int) Position.Left] + offsets [(int) Position.Right]; + screenGeo.Height -= offsets [(int) Position.Top] + offsets [(int) Position.Bottom]; + screenGeo.X += offsets [(int) Position.Left]; + screenGeo.Y += offsets [(int) Position.Top]; + + return screenGeo; + } + + void SetTemporaryWindowGeometry (Wnck.Window window, Gdk.Rectangle area) + { + Gdk.Rectangle oldGeo = window.EasyGeometry (); + + oldGeo.X += parent.ViewportX; + oldGeo.Y += parent.ViewportY; + + if (!window_states.ContainsKey (window)) + window_states [window] = new WindowState (oldGeo, window.State); + + if (window.IsMaximized) + window.Unmaximize (); + + window.SetWorkaroundGeometry (WindowGravity.Current, MoveResizeMask, area.X, area.Y, area.Width, area.Height); + } + + void RestoreTemporaryWindowGeometry (Wnck.Window window) + { + if (!window_states.ContainsKey (window)) + return; + + WindowState state = window_states [window]; + window.SetWorkaroundGeometry (WindowGravity.Current, MoveResizeMask, state.Area.X - parent.ViewportX, + state.Area.Y - parent.ViewportY, state.Area.Width, state.Area.Height); + + window_states.Remove (window); + } + } +} === added file 'WindowManager/src/Wink/WindowControl.cs' --- WindowManager/src/Wink/WindowControl.cs 1970-01-01 00:00:00 +0000 +++ WindowManager/src/Wink/WindowControl.cs 2009-10-11 21:50:55 +0000 @@ -0,0 +1,173 @@ +// WindowControl.cs +// +// Copyright (C) 2008 GNOME Do +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see <http://www.gnu.org/licenses/>. +// + +using System; +using System.Collections.Generic; +using System.Linq; + +using Wnck; + +namespace WindowManager.Wink +{ + + + public static class WindowControl + { + + const int SleepTime = 10; + const int FocusDelay = 200; + + static WindowControl () + { + Wnck.Global.ClientType = Wnck.ClientType.Pager; + } + + /// <summary> + /// Handles intelligent minimize/restoring of windows. If one or more windows is minimized, it restores + /// all windows. If more all are visible, it minimizes. This operation only takes into account windows + /// on the current workspace (by design). + /// </summary> + /// <param name="windows"> + /// A <see cref="IEnumerable"/> + /// </param> + public static void MinimizeRestoreWindows (IEnumerable<Window> windows) + { + bool restore = false; + foreach (Window w in windows) { + if (w.IsMinimized) { + restore = true; + break; + } + } + if (restore) + RestoreWindows (windows); + else + MinimizeWindows (windows); + } + + /// <summary> + /// Minimizes every window in the list if it is not minimized + /// </summary> + /// <param name="windows"> + /// A <see cref="IEnumerable"/> + /// </param> + public static void MinimizeWindows (IEnumerable<Window> windows) + { + foreach (Window window in windows) { + if (window.IsInViewport (window.Screen.ActiveWorkspace) && !window.IsMinimized) { + window.Minimize (); + System.Threading.Thread.Sleep (SleepTime); + } + } + } + + /// <summary> + /// Restores every window in the list that is minimized + /// </summary> + /// <param name="windows"> + /// A <see cref="IEnumerable"/> + /// </param> + public static void RestoreWindows (IEnumerable<Window> windows) + { + foreach (Window window in windows.Reverse ()) { + if (window.IsInViewport (window.Screen.ActiveWorkspace) && window.IsMinimized) { + window.Unminimize (Gtk.Global.CurrentEventTime); + System.Threading.Thread.Sleep (SleepTime); + } + } + } + + public static void FocusWindows (IEnumerable<Window> windows) + { + if (!windows.Any ()) + return; + + if (windows.Any (w => w.IsInViewport (w.Screen.ActiveWorkspace))) { + foreach (Window window in windows.Reverse ()) { + if (window.IsInViewport (window.Screen.ActiveWorkspace) && !window.IsMinimized) { + window.CenterAndFocusWindow (); + System.Threading.Thread.Sleep (SleepTime); + } + } + } else { + windows.First ().CenterAndFocusWindow (); + } + + if (windows.Count () <= 1) + return; + + // we do this to make sure our active window is also at the front... Its a tricky thing to do. + // sometimes compiz plays badly. This hacks around it + uint time = Gtk.Global.CurrentEventTime + FocusDelay; + GLib.Timeout.Add (FocusDelay, delegate { + try { //unimportant if this fails, its just "nice" + windows.Where (w => w.IsInViewport (w.Screen.ActiveWorkspace) && !w.IsMinimized).First ().Activate (time); + } catch { } + return false; + }); + } + + public static void FocusWindows (Window window) + { + FocusWindows (new [] {window}); + } + + public static void CloseWindows (IEnumerable<Window> windows) + { + foreach (Window window in windows.Where (w => !w.IsSkipTasklist)) + window.Close (Gtk.Global.CurrentEventTime); + } + + public static void CloseWindows (Window window) + { + CloseWindows (new [] {window}); + } + + public static void MinimizeRestoreWindows (Window window) + { + MinimizeRestoreWindows (new [] {window}); + } + + public static void MaximizeWindow (Window window) + { + window.Maximize (); + } + + /// <summary> + /// Moves the current viewport to the selected window and then raises it + /// </summary> + /// <param name="w"> + /// A <see cref="Window"/> + /// </param> + public static void CenterAndFocusWindow (this Window w) + { + if (w == null) + return; + + uint time = Gtk.Global.CurrentEventTime; + if (w.Workspace != null && w.Workspace != w.Screen.ActiveWorkspace) + w.Workspace.Activate (time); + + + if (w.IsMinimized) + w.Unminimize (time); + + w.ActivateTransient (time); + } + } +} === added file 'WindowManager/src/Wink/WindowUtils.cs' --- WindowManager/src/Wink/WindowUtils.cs 1970-01-01 00:00:00 +0000 +++ WindowManager/src/Wink/WindowUtils.cs 2009-10-11 21:50:55 +0000 @@ -0,0 +1,402 @@ +// WindowUtils.cs +// +// Copyright (C) 2008 GNOME Do +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see <http://www.gnu.org/licenses/>. +// + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Text.RegularExpressions; + +using Do.Platform; + +using Wnck; + +namespace WindowManager.Wink +{ + + public static class WindowUtils + { + enum OpenOfficeProducts { + Writer, + Calc, + Base, + Math, + Impress, + } + + static bool initialized; + + static string RemapFile { + get { return Path.Combine (Services.Paths.UserDataDirectory, "RemapFile"); } + } + + static IEnumerable<string> PrefixStrings { + get { + yield return "gksu"; + yield return "sudo"; + yield return "java"; + yield return "mono"; + yield return "ruby"; + yield return "padsp"; + yield return "aoss"; + yield return "python(\\d.\\d)?"; + yield return "(ba)?sh"; + } + } + + public static IEnumerable<Regex> BadPrefixes { get; private set; } + + static Dictionary<string, string> RemapDictionary { get; set; } + + static List<Window> window_list; + static bool window_list_update_needed; + + static Dictionary<int, string> exec_lines = new Dictionary<int, string> (); + static DateTime last_update = new DateTime (0); + + #region ctor + public static void Initialize () + { + if (initialized) + return; + + initialized = true; + Wnck.Global.ClientType = Wnck.ClientType.Pager; + + List<Regex> regex = new List<Regex> (); + foreach (string s in PrefixStrings) { + regex.Add (new Regex (string.Format ("^{0}$", s), RegexOptions.IgnoreCase)); + } + + BadPrefixes = regex.AsEnumerable (); + + Wnck.Screen.Default.WindowClosed += delegate { + window_list_update_needed = true; + }; + + Wnck.Screen.Default.WindowOpened += delegate { + window_list_update_needed = true; + }; + + Wnck.Screen.Default.ApplicationOpened += delegate { + window_list_update_needed = true; + }; + + Wnck.Screen.Default.ApplicationClosed += delegate { + window_list_update_needed = true; + }; + + BuildRemapDictionary (); + } + #endregion + + #region Private Methods + static void BuildRemapDictionary () + { + if (!File.Exists (RemapFile)) { + RemapDictionary = BuildDefaultRemapDictionary (); + + try { + using (StreamWriter writer = new StreamWriter (RemapFile)) { + writer.WriteLine ("# Docky Remap File"); + writer.WriteLine ("# Add key value pairs following dictionary syntax"); + writer.WriteLine ("# key, value"); + writer.WriteLine ("# key, altKey, value"); + writer.WriteLine ("# Lines starting with # are comments, otherwise # is a valid character"); + + foreach (KeyValuePair<string, string> kvp in RemapDictionary) { + writer.WriteLine ("{0}, {1}", kvp.Key, kvp.Value); + } + writer.Close (); + } + } catch { + } + } else { + RemapDictionary = new Dictionary<string, string> (); + + try { + using (StreamReader reader = new StreamReader (RemapFile)) { + string line; + while (!reader.EndOfStream) { + line = reader.ReadLine (); + if (line.StartsWith ("#") || !line.Contains (",")) + continue; + string [] array = line.Split (','); + if (array.Length < 2 || array [0].Length == 0) + continue; + + string val = array [array.Length - 1].Trim ().ToLower (); + if (string.IsNullOrEmpty (val)) + continue; + + for (int i=0; i < array.Length - 1; i++) { + string key = array [i].Trim ().ToLower (); + if (string.IsNullOrEmpty (key)) + continue; + RemapDictionary [key] = val; + } + } + + reader.Close (); + } + } catch { + Log.Error ("Could not read remap file"); + RemapDictionary = BuildDefaultRemapDictionary (); + } + } + } + + static Dictionary<string, string> BuildDefaultRemapDictionary () + { + Dictionary<string, string> remapDict = new Dictionary<string, string> (); + remapDict ["banshee.exe"] = "banshee"; + remapDict ["banshee-1"] = "banshee"; + remapDict ["azureus"] = "vuze"; + remapDict ["thunderbird-3.0"] = "thunderbird"; + remapDict ["thunderbird-bin"] = "thunderbird"; + + return remapDict; + } + + static void UpdateExecList () + { + if ((DateTime.UtcNow - last_update).TotalMilliseconds < 200) return; + + Dictionary<int, string> old = exec_lines; + + exec_lines = new Dictionary<int, string> (); + + foreach (string dir in Directory.GetDirectories ("/proc")) { + int pid; + try { pid = Convert.ToInt32 (Path.GetFileName (dir)); } + catch { continue; } + + if (old.ContainsKey (pid)) { + exec_lines [pid] = old [pid]; + continue; + } + + string exec_line = CmdLineForPid (pid); + if (string.IsNullOrEmpty (exec_line)) + continue; + + if (exec_line.Contains ("java") && exec_line.Contains ("jar")) { + foreach (Window window in GetWindows ()) { + if (window == null) + continue; + + if (window.Pid == pid || window.Application.Pid == pid) { + exec_line = window.ClassGroup.ResClass; + + // Vuze is retarded + if (exec_line == "SWT") + exec_line = window.Name; + } + } + } + + exec_line = ProcessExecString (exec_line); + + exec_lines [pid] = exec_line; + } + + last_update = DateTime.UtcNow; + } + #endregion + + #region Public Methods + /// <summary> + /// Returns a list of all windows on the default screen + /// </summary> + /// <returns> + /// A <see cref="List"/> + /// </returns> + public static List<Window> GetWindows () + { + if (window_list == null || window_list_update_needed) + window_list = new List<Window> (Wnck.Screen.Default.WindowsStacked); + + return window_list; + } + + /// <summary> + /// Gets the command line excec string for a PID + /// </summary> + /// <param name="pid"> + /// A <see cref="System.Int32"/> + /// </param> + /// <returns> + /// A <see cref="System.String"/> + /// </returns> + public static string CmdLineForPid (int pid) + { + string cmdline = null; + + try { + string procPath = new [] { "/proc", pid.ToString (), "cmdline" }.Aggregate (Path.Combine); + using (StreamReader reader = new StreamReader (procPath)) { + cmdline = reader.ReadLine (); + reader.Close (); + } + } catch { } + + return cmdline; + } + + public static List<Window> WindowListForCmd (string exec) + { + List<Window> windows = new List<Window> (); + if (string.IsNullOrEmpty (exec)) + return windows; + + // open office hakk + if (exec.Contains ("ooffice")) { + return GetOpenOfficeWindows (exec); + } + + exec = ProcessExecString (exec); + if (string.IsNullOrEmpty (exec)) + return windows; + + UpdateExecList (); + + foreach (KeyValuePair<int, string> kvp in exec_lines) { + if (!string.IsNullOrEmpty (kvp.Value) && kvp.Value.Contains (exec)) { + // we have a matching exec, now we just find every window whose PID matches this exec + foreach (Window window in GetWindows ()) { + if (window == null) + continue; + + // this window matches the right PID and exec string, we can match it. + bool pidMatch = window.Pid == kvp.Key || + (window.Application != null && window.Application.Pid == kvp.Key); + + if (pidMatch) + windows.Add (window); + } + } + } + + return windows.Distinct ().ToList (); + } + + static List<Window> GetOpenOfficeWindows (string exec) + { + if (exec.Contains ("writer")) { + return GetWindows ().Where ((Wnck.Window w) => w.Name.Contains ("OpenOffice.org Writer")).ToList (); + } else if (exec.Contains ("math")) { + return GetWindows ().Where ((Wnck.Window w) => w.Name.Contains ("OpenOffice.org Math")).ToList (); + } else if (exec.Contains ("calc")) { + return GetWindows ().Where ((Wnck.Window w) => w.Name.Contains ("OpenOffice.org Calc")).ToList (); + } else if (exec.Contains ("impress")) { + return GetWindows ().Where ((Wnck.Window w) => w.Name.Contains ("OpenOffice.org Impress")).ToList (); + } else if (exec.Contains ("draw")) { + return GetWindows ().Where ((Wnck.Window w) => w.Name.Contains ("OpenOffice.org Draw")).ToList (); + } else { + return new List<Window> (0); + } + } + + /// <summary> + /// This method takes in an "execution string" from proc and applies a heureustic to try + /// to magic out the name of the actual executing application. The executing binary is not + /// the desired target all the time. + /// </summary> + /// <param name="exec"> + /// A <see cref="System.String"/> + /// </param> + /// <returns> + /// A <see cref="System.String"/> + /// </returns> + static string ProcessExecString (string exec) + { + if (string.IsNullOrEmpty (exec)) + return exec; + + // lower it and trim off white space so we can abuse whitespace a bit + exec = exec.ToLower ().Trim (); + + // if the user has specified a specific mapping, we can use that here + if (RemapDictionary.ContainsKey (exec)) + return RemapDictionary [exec]; + + // this is the "split" character or the argument separator. If the string contains a null + // it was fetched from /proc/PID/cmdline and will be nicely split up. Otherwise things get a bit + // nasty, and it likely came from a .desktop file. + char splitChar = Convert.ToChar (0x0); + splitChar = exec.Contains (splitChar) ? splitChar : ' '; + + // this part is here soley for the remap file so that users may specify to remap based on just the name + // without the full path. If no remap file match is found, the net effect of this is nothing. + if (exec.StartsWith ("/")) { + string first_part = exec.Split (splitChar) [0]; + int length = first_part.Length; + first_part = first_part.Split ('/').Last (); + + if (length < exec.Length) + first_part = first_part + " " + exec.Substring (length + 1); + + if (RemapDictionary.ContainsKey (first_part)) { + return RemapDictionary [first_part]; + } + } + + string [] parts = exec.Split (splitChar); + for (int i = 0; i < parts.Length; i++) { + // we're going to use this a lot + string out_val = parts [i]; + + // arguments are useless + if (out_val.StartsWith ("-")) + continue; + + // we want the end of paths + if (out_val.Contains ("/")) + out_val = out_val.Split ('/').Last (); + + // wine apps can do it backwards... who knew? + if (out_val.Contains ("\\")) + out_val = out_val.Split ('\\').Last (); + + // null out our part if is a bad prefix + foreach (Regex regex in BadPrefixes) { + if (regex.IsMatch (out_val)) { + out_val = null; + break; + } + } + + // check if it was a bad prefix... + if (!string.IsNullOrEmpty (out_val)) { + // sometimes we hide things with shell scripts. This is the most common method of doing it. + if (out_val.EndsWith (".real")) + out_val = out_val.Substring (0, out_val.Length - ".real".Length); + + // give the remap dictionary one last shot at this + if (RemapDictionary.ContainsKey (out_val)) + out_val = RemapDictionary [out_val]; + return out_val; + } + } + return null; + } + + #endregion + } +} === added file 'WindowManager/src/Wink/WnckWindow_Extensions.cs' --- WindowManager/src/Wink/WnckWindow_Extensions.cs 1970-01-01 00:00:00 +0000 +++ WindowManager/src/Wink/WnckWindow_Extensions.cs 2009-10-11 20:48:44 +0000 @@ -0,0 +1,94 @@ +// +// Copyright (C) 2009 GNOME Do +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see <http://www.gnu.org/licenses/>. +// + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; + +using Wnck; +using WindowManager.Xlib; + +namespace WindowManager.Wink +{ + + + public static class WnckWindow_Extensions + { + public static int Area (this Wnck.Window self) + { + Gdk.Rectangle geo = self.EasyGeometry (); + return geo.Width * geo.Height; + } + + public static Gdk.Rectangle EasyGeometry (this Wnck.Window self) + { + Gdk.Rectangle geo; + self.GetGeometry (out geo.X, out geo.Y, out geo.Width, out geo.Height); + return geo; + } + + public static void SetWorkaroundGeometry (this Wnck.Window window, WindowGravity gravity, WindowMoveResizeMask mask, + int x, int y, int width, int height) + { + // This is very weird. Don't know when they will fix it. You must subtract the top and left + // frame extents from a move operation to get the window to actually show in the right spot. + // Save for maybe kwin, I think only compiz uses Viewports anyhow, so this is ok. + int [] extents = window.FrameExtents (); + + x -= extents [(int) Position.Left]; + y -= extents [(int) Position.Top]; + + window.SetGeometry (gravity, mask, x, y, width, height); + } + + public static int [] FrameExtents (this Wnck.Window window) + { + return GetCardinalProperty (window, X11Atoms.Instance._NET_FRAME_EXTENTS); + } + + public static int [] GetCardinalProperty (this Wnck.Window window, IntPtr atom) + { + X11Atoms atoms = X11Atoms.Instance; + IntPtr display; + IntPtr type; + int format; + IntPtr prop_return; + IntPtr nitems, bytes_after; + int result; + int [] extents = new int[12]; + + IntPtr window_handle = (IntPtr) window.Xid; + + display = Xlib.Xlib.GdkDisplayXDisplay (Gdk.Screen.Default.Display); + type = IntPtr.Zero; + + result = Xlib.Xlib.XGetWindowProperty (display, window_handle, atom, (IntPtr) 0, + (IntPtr) System.Int32.MaxValue, false, atoms.XA_CARDINAL, out type, out format, + out nitems, out bytes_after, out prop_return); + + if (type == atoms.XA_CARDINAL && format == 32) { + extents = new int [(int) nitems]; + for (int i = 0; i < (int) nitems; i++) { + extents [i] = Marshal.ReadInt32 (prop_return, i * IntPtr.Size); + } + } + + return extents; + } + } +} === added directory 'WindowManager/src/Xlib' === added file 'WindowManager/src/Xlib/X11Atoms.cs' --- WindowManager/src/Xlib/X11Atoms.cs 1970-01-01 00:00:00 +0000 +++ WindowManager/src/Xlib/X11Atoms.cs 2009-10-11 20:48:44 +0000 @@ -0,0 +1,336 @@ +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// +// Copyright (c) 2006 Novell, Inc. (http://www.novell.com) +// +// + +using System; + +namespace WindowManager.Xlib { + + public class X11Atoms { + + static X11Atoms instance; + public static X11Atoms Instance { + get { + if (instance == null) + instance = new X11Atoms (Gdk.Screen.Default.Display); + return instance; + } + } + + // Our atoms + public readonly IntPtr AnyPropertyType = (IntPtr)0; + public readonly IntPtr XA_PRIMARY = (IntPtr)1; + public readonly IntPtr XA_SECONDARY = (IntPtr)2; + public readonly IntPtr XA_ARC = (IntPtr)3; + public readonly IntPtr XA_ATOM = (IntPtr)4; + public readonly IntPtr XA_BITMAP = (IntPtr)5; + public readonly IntPtr XA_CARDINAL = (IntPtr)6; + public readonly IntPtr XA_COLORMAP = (IntPtr)7; + public readonly IntPtr XA_CURSOR = (IntPtr)8; + public readonly IntPtr XA_CUT_BUFFER0 = (IntPtr)9; + public readonly IntPtr XA_CUT_BUFFER1 = (IntPtr)10; + public readonly IntPtr XA_CUT_BUFFER2 = (IntPtr)11; + public readonly IntPtr XA_CUT_BUFFER3 = (IntPtr)12; + public readonly IntPtr XA_CUT_BUFFER4 = (IntPtr)13; + public readonly IntPtr XA_CUT_BUFFER5 = (IntPtr)14; + public readonly IntPtr XA_CUT_BUFFER6 = (IntPtr)15; + public readonly IntPtr XA_CUT_BUFFER7 = (IntPtr)16; + public readonly IntPtr XA_DRAWABLE = (IntPtr)17; + public readonly IntPtr XA_FONT = (IntPtr)18; + public readonly IntPtr XA_INTEGER = (IntPtr)19; + public readonly IntPtr XA_PIXMAP = (IntPtr)20; + public readonly IntPtr XA_POINT = (IntPtr)21; + public readonly IntPtr XA_RECTANGLE = (IntPtr)22; + public readonly IntPtr XA_RESOURCE_MANAGER = (IntPtr)23; + public readonly IntPtr XA_RGB_COLOR_MAP = (IntPtr)24; + public readonly IntPtr XA_RGB_BEST_MAP = (IntPtr)25; + public readonly IntPtr XA_RGB_BLUE_MAP = (IntPtr)26; + public readonly IntPtr XA_RGB_DEFAULT_MAP = (IntPtr)27; + public readonly IntPtr XA_RGB_GRAY_MAP = (IntPtr)28; + public readonly IntPtr XA_RGB_GREEN_MAP = (IntPtr)29; + public readonly IntPtr XA_RGB_RED_MAP = (IntPtr)30; + public readonly IntPtr XA_STRING = (IntPtr)31; + public readonly IntPtr XA_VISUALID = (IntPtr)32; + public readonly IntPtr XA_WINDOW = (IntPtr)33; + public readonly IntPtr XA_WM_COMMAND = (IntPtr)34; + public readonly IntPtr XA_WM_HINTS = (IntPtr)35; + public readonly IntPtr XA_WM_CLIENT_MACHINE = (IntPtr)36; + public readonly IntPtr XA_WM_ICON_NAME = (IntPtr)37; + public readonly IntPtr XA_WM_ICON_SIZE = (IntPtr)38; + public readonly IntPtr XA_WM_NAME = (IntPtr)39; + public readonly IntPtr XA_WM_NORMAL_HINTS = (IntPtr)40; + public readonly IntPtr XA_WM_SIZE_HINTS = (IntPtr)41; + public readonly IntPtr XA_WM_ZOOM_HINTS = (IntPtr)42; + public readonly IntPtr XA_MIN_SPACE = (IntPtr)43; + public readonly IntPtr XA_NORM_SPACE = (IntPtr)44; + public readonly IntPtr XA_MAX_SPACE = (IntPtr)45; + public readonly IntPtr XA_END_SPACE = (IntPtr)46; + public readonly IntPtr XA_SUPERSCRIPT_X = (IntPtr)47; + public readonly IntPtr XA_SUPERSCRIPT_Y = (IntPtr)48; + public readonly IntPtr XA_SUBSCRIPT_X = (IntPtr)49; + public readonly IntPtr XA_SUBSCRIPT_Y = (IntPtr)50; + public readonly IntPtr XA_UNDERLINE_POSITION = (IntPtr)51; + public readonly IntPtr XA_UNDERLINE_THICKNESS = (IntPtr)52; + public readonly IntPtr XA_STRIKEOUT_ASCENT = (IntPtr)53; + public readonly IntPtr XA_STRIKEOUT_DESCENT = (IntPtr)54; + public readonly IntPtr XA_ITALIC_ANGLE = (IntPtr)55; + public readonly IntPtr XA_X_HEIGHT = (IntPtr)56; + public readonly IntPtr XA_QUAD_WIDTH = (IntPtr)57; + public readonly IntPtr XA_WEIGHT = (IntPtr)58; + public readonly IntPtr XA_POINT_SIZE = (IntPtr)59; + public readonly IntPtr XA_RESOLUTION = (IntPtr)60; + public readonly IntPtr XA_COPYRIGHT = (IntPtr)61; + public readonly IntPtr XA_NOTICE = (IntPtr)62; + public readonly IntPtr XA_FONT_NAME = (IntPtr)63; + public readonly IntPtr XA_FAMILY_NAME = (IntPtr)64; + public readonly IntPtr XA_FULL_NAME = (IntPtr)65; + public readonly IntPtr XA_CAP_HEIGHT = (IntPtr)66; + public readonly IntPtr XA_WM_CLASS = (IntPtr)67; + public readonly IntPtr XA_WM_TRANSIENT_FOR = (IntPtr)68; + + public readonly IntPtr WM_PROTOCOLS; + public readonly IntPtr WM_DELETE_WINDOW; + public readonly IntPtr WM_TAKE_FOCUS; + public readonly IntPtr _NET_SUPPORTED; + public readonly IntPtr _NET_CLIENT_LIST; + public readonly IntPtr _NET_NUMBER_OF_DESKTOPS; + public readonly IntPtr _NET_DESKTOP_GEOMETRY; + public readonly IntPtr _NET_DESKTOP_VIEWPORT; + public readonly IntPtr _NET_CURRENT_DESKTOP; + public readonly IntPtr _NET_DESKTOP_NAMES; + public readonly IntPtr _NET_ACTIVE_WINDOW; + public readonly IntPtr _NET_WORKAREA; + public readonly IntPtr _NET_SUPPORTING_WM_CHECK; + public readonly IntPtr _NET_VIRTUAL_ROOTS; + public readonly IntPtr _NET_DESKTOP_LAYOUT; + public readonly IntPtr _NET_SHOWING_DESKTOP; + public readonly IntPtr _NET_CLOSE_WINDOW; + public readonly IntPtr _NET_MOVERESIZE_WINDOW; + public readonly IntPtr _NET_WM_MOVERESIZE; + public readonly IntPtr _NET_RESTACK_WINDOW; + public readonly IntPtr _NET_REQUEST_FRAME_EXTENTS; + public readonly IntPtr _NET_WM_NAME; + public readonly IntPtr _NET_WM_VISIBLE_NAME; + public readonly IntPtr _NET_WM_ICON_NAME; + public readonly IntPtr _NET_WM_VISIBLE_ICON_NAME; + public readonly IntPtr _NET_WM_DESKTOP; + public readonly IntPtr _NET_WM_WINDOW_TYPE; + public readonly IntPtr _NET_WM_STATE; + public readonly IntPtr _NET_WM_ALLOWED_ACTIONS; + public readonly IntPtr _NET_WM_STRUT; + public readonly IntPtr _NET_WM_STRUT_PARTIAL; + public readonly IntPtr _NET_WM_ICON_GEOMETRY; + public readonly IntPtr _NET_WM_ICON; + public readonly IntPtr _NET_WM_PID; + public readonly IntPtr _NET_WM_HANDLED_ICONS; + public readonly IntPtr _NET_WM_USER_TIME; + public readonly IntPtr _NET_FRAME_EXTENTS; + public readonly IntPtr _NET_WM_PING; + public readonly IntPtr _NET_WM_SYNC_REQUEST; + public readonly IntPtr _NET_SYSTEM_TRAY_ORIENTATION; + public readonly IntPtr _NET_SYSTEM_TRAY_OPCODE; + public readonly IntPtr _NET_WM_STATE_MAXIMIZED_HORZ; + public readonly IntPtr _NET_WM_STATE_MAXIMIZED_VERT; + public readonly IntPtr _XEMBED; + public readonly IntPtr _XEMBED_INFO; + public readonly IntPtr _MOTIF_WM_HINTS; + public readonly IntPtr _NET_WM_STATE_SKIP_TASKBAR; + public readonly IntPtr _NET_WM_STATE_ABOVE; + public readonly IntPtr _NET_WM_STATE_MODAL; + public readonly IntPtr _NET_WM_STATE_HIDDEN; + public readonly IntPtr _NET_WM_CONTEXT_HELP; + public readonly IntPtr _NET_WM_WINDOW_OPACITY; + public readonly IntPtr _NET_WM_WINDOW_TYPE_DESKTOP; + public readonly IntPtr _NET_WM_WINDOW_TYPE_DOCK; + public readonly IntPtr _NET_WM_WINDOW_TYPE_TOOLBAR; + public readonly IntPtr _NET_WM_WINDOW_TYPE_MENU; + public readonly IntPtr _NET_WM_WINDOW_TYPE_UTILITY; + public readonly IntPtr _NET_WM_WINDOW_TYPE_SPLASH; + public readonly IntPtr _NET_WM_WINDOW_TYPE_DIALOG; + public readonly IntPtr _NET_WM_WINDOW_TYPE_NORMAL; + public readonly IntPtr _COMPIZ_WM_WINDOW_BLUR; + public readonly IntPtr CLIPBOARD; + public readonly IntPtr PRIMARY; + public readonly IntPtr DIB; + public readonly IntPtr OEMTEXT; + public readonly IntPtr UNICODETEXT; + public readonly IntPtr TARGETS; + public readonly IntPtr PostAtom; + public readonly IntPtr AsyncAtom; + + + X11Atoms (Gdk.Display dsp) { + IntPtr display = Xlib.GdkDisplayXDisplay (dsp); + // make sure this array stays in sync with the statements below + string [] atom_names = new string[] { + "WM_PROTOCOLS", + "WM_DELETE_WINDOW", + "WM_TAKE_FOCUS", + "_NET_SUPPORTED", + "_NET_CLIENT_LIST", + "_NET_NUMBER_OF_DESKTOPS", + "_NET_DESKTOP_GEOMETRY", + "_NET_DESKTOP_VIEWPORT", + "_NET_CURRENT_DESKTOP", + "_NET_DESKTOP_NAMES", + "_NET_ACTIVE_WINDOW", + "_NET_WORKAREA", + "_NET_SUPPORTING_WM_CHECK", + "_NET_VIRTUAL_ROOTS", + "_NET_DESKTOP_LAYOUT", + "_NET_SHOWING_DESKTOP", + "_NET_CLOSE_WINDOW", + "_NET_MOVERESIZE_WINDOW", + "_NET_WM_MOVERESIZE", + "_NET_RESTACK_WINDOW", + "_NET_REQUEST_FRAME_EXTENTS", + "_NET_WM_NAME", + "_NET_WM_VISIBLE_NAME", + "_NET_WM_ICON_NAME", + "_NET_WM_VISIBLE_ICON_NAME", + "_NET_WM_DESKTOP", + "_NET_WM_WINDOW_TYPE", + "_NET_WM_STATE", + "_NET_WM_ALLOWED_ACTIONS", + "_NET_WM_STRUT", + "_NET_WM_STRUT_PARTIAL", + "_NET_WM_ICON_GEOMETRY", + "_NET_WM_ICON", + "_NET_WM_PID", + "_NET_WM_HANDLED_ICONS", + "_NET_WM_USER_TIME", + "_NET_FRAME_EXTENTS", + "_NET_WM_PING", + "_NET_WM_SYNC_REQUEST", + "_NET_SYSTEM_TRAY_OPCODE", + "_NET_SYSTEM_TRAY_ORIENTATION", + "_NET_WM_STATE_MAXIMIZED_HORZ", + "_NET_WM_STATE_MAXIMIZED_VERT", + "_NET_WM_STATE_HIDDEN", + "_XEMBED", + "_XEMBED_INFO", + "_MOTIF_WM_HINTS", + "_NET_WM_STATE_SKIP_TASKBAR", + "_NET_WM_STATE_ABOVE", + "_NET_WM_STATE_MODAL", + "_NET_WM_CONTEXT_HELP", + "_NET_WM_WINDOW_OPACITY", + "_NET_WM_WINDOW_TYPE_DESKTOP", + "_NET_WM_WINDOW_TYPE_DOCK", + "_NET_WM_WINDOW_TYPE_TOOLBAR", + "_NET_WM_WINDOW_TYPE_MENU", + "_NET_WM_WINDOW_TYPE_UTILITY", + "_NET_WM_WINDOW_TYPE_DIALOG", + "_NET_WM_WINDOW_TYPE_SPLASH", + "_NET_WM_WINDOW_TYPE_NORMAL", + "_COMPIZ_WM_WINDOW_BLUR", + "CLIPBOARD", + "PRIMARY", + "COMPOUND_TEXT", + "UTF8_STRING", + "TARGETS", + "_SWF_AsyncAtom", + "_SWF_PostMessageAtom", + "_SWF_HoverAtom", + }; + + IntPtr[] atoms = new IntPtr [atom_names.Length];; + + Xlib.XInternAtoms (display, atom_names, atom_names.Length, false, atoms); + + int off = 0; + WM_PROTOCOLS = atoms [off++]; + WM_DELETE_WINDOW = atoms [off++]; + WM_TAKE_FOCUS = atoms [off++]; + _NET_SUPPORTED = atoms [off++]; + _NET_CLIENT_LIST = atoms [off++]; + _NET_NUMBER_OF_DESKTOPS = atoms [off++]; + _NET_DESKTOP_GEOMETRY = atoms [off++]; + _NET_DESKTOP_VIEWPORT = atoms [off++]; + _NET_CURRENT_DESKTOP = atoms [off++]; + _NET_DESKTOP_NAMES = atoms [off++]; + _NET_ACTIVE_WINDOW = atoms [off++]; + _NET_WORKAREA = atoms [off++]; + _NET_SUPPORTING_WM_CHECK = atoms [off++]; + _NET_VIRTUAL_ROOTS = atoms [off++]; + _NET_DESKTOP_LAYOUT = atoms [off++]; + _NET_SHOWING_DESKTOP = atoms [off++]; + _NET_CLOSE_WINDOW = atoms [off++]; + _NET_MOVERESIZE_WINDOW = atoms [off++]; + _NET_WM_MOVERESIZE = atoms [off++]; + _NET_RESTACK_WINDOW = atoms [off++]; + _NET_REQUEST_FRAME_EXTENTS = atoms [off++]; + _NET_WM_NAME = atoms [off++]; + _NET_WM_VISIBLE_NAME = atoms [off++]; + _NET_WM_ICON_NAME = atoms [off++]; + _NET_WM_VISIBLE_ICON_NAME = atoms [off++]; + _NET_WM_DESKTOP = atoms [off++]; + _NET_WM_WINDOW_TYPE = atoms [off++]; + _NET_WM_STATE = atoms [off++]; + _NET_WM_ALLOWED_ACTIONS = atoms [off++]; + _NET_WM_STRUT = atoms [off++]; + _NET_WM_STRUT_PARTIAL = atoms [off++]; + _NET_WM_ICON_GEOMETRY = atoms [off++]; + _NET_WM_ICON = atoms [off++]; + _NET_WM_PID = atoms [off++]; + _NET_WM_HANDLED_ICONS = atoms [off++]; + _NET_WM_USER_TIME = atoms [off++]; + _NET_FRAME_EXTENTS = atoms [off++]; + _NET_WM_PING = atoms [off++]; + _NET_WM_SYNC_REQUEST = atoms [off++]; + _NET_SYSTEM_TRAY_OPCODE = atoms [off++]; + _NET_SYSTEM_TRAY_ORIENTATION = atoms [off++]; + _NET_WM_STATE_MAXIMIZED_HORZ = atoms [off++]; + _NET_WM_STATE_MAXIMIZED_VERT = atoms [off++]; + _NET_WM_STATE_HIDDEN = atoms [off++]; + _XEMBED = atoms [off++]; + _XEMBED_INFO = atoms [off++]; + _MOTIF_WM_HINTS = atoms [off++]; + _NET_WM_STATE_SKIP_TASKBAR = atoms [off++]; + _NET_WM_STATE_ABOVE = atoms [off++]; + _NET_WM_STATE_MODAL = atoms [off++]; + _NET_WM_CONTEXT_HELP = atoms [off++]; + _NET_WM_WINDOW_OPACITY = atoms [off++]; + _NET_WM_WINDOW_TYPE_DESKTOP = atoms [off++]; + _NET_WM_WINDOW_TYPE_DOCK = atoms [off++]; + _NET_WM_WINDOW_TYPE_TOOLBAR = atoms [off++]; + _NET_WM_WINDOW_TYPE_MENU = atoms [off++]; + _NET_WM_WINDOW_TYPE_UTILITY = atoms [off++]; + _NET_WM_WINDOW_TYPE_DIALOG = atoms [off++]; + _NET_WM_WINDOW_TYPE_SPLASH = atoms [off++]; + _NET_WM_WINDOW_TYPE_NORMAL = atoms [off++]; + _COMPIZ_WM_WINDOW_BLUR = atoms [off++]; + CLIPBOARD = atoms [off++]; + PRIMARY = atoms [off++]; + OEMTEXT = atoms [off++]; + UNICODETEXT = atoms [off++]; + TARGETS = atoms [off++]; + AsyncAtom = atoms [off++]; + PostAtom = atoms [off++]; + + DIB = XA_PIXMAP; + } + + } + +} + === added file 'WindowManager/src/Xlib/Xlib.cs' --- WindowManager/src/Xlib/Xlib.cs 1970-01-01 00:00:00 +0000 +++ WindowManager/src/Xlib/Xlib.cs 2009-10-11 20:48:44 +0000 @@ -0,0 +1,126 @@ +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// +// Copyright (c) 2006 Novell, Inc. (http://www.novell.com) +// +// + +using System; +using System.Text; +using System.Runtime.InteropServices; +using System.Collections.Generic; +using System.Linq; + +namespace WindowManager.Xlib { + + public enum PropertyMode + { + PropModeReplace = 0, + PropModePrepend = 1, + PropModeAppend = 2, + } + + public enum Struts + { + Left = 0, + Right = 1, + Top = 2, + Bottom = 3, + LeftStart = 4, + LeftEnd = 5, + RightStart = 6, + RightEnd = 7, + TopStart = 8, + TopEnd = 9, + BottomStart = 10, + BottomEnd = 11 + } + + public enum XGravity + { + ForgetGravity = 0, + NorthWestGravity = 1, + NorthGravity = 2, + NorthEastGravity = 3, + WestGravity = 4, + CenterGravity = 5, + EastGravity = 6, + SouthWestGravity = 7, + SouthGravity = 8, + SouthEastGravity = 9, + StaticGravity = 10, + } + + public static class Xlib { + const string libX11 = "X11"; + const string libGdkX11 = "libgdk-x11"; + + [DllImport (libGdkX11)] + static extern IntPtr gdk_x11_drawable_get_xid (IntPtr handle); + + [DllImport (libGdkX11)] + static extern IntPtr gdk_x11_drawable_get_xdisplay (IntPtr handle); + + [DllImport (libGdkX11)] + static extern IntPtr gdk_x11_display_get_xdisplay (IntPtr display); + + [DllImport (libGdkX11)] + static extern void gdk_x11_window_set_user_time (IntPtr window, uint timestamp); + + [DllImport (libX11)] + public extern static IntPtr XOpenDisplay (IntPtr display); + + [DllImport (libX11)] + public extern static int XInternAtoms (IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms); + + [DllImport (libX11)] + extern static int XChangeProperty (IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, int mode, IntPtr[] data, int nelements); + + [DllImport (libX11)] + public extern static int XGetWindowProperty (IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, + IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, + out int actual_format, out IntPtr nitems, out IntPtr bytes_after, out IntPtr prop); + + public static IntPtr GdkWindowX11Xid (Gdk.Window window) + { + return gdk_x11_drawable_get_xid (window.Handle); + } + + public static IntPtr GdkDrawableXDisplay (Gdk.Window window) + { + return gdk_x11_drawable_get_xdisplay (window.Handle); + } + + public static IntPtr GdkDisplayXDisplay (Gdk.Display display) + { + return gdk_x11_display_get_xdisplay (display.Handle); + } + + public static int XChangeProperty (Gdk.Window window, IntPtr property, IntPtr type, int mode, IntPtr[] data) + { + return XChangeProperty (GdkDrawableXDisplay (window), GdkWindowX11Xid (window), property, type, 32, mode, data, data.Length); + } + + public static void GdkWindowSetUserTime (Gdk.Window window, uint timestamp) + { + gdk_x11_window_set_user_time (window.Handle, timestamp); + } + + } +} === modified file 'configure.ac' --- configure.ac 2010-02-07 21:56:33 +0000 +++ configure.ac 2010-03-08 02:43:56 +0000 @@ -159,7 +159,7 @@ PKG_CHECK_MODULES([GDATA_SHARP_YOUTUBE], [gdata-sharp-youtube], HAVE_YOUTUBE=yes, HAVE_YOUTUBE=no) if test "x$enable_youtube" = "xyes" -a "x$HAVE_YOUTUBE" = "no"; then - AC_MSG_ERROR([YouTube support explicitly requested but dependencies no found]) + AC_MSG_ERROR([YouTube support explicitly requested but dependencies not found]) fi fi @@ -168,6 +168,25 @@ AC_SUBST([GDATA_SHARP_YOUTUBE_LIBS]) dnl}}} +dnl {{{ check for Wnck libraries +AC_ARG_ENABLE(wnck, + AC_HELP_STRING([--enable-window-manager], [Build plugin to control window (default: auto]), + enable_wnck=$enableval, + enable_wnck=auto) + +if test "x$enable_wnck" != "xno"; then + PKG_CHECK_MODULES([WNCK_SHARP_10], [wnck-sharp-1.0], HAVE_WNCK=yes, HAVE_WNCK=no) + + if test "x$enable_wnck" = "xyes" -a "x$HAVE_WNCK" = "no"; then + AC_MSG_ERROR([Window manager support explicitly requested but dependencies not found]) + fi +fi + +AM_CONDITIONAL(HAVE_WNCK, test "x$HAVE_WNCK" = "xyes") + +AC_SUBST([WNCK_SHARP_10_LIBS]) +dnl}}} + PKG_CHECK_MODULES([GCONF_SHARP_20], [gconf-sharp-2.0]) PKG_CHECK_MODULES([GLADE_SHARP_20], [glade-sharp-2.0]) PKG_CHECK_MODULES([GLIB_SHARP_20], [glib-sharp-2.0]) @@ -182,7 +201,7 @@ PKG_CHECK_MODULES([NDESK_DBUS_10], [ndesk-dbus-1.0]) PKG_CHECK_MODULES([NDESK_DBUS_GLIB_10], [ndesk-dbus-glib-1.0]) PKG_CHECK_MODULES([NOTIFY_SHARP], [notify-sharp]) -PKG_CHECK_MODULES([WNCK_SHARP_10], [wnck-sharp-1.0]) + AC_SUBST([GCONF_SHARP_20_LIBS]) AC_SUBST([GLADE_SHARP_20_LIBS]) @@ -198,18 +217,15 @@ AC_SUBST([NDESK_DBUS_10_LIBS]) AC_SUBST([NDESK_DBUS_GLIB_10_LIBS]) AC_SUBST([NOTIFY_SHARP_LIBS]) -AC_SUBST([WNCK_SHARP_10_LIBS]) dnl Do core references PKG_CHECK_MODULES([DO_PLATFORM], [do.platform >= 0.8]) PKG_CHECK_MODULES([DO_PLATFORM_LINUX], [do.platform.linux >= 0.8]) PKG_CHECK_MODULES([DO_UNIVERSE], [do.universe >= 0.8]) -PKG_CHECK_MODULES([DO_INTERFACE_WINK], [do.interface.wink >= 0.8]) AC_SUBST([DO_PLATFORM_LIBS]) AC_SUBST([DO_PLATFORM_LINUX_LIBS]) AC_SUBST([DO_UNIVERSE_LIBS]) -AC_SUBST([DO_INTERFACE_WINK_LIBS]) AC_ARG_ENABLE(debug, AC_HELP_STRING([--enable-debug], @@ -414,6 +430,7 @@ Google Calendar: ${HAVE_GCAL} Google Contacts: ${HAVE_GMAIL} Google Docs: ${HAVE_GDOCS} + Window Manager: ${HAVE_WNCK} YouTube: ${HAVE_YOUTUBE} Build/Development:
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
