3
* Author : Guillaume "iXce" Seguin
4
* Email : ixce@beryl-project.org
6
* Ported to compiz by : Patrick "marex" Niklaus
7
* Email : marex@beryl-project.org
9
* Ported to C++ by : Travis Watkins
10
* Email : amaranth@ubuntu.com
12
* Copyright (C) 2009 Guillaume Seguin
14
* This program is free software; you can redistribute it and/or
15
* modify it under the terms of the GNU General Public License
16
* as published by the Free Software Foundation; either version 2
17
* of the License, or (at your option) any later version.
19
* This program is distributed in the hope that it will be useful,
20
* but WITHOUT ANY WARRANTY; without even the implied warranty of
21
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22
* GNU General Public License for more details.
24
* You should have received a copy of the GNU General Public License
25
* along with this program; if not, write to the Free Software
26
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
31
* - Apply Edge Resistance to resize
41
COMPIZ_PLUGIN_20090315 (snap, SnapPluginVTable);
46
* Wrapper functions to avoid infinite notify loops
49
SnapWindow::move (int dx, int dy)
52
window->move (dx, dy, true);
53
screen->warpPointer (dx, dy);
58
SnapWindow::resize (int dx, int dy, int dwidth, int dheight)
60
CompWindow::Geometry geometry = window->geometry ();
62
window->resize (geometry.x () + dx, geometry.y () + dy,
63
geometry.width () + dwidth, geometry.height () + dheight,
69
SnapWindow::addEdge (Window id,
78
edge.position = position;
82
edge.screenEdge = screenEdge;
87
edges.push_back (edge);
91
* Add an edge for each rectangle of the region
94
SnapWindow::addRegionEdges (Edge *parent, CompRegion region)
96
int position, start, end;
98
foreach (const CompRect &r, region.rects ())
100
switch (parent->type)
116
addEdge (parent->id, position, start, end,
117
parent->type, parent->screenEdge);
118
edges.back ().passed = parent->passed;
122
/* Checks if a window is considered a snap window. If it's
123
* not visible, returns false. If it's a panel and we're
124
* snapping to screen edges, it's considered a snap-window.
127
#define UNLIKELY(x) __builtin_expect(!!(x),0)
130
isSnapWindow (CompWindow *w)
132
SNAP_SCREEN (screen);
136
if (!w->isViewable ())
138
if ((w->type () & SNAP_WINDOW_TYPE) &&
139
(ss->optionGetEdgesCategoriesMask () & EdgesCategoriesWindowEdgesMask))
142
(ss->optionGetEdgesCategoriesMask () & EdgesCategoriesScreenEdgesMask))
147
// Edges update functions ------------------------------------------------------
149
* Detect visible windows edges
152
SnapWindow::updateWindowsEdges ()
154
CompRegion edgeRegion, resultRegion;
158
// First add all the windows
159
foreach (CompWindow *w, screen->windows ())
162
// Just check that we're not trying to snap to current window,
163
// that the window is not invisible and of a valid type
164
if (w == window || !isSnapWindow (w))
169
input = w->borderRect ();
170
addEdge (w->id (), input.top (), input.left (),
171
input.right (), TopEdge, false);
172
addEdge (w->id (), input.bottom (), input.left (),
173
input.right (), BottomEdge, false);
174
addEdge (w->id (), input.left (), input.top (),
175
input.bottom (), LeftEdge, false);
176
addEdge (w->id (), input.right (), input.top (),
177
input.bottom (), RightEdge, false);
180
// Now strip invisible edges
181
// Loop through all the windows stack, and through all the edges
182
// If an edge has been passed, check if it's in the region window,
183
// if the edge is fully under the window, drop it, or if it's only
184
// partly covered, cut it/split it in one/two smaller visible edges
185
foreach (CompWindow *w, screen->windows ())
187
if (w == window || !isSnapWindow (w))
190
// can't use foreach here because we need the iterator for erase()
191
for (std::list<Edge>::iterator it = edges.begin (); it != edges.end (); )
198
if (e->id == w->id ())
208
rect.setGeometry (e->position,
216
rect.setGeometry (e->start,
222
// If the edge is in the window region, remove it,
223
// if it's partly in the region, split it
224
edgeRegion = CompRegion (rect);
225
resultRegion = edgeRegion - w->region ();
226
if (resultRegion.isEmpty ())
230
else if (edgeRegion != resultRegion)
232
addRegionEdges (e, resultRegion);
238
it = edges.erase (it);
250
* Loop on outputDevs and add the extents as edges
251
* Note that left side is a right edge, right side a left edge,
252
* top side a bottom edge and bottom side a top edge,
253
* since they will be snapped as the right/left/bottom/top edge of a window
256
SnapWindow::updateScreenEdges ()
258
CompRegion edgeRegion, resultRegion;
261
foreach (CompOutput output, screen->outputDevs ())
263
const CompRect& area = output.workArea ();
264
addEdge (0, area.top (), area.left (), area.right () - 1,
266
addEdge (0, area.bottom (), area.left (), area.right () - 1,
268
addEdge (0, area.left (), area.top (), area.bottom () - 1,
270
addEdge (0, area.right (), area.top (), area.bottom () - 1,
274
// Drop screen edges parts that are under struts, basically apply the
275
// same strategy than for windows edges visibility
276
foreach (CompWindow *w, screen->windows ())
278
if (w == window || !w->struts ())
281
for (std::list<Edge>::iterator it = edges.begin (); it != edges.end ();)
296
rect.setGeometry (e->position,
304
rect.setGeometry (e->start,
310
edgeRegion = CompRegion (rect);
311
resultRegion = edgeRegion - w->region ();
312
if (resultRegion.isEmpty ())
316
else if (edgeRegion != resultRegion)
318
addRegionEdges (e, resultRegion);
324
it = edges.erase (it);
336
* Clean edges and fill it again with appropriate edges
339
SnapWindow::updateEdges ()
341
SNAP_SCREEN (screen);
344
updateWindowsEdges ();
346
if (ss->optionGetEdgesCategoriesMask () & EdgesCategoriesScreenEdgesMask)
347
updateScreenEdges ();
350
// Edges checking functions (move) ---------------------------------------------
353
* Find nearest edge in the direction set by "type",
354
* w is the grabbed window, position/start/end are the window edges coordinates
355
* before : if true the window has to be before the edge (top/left being origin)
356
* snapDirection : just an helper, related to type
359
SnapWindow::moveCheckNearestEdge (int position,
366
SNAP_SCREEN (screen);
368
Edge *edge = &edges.front ();
369
int dist, min = 65535;
371
foreach (Edge ¤t, edges)
373
// Skip wrong type or outbound edges
374
if (current.type != type || current.end < start || current.start > end)
378
dist = before ? position - current.position : current.position - position;
379
// Update minimum distance if needed
380
if (dist < min && dist >= 0)
385
// 0-dist edge, just break
388
// Unsnap edges that aren't snapped anymore
389
if (current.snapped && dist > ss->optionGetResistanceDistance ())
390
current.snapped = false;
392
// We found a 0-dist edge, or we have a snapping candidate
393
if (min == 0 || (min <= ss->optionGetAttractionDistance ()
394
&& ss->optionGetSnapTypeMask () & SnapTypeEdgeAttractionMask))
396
// Update snapping data
397
if (ss->optionGetSnapTypeMask () & SnapTypeEdgeResistanceMask)
400
this->snapDirection |= snapDirection;
402
// Attract the window if needed, moving it of the correct dist
403
if (min != 0 && !edge->snapped)
405
edge->snapped = true;
428
* Call the previous function for each of the 4 sides of the window
431
SnapWindow::moveCheckEdges ()
433
CompRect input (window->borderRect ());
434
moveCheckNearestEdge (input.left (), input.top (), input.bottom (),
435
true, RightEdge, HorizontalSnap);
436
moveCheckNearestEdge (input.right (), input.top (), input.bottom (),
437
false, LeftEdge, HorizontalSnap);
438
moveCheckNearestEdge (input.top (), input.left (), input.right (),
439
true, BottomEdge, VerticalSnap);
440
moveCheckNearestEdge (input.bottom (), input.left (), input.right (),
441
false, TopEdge, VerticalSnap);
444
// Edges checking functions (resize) -------------------------------------------
447
* Similar function for Snap on Resize
450
SnapWindow::resizeCheckNearestEdge (int position,
457
SNAP_SCREEN (screen);
459
Edge *edge = &edges.front ();
460
int dist, min = 65535;
462
foreach (Edge ¤t, edges)
464
// Skip wrong type or outbound edges
465
if (current.type != type || current.end < start || current.start > end)
469
dist = before ? position - current.position : current.position - position;
470
// Update minimum distance if needed
471
if (dist < min && dist >= 0)
476
// 0-dist edge, just break
479
// Unsnap edges that aren't snapped anymore
480
if (current.snapped && dist > ss->optionGetResistanceDistance ())
481
current.snapped = false;
483
// We found a 0-dist edge, or we have a snapping candidate
484
if (min == 0 || (min <= ss->optionGetAttractionDistance ()
485
&& ss->optionGetSnapTypeMask () & SnapTypeEdgeAttractionMask))
487
// Update snapping data
488
if (ss->optionGetSnapTypeMask () & SnapTypeEdgeResistanceMask)
491
this->snapDirection |= snapDirection;
493
// FIXME : this needs resize-specific code.
494
// Attract the window if needed, moving it of the correct dist
495
if (min != 0 && !edge->snapped)
497
edge->snapped = true;
501
resize (min, 0, 0, 0);
504
resize (-min, 0, 0, 0);
507
resize (0, min, 0, 0);
510
resize (0, -min, 0, 0);
520
* Call the previous function for each of the 4 sides of the window
523
SnapWindow::resizeCheckEdges (int dx, int dy, int dwidth, int dheight)
525
CompRect input (window->borderRect ());
527
resizeCheckNearestEdge (input.left (), input.top (), input.bottom (),
528
true, RightEdge, HorizontalSnap);
529
resizeCheckNearestEdge (input.right (), input.top (), input.bottom (),
530
false, LeftEdge, HorizontalSnap);
531
resizeCheckNearestEdge (input.top (), input.left (), input.right (),
532
true, BottomEdge, VerticalSnap);
533
resizeCheckNearestEdge (input.bottom (), input.left (), input.right (),
534
false, TopEdge, VerticalSnap);
537
// Check if avoidSnap is matched, and enable/disable snap consequently
539
SnapScreen::handleEvent (XEvent *event)
541
if (event->type == screen->xkbEvent ())
543
XkbAnyEvent *xkbEvent = (XkbAnyEvent *) event;
545
if (xkbEvent->xkb_type == XkbStateNotify)
547
XkbStateNotifyEvent *stateEvent = (XkbStateNotifyEvent *) event;
549
unsigned int mods = 0xffffffff;
551
mods = avoidSnapMask;
553
if ((stateEvent->mods & mods) == mods)
560
screen->handleEvent (event);
563
// Events notifications --------------------------------------------------------
566
SnapWindow::resizeNotify (int dx, int dy, int dwidth, int dheight)
568
SNAP_SCREEN (screen);
570
window->resizeNotify (dx, dy, dwidth, dheight);
572
// avoid-infinite-notify-loop mode/not grabbed
573
if (skipNotify || !(grabbed & ResizeGrab))
576
// we have to avoid snapping but there's still some buffered moving
577
if (!ss->snapping && (m_dx || m_dy || m_dwidth || m_dheight))
579
resize (m_dx, m_dy, m_dwidth, m_dheight);
580
m_dx = m_dy = m_dwidth = m_dheight = 0;
584
// avoiding snap, nothing buffered
588
// apply edge resistance
589
if (ss->optionGetSnapTypeMask () & SnapTypeEdgeResistanceMask)
591
// If there's horizontal snapping, add dx to current buffered
592
// dx and resist (move by -dx) or release the window and move
593
// by buffered dx - dx, same for dh
594
if (snapped && snapDirection & HorizontalSnap)
597
if (m_dx < ss->optionGetResistanceDistance ()
598
&& m_dx > -ss->optionGetResistanceDistance ())
600
resize (-dx, 0, 0, 0);
604
resize (m_dx - dx, 0, 0, 0);
607
snapDirection &= VerticalSnap;
610
if (m_dwidth < ss->optionGetResistanceDistance ()
611
&& m_dwidth > -ss->optionGetResistanceDistance ())
613
resize (0, 0, -dwidth, 0);
617
resize (0, 0, m_dwidth - dwidth, 0);
620
snapDirection &= VerticalSnap;
624
// Same for vertical snapping and dy/dh
625
if (snapped && snapDirection & VerticalSnap)
628
if (m_dy < ss->optionGetResistanceDistance ()
629
&& m_dy > -ss->optionGetResistanceDistance ())
631
resize (0, -dy, 0, 0);
635
resize (0, m_dy - dy, 0, 0);
638
snapDirection &= HorizontalSnap;
640
m_dheight += dheight;
641
if (m_dheight < ss->optionGetResistanceDistance ()
642
&& m_dheight > -ss->optionGetResistanceDistance ())
644
resize (0, 0, 0, -dheight);
648
resize (0, 0, 0, m_dheight - dheight);
651
snapDirection &= HorizontalSnap;
654
// If we are no longer snapping in any direction, reset snapped
655
if (snapped && !snapDirection)
659
// If we don't already snap vertically and horizontally,
660
// check edges status
661
if (snapDirection != (VerticalSnap | HorizontalSnap))
662
resizeCheckEdges (dx, dy, dwidth, dheight);
666
SnapWindow::moveNotify (int dx, int dy, bool immediate)
668
SNAP_SCREEN (screen);
670
window->moveNotify (dx, dy, immediate);
672
// avoid-infinite-notify-loop mode/not grabbed
673
if (skipNotify || !(grabbed & MoveGrab))
676
// we have to avoid snapping but there's still some buffered moving
677
if (!ss->snapping && (m_dx || m_dy))
684
// avoiding snap, nothing buffered
688
// apply edge resistance
689
if (ss->optionGetSnapTypeMask () & SnapTypeEdgeResistanceMask)
691
// If there's horizontal snapping, add dx to current buffered
692
// dx and resist (move by -dx) or release the window and move
693
// by buffered dx - dx
694
if (snapped && snapDirection & HorizontalSnap)
697
if (m_dx < ss->optionGetResistanceDistance ()
698
&& m_dx > -ss->optionGetResistanceDistance ())
706
snapDirection &= VerticalSnap;
709
// Same for vertical snapping and dy
710
if (snapped && snapDirection & VerticalSnap)
713
if (m_dy < ss->optionGetResistanceDistance ()
714
&& m_dy > -ss->optionGetResistanceDistance ())
722
snapDirection &= HorizontalSnap;
725
// If we are no longer snapping in any direction, reset snapped
726
if (snapped && !snapDirection)
729
// If we don't already snap vertically and horizontally,
730
// check edges status
731
if (snapDirection != (VerticalSnap | HorizontalSnap))
736
* Initiate snap, get edges
739
SnapWindow::grabNotify (int x, int y, unsigned int state, unsigned int mask)
741
grabbed = (mask & CompWindowGrabResizeMask) ? ResizeGrab : MoveGrab;
744
window->grabNotify (x, y, state, mask);
748
* Clean edges data, reset dx/dy to avoid buggy moves
749
* when snap will be triggered again.
752
SnapWindow::ungrabNotify ()
759
m_dx = m_dy = m_dwidth = m_dheight = 0;
761
window->ungrabNotify ();
764
// Internal stuff --------------------------------------------------------------
767
SnapScreen::optionChanged (CompOption *opt, SnapOptions::Options num)
771
case SnapOptions::AvoidSnap:
773
unsigned int mask = optionGetAvoidSnapMask ();
775
if (mask & AvoidSnapShiftMask)
776
avoidSnapMask |= ShiftMask;
777
if (mask & AvoidSnapAltMask)
778
avoidSnapMask |= CompAltMask;
779
if (mask & AvoidSnapControlMask)
780
avoidSnapMask |= ControlMask;
781
if (mask & AvoidSnapMetaMask)
782
avoidSnapMask |= CompMetaMask;
790
SnapScreen::SnapScreen (CompScreen *screen) :
791
PluginClassHandler <SnapScreen, CompScreen> (screen),
796
ScreenInterface::setHandler (screen);
798
#define setNotify(func) \
799
optionSet##func##Notify (boost::bind (&SnapScreen::optionChanged, this, _1, _2))
801
setNotify (AvoidSnap);
804
SnapWindow::SnapWindow (CompWindow *window) :
805
PluginClassHandler <SnapWindow, CompWindow> (window),
816
WindowInterface::setHandler (window);
819
SnapWindow::~SnapWindow ()
824
SnapPluginVTable::init ()
826
if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION))
added
removed
snap/src/snap.cpp
