void UpdateWindowIntersect()
{
Gdk.Rectangle adjustedDockArea = intersect_area;
adjustedDockArea.Inflate(-2, -2);
bool intersect = false;
Wnck.Window activeWindow = screen.ActiveWindow;
try {
foreach (Wnck.Window window in screen.Windows.Where(w => IsIntersectableWindow(w)))
{
if (Behavior == AutohideType.Intellihide && activeWindow != null && activeWindow.Pid != window.Pid)
{
continue;
}
if (window.EasyGeometry().IntersectsWith(adjustedDockArea))
{
intersect = true;
break;
}
}
} catch (Exception e) {
Log <AutohideManager> .Error("Failed to update window intersect: '{0}'", e.Message);
Log <AutohideManager> .Debug(e.StackTrace);
}
if (WindowIntersectingOther != intersect)
{
WindowIntersectingOther = intersect;
SetHidden();
}
}
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);
}
void HandleGeometryChanged(object sender, EventArgs e)
{
Wnck.Window window = sender as Wnck.Window;
if (sender == null)
{
return;
}
Gdk.Rectangle geo = window.EasyGeometry();
if (geo == last_known_geo)
{
return;
}
last_known_geo = geo;
if (timer_geometry > 0)
{
return;
}
timer_geometry = GLib.Timeout.Add(updateDelay, delegate {
UpdateWindowIntersect();
timer_geometry = 0;
return(false);
});
}
public static void UnmaximizeWindows(Wnck.Window window)
{
if (window.IsMaximized)
{
window.Unmaximize();
}
}
void SetupActiveWindow()
{
Wnck.Window active = screen.ActiveWindow;
if (active != null)
{
active.GeometryChanged += HandleGeometryChanged;
last_known_geo = active.EasyGeometry();
}
}
void HandleUnmatchedWindowNameChanged(object sender, EventArgs e)
{
Wnck.Window window = (sender as Wnck.Window);
if (DockServices.WindowMatcher.WindowIsReadyForMatch(window))
{
window.NameChanged -= HandleUnmatchedWindowNameChanged;
longMatchInProgress = false;
UpdateTransientItems();
}
}
public WindowDockItem(Wnck.Window baseWindow)
{
base_window = baseWindow;
id = baseWindow.Name + baseWindow.Pid;
UpdateWindows(baseWindow);
SetNameAndIcon();
Wnck.Screen.Default.WindowOpened += WnckScreenDefaultWindowOpened;
Wnck.Screen.Default.WindowClosed += WnckScreenDefaultWindowClosed;
}
void WnckScreenDefaultWindowClosed (object o, WindowClosedArgs args)
{
if (base_window == args.Window)
base_window = ManagedWindows
.Where (w => w != args.Window)
.DefaultIfEmpty (null)
.FirstOrDefault ();
UpdateWindows (base_window);
SetNameAndIcon ();
}
public WindowDockItem (Wnck.Window baseWindow)
{
base_window = baseWindow;
id = baseWindow.Name + baseWindow.Pid;
UpdateWindows (baseWindow);
SetNameAndIcon ();
Wnck.Screen.Default.WindowOpened += WnckScreenDefaultWindowOpened;
Wnck.Screen.Default.WindowClosed += WnckScreenDefaultWindowClosed;
}
bool IsIntersectableWindow(Wnck.Window window)
{
return(window != null &&
!window.IsMinimized &&
window.Pid != pid &&
window.WindowType != Wnck.WindowType.Desktop &&
window.WindowType != Wnck.WindowType.Dock &&
window.WindowType != Wnck.WindowType.Splashscreen &&
window.WindowType != Wnck.WindowType.Menu &&
Wnck.Screen.Default.ActiveWorkspace != null &&
window.IsVisibleOnWorkspace(Wnck.Screen.Default.ActiveWorkspace));
}
void UpdateWindows(Wnck.Window baseWindow)
{
if (baseWindow != null)
{
Windows = DockServices.WindowMatcher.SimilarWindows(baseWindow)
.Where(w => !FileApplicationProvider.ManagedWindows.Contains(w));
}
else
{
Windows = Enumerable.Empty <Wnck.Window> ();
}
}
void RestoreTemporaryWindowGeometry(Wnck.Window window, Dictionary <Wnck.Window, WindowState> state)
{
if (!state.ContainsKey(window))
{
return;
}
WindowState currentState = state [window];
window.SetWorkaroundGeometry(WindowGravity.Current, MoveResizeMask,
currentState.Area.X - parent.ViewportX, currentState.Area.Y - parent.ViewportY,
currentState.Area.Width, currentState.Area.Height);
}
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);
}
void WnckScreenDefaultWindowClosed(object o, WindowClosedArgs args)
{
if (base_window == args.Window)
{
base_window = ManagedWindows
.Where(w => w != args.Window)
.DefaultIfEmpty(null)
.FirstOrDefault();
}
UpdateWindows(base_window);
SetNameAndIcon();
}
bool WindowCenterInViewport(Wnck.Window window)
{
if (!window.IsOnWorkspace(parent))
{
return(false);
}
Rectangle geo = window.EasyGeometry();
geo.X += parent.ViewportX;
geo.Y += parent.ViewportY;
return(area.Contains(new Point(geo.X + geo.Width / 2, geo.Y + geo.Height / 2)));
}
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);
}
protected override void OnScrolled(Gdk.ScrollDirection direction, Gdk.ModifierType mod)
{
int count = ManagedWindows.Count();
if (count < 1 || (DateTime.UtcNow - last_scroll) < scroll_rate)
{
return;
}
last_scroll = DateTime.UtcNow;
// This block will make sure that if we're scrolling on an app that is already active
// that when we scroll we move on the next window instead of appearing to do nothing
Wnck.Window focused = ManagedWindows.Where(w => w.IsActive).FirstOrDefault();
if (focused != null)
{
for (; last_raised < count - 1; last_raised++)
{
if (ManagedWindows.ElementAt(last_raised).Pid == focused.Pid)
{
break;
}
}
}
switch (direction)
{
case ScrollDirection.Up:
case ScrollDirection.Right:
last_raised++;
break;
case ScrollDirection.Down:
case ScrollDirection.Left:
last_raised--;
break;
}
if (last_raised < 0)
{
last_raised = count - 1;
}
else if (last_raised >= count)
{
last_raised = 0;
}
ManagedWindows.ElementAt(last_raised).CenterAndFocusWindow();
}
void SetTemporaryWindowGeometry(Wnck.Window window, Gdk.Rectangle area, Dictionary <Wnck.Window, WindowState> state)
{
Gdk.Rectangle oldGeo = window.EasyGeometry();
oldGeo.X += parent.ViewportX;
oldGeo.Y += parent.ViewportY;
state [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 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);
}
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);
}
}
static bool WindowsShareViewport(Wnck.Window first, Wnck.Window second)
{
if (first == null || second == null)
{
return(false);
}
Wnck.Workspace wksp = first.Workspace ?? second.Workspace;
if (wksp == null)
{
return(false);
}
Gdk.Rectangle firstGeo, secondGeo;
first.GetGeometry(out firstGeo.X, out firstGeo.Y, out firstGeo.Width, out firstGeo.Height);
second.GetGeometry(out secondGeo.X, out secondGeo.Y, out secondGeo.Width, out secondGeo.Height);
firstGeo.X += wksp.ViewportX;
firstGeo.Y += wksp.ViewportY;
secondGeo.X += wksp.ViewportX;
secondGeo.Y += wksp.ViewportY;
int viewportWidth, viewportHeight;
viewportWidth = first.Screen.Width;
viewportHeight = first.Screen.Height;
int firstViewportX = ((firstGeo.X + firstGeo.Width / 2) / viewportWidth) * viewportWidth;
int firstViewportY = ((firstGeo.Y + firstGeo.Height / 2) / viewportHeight) * viewportHeight;
Gdk.Rectangle viewpRect = new Gdk.Rectangle(firstViewportX, firstViewportY,
viewportWidth, viewportHeight);
return(viewpRect.IntersectsWith(secondGeo));
}
public static int Area(this Wnck.Window self)
{
Gdk.Rectangle geo = self.EasyGeometry();
return(geo.Width * geo.Height);
}
public static int [] FrameExtents(this Wnck.Window window)
{
return(GetCardinalProperty(window, X11Atoms.Instance._NET_FRAME_EXTENTS));
}
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);
}
