← Back to branch summary

~hypodermia/ubuntu/oneiric/compiz/fix-for-bug-301174

« back to all changes in this revision

Viewing changes to .pc/01_bzr_fix_grid_premultiply.patch/plugins/grid/src/grid.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2011-04-07 18:06:44 UTC
  • mfrom: (0.168.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20110407180644-7xwnirf7k3zotc2w
Tags: 1:0.9.4+bzr20110407-0ubuntu2
https://launchpad.net/bugs/711561
https://launchpad.net/bugs/752711
* New upstream snapshot:
  - fix unity-window-decorator crashed with SIGSEGV in event_filter_funct
    (LP: #711561)
* debian/patches/086_new_grid_defaults.patch:
  - change threshold to 15 on sides and 20 on top to work well with the new
    animtion
* debian/patches/01_bzr_fix_grid_on_multimonitor.patch,
  01_bzr_fix_resize.patch, 01_bzr_fix_grid_premultiply.patch:
  - from upstream bzr, fix grid on multimonitor and colors handling
* debian/patches/086_new_grid_defaults.patch,
  debian/patches/029_default_options.patch:
  - set the resize grid shadow to orange (LP: #752711)

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/01_bzr_fix_grid_premultiply.patch/plugins/grid/src/grid.cpp
 
1
/*
 
2
 * Compiz Fusion Grid plugin
 
3
 *
 
4
 * Copyright (c) 2008 Stephen Kennedy <suasol@gmail.com>
 
5
 * Copyright (c) 2010 Scott Moreau <oreaus@gmail.com>
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or
 
8
 * modify it under the terms of the GNU General Public License
 
9
 * as published by the Free Software Foundation; either version 2
 
10
 * of the License, or (at your option) any later version.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * Description:
 
18
 *
 
19
 * Plugin to act like winsplit revolution (http://www.winsplit-revolution.com/)
 
20
 * use <Control><Alt>NUMPAD_KEY to move and tile your windows.
 
21
 *
 
22
 * Press the tiling keys several times to cycle through some tiling options.
 
23
 */
 
24
 
 
25
#include "grid.h"
 
26
 
 
27
bool compositingActive;
 
28
 
 
29
static const GridProps gridProps[] =
 
30
{
 
31
    {0,1, 1,1},
 
32
 
 
33
    {0,1, 2,2},
 
34
    {0,1, 1,2},
 
35
    {1,1, 2,2},
 
36
 
 
37
    {0,0, 2,1},
 
38
    {0,0, 1,1},
 
39
    {1,0, 2,1},
 
40
 
 
41
    {0,0, 2,2},
 
42
    {0,0, 1,2},
 
43
    {1,0, 2,2},
 
44
 
 
45
    {0,0, 1,1},
 
46
};
 
47
 
 
48
GridRectangle
 
49
GridRectangle::subtractBorders (CompWindow      *w) const
 
50
{
 
51
    return CompRect (x () + w->border ().left,
 
52
                     y () + w->border ().top,
 
53
                     width () - (w->border ().left + w->border ().right),
 
54
                     height () - (w->border ().top + w->border ().bottom));
 
55
}
 
56
 
 
57
GridRectangle
 
58
GridRectangle::addBorders (CompWindow      *w) const
 
59
{
 
60
    return CompRect (x () - w->border ().left,
 
61
                     y () - w->border ().top,
 
62
                     width () + (w->border ().left + w->border ().right),
 
63
                     height () + (w->border ().top + w->border ().bottom));
 
64
}
 
65
 
 
66
GridRectangle
 
67
GridWindow::constrainSize (const GridRectangle& slot)
 
68
{
 
69
    GridRectangle result = slot.subtractBorders (window);
 
70
    CompRect wa = screen->outputDevs ().at (screen->outputDeviceForGeometry (window->serverGeometry ())).workArea ();
 
71
    int      cw, ch;
 
72
 
 
73
    if (window->constrainNewWindowSize (result.width (), result.height (), &cw, &ch))
 
74
    {
 
75
        /* constrained size may put window offscreen, adjust for that case */
 
76
        int dx = result.x () + cw - wa.right () + window->border ().right;
 
77
        int dy = result.y () + ch - wa.bottom () + window->border ().bottom;
 
78
 
 
79
        if (dx > 0)
 
80
            result.setX (result.x () - dx);
 
81
        if (dy > 0)
 
82
            result.setY (result.y () - dy);
 
83
 
 
84
        /* constrainment may leave gaps between the edges of the screen
 
85
         * and the window borders ... in that case center the window so
 
86
         * that these gaps are even */
 
87
 
 
88
        if (result.width () != cw)
 
89
            result.setX (result.x () + ((result.width () - cw) / 2));
 
90
 
 
91
        if (result.height () != ch)
 
92
            result.setY (result.y () + ((result.height () - ch) / 2));
 
93
 
 
94
        result.setWidth (cw);
 
95
        result.setHeight (ch);
 
96
    }
 
97
 
 
98
    return result.addBorders (window);
 
99
}
 
100
 
 
101
bool
 
102
GridWindow::allowGrid (GridType where)
 
103
{
 
104
    /* Don't grid windows that can't be resized */
 
105
    if (!(window->actions () & CompWindowActionResizeMask))
 
106
        return false;
 
107
 
 
108
    if (where == GridMaximize)
 
109
    {
 
110
        if (!(window->actions () & (CompWindowActionMaximizeHorzMask | CompWindowActionMaximizeVertMask)))
 
111
            return false;
 
112
 
 
113
        /* Don't maximize windows twice */
 
114
        if (window->state () & (MAXIMIZE_STATE))
 
115
            return false;
 
116
    }
 
117
 
 
118
    return true;
 
119
 
 
120
}
 
121
 
 
122
bool
 
123
GridScreen::initiateCommon (CompAction         *action,
 
124
                            CompAction::State  state,
 
125
                            CompOption::Vector &option,
 
126
                            GridType           where,
 
127
                            bool               resize)
 
128
{
 
129
    Window     xid;
 
130
    CompWindow *cw = 0;
 
131
 
 
132
    xid = CompOption::getIntOptionNamed (option, "window");
 
133
    cw  = screen->findWindow (xid);
 
134
 
 
135
    if (where == GridUnknown)
 
136
    {
 
137
        if (desiredSlot)
 
138
        {
 
139
            delete desiredSlot;
 
140
            desiredSlot = NULL;
 
141
        }
 
142
 
 
143
        return false;
 
144
    }
 
145
    else if (screen->otherGrabExist ("move", NULL))
 
146
        return false;
 
147
 
 
148
    if (cw)
 
149
    {
 
150
        XWindowChanges xwc;
 
151
 
 
152
        GRID_WINDOW (cw);
 
153
 
 
154
        if (!gw->allowGrid (where))
 
155
            return false;
 
156
 
 
157
        if (gw->lastTarget != where)
 
158
            gw->resizeCount = 0;
 
159
 
 
160
        props = gridProps[where];
 
161
 
 
162
        /* get current available area */
 
163
        if (cw == mGrabWindow)
 
164
            workarea = screen->getWorkareaForOutput
 
165
                            (screen->outputDeviceForPoint (pointerX, pointerY));
 
166
        else
 
167
        {
 
168
            workarea = screen->getWorkareaForOutput (cw->outputDevice ());
 
169
 
 
170
            if (!gw->isGridResized)
 
171
                /* Store size not including borders when using a keybinding */
 
172
                gw->originalSize = (CompRect &) cw->serverGeometry ();
 
173
        }
 
174
 
 
175
        if ((cw->state () & MAXIMIZE_STATE) &&
 
176
            (resize || optionGetSnapoffMaximized ()))
 
177
        {
 
178
            /* maximized state interferes with us, clear it */
 
179
            cw->maximize (0);
 
180
        }
 
181
 
 
182
        if (where == GridMaximize && resize)
 
183
        {
 
184
            /* move the window to the correct output */
 
185
            if (cw == mGrabWindow)
 
186
            {
 
187
                xwc.x = workarea.x () + 50;
 
188
                xwc.y = workarea.y () + 50;
 
189
                xwc.width = workarea.width ();
 
190
                xwc.height = workarea.height ();
 
191
                cw->configureXWindow (CWX | CWY, &xwc);
 
192
            }
 
193
 
 
194
            cw->maximize (MAXIMIZE_STATE);
 
195
            gw->isGridResized = true;
 
196
            gw->isGridMaximized = true;
 
197
 
 
198
            return true;
 
199
        }
 
200
 
 
201
        /* Should really be three different types here, but not enough time
 
202
         * to implement that one FIXME */
 
203
        if (!desiredSlot)
 
204
        {
 
205
            if (resize)
 
206
            {
 
207
                desiredSlot = new PaintableAnimatedGridRectangle ();
 
208
 
 
209
                if (!desiredSlot)
 
210
                    return false;
 
211
            }
 
212
            else
 
213
            {
 
214
                CompRect sbr = cw->serverBorderRect ();
 
215
                if (compositingActive)
 
216
                {
 
217
                    CompRect sbr = cw->serverBorderRect ();
 
218
                    desiredSlot = new PaintableAnimatedGridRectangle ();
 
219
 
 
220
                    if (!desiredSlot)
 
221
                        return false;
 
222
                }
 
223
                else
 
224
                {
 
225
                    desiredSlot = new PaintableAnimatedGridRectangle ();
 
226
 
 
227
                    if (!desiredSlot)
 
228
                        return false;
 
229
                }
 
230
 
 
231
                ((AnimatedGridRectangle *) desiredSlot)->setFrom (sbr);
 
232
            }
 
233
        }
 
234
 
 
235
        /* Convention:
 
236
         * xxxSlot include decorations (it's the screen area occupied)
 
237
         * xxxRect are undecorated (it's the constrained position
 
238
                                    of the contents)
 
239
         */
 
240
 
 
241
        /* slice and dice to get desired slot - including decorations */
 
242
        desiredSlot->setY (workarea.y () + props.gravityDown *
 
243
                          (workarea.height () / props.numCellsY));
 
244
        desiredSlot->setHeight (workarea.height () / props.numCellsY);
 
245
        desiredSlot->setX (workarea.x () + props.gravityRight *
 
246
                          (workarea.width () / props.numCellsX));
 
247
        desiredSlot->setWidth (workarea.width () / props.numCellsX);
 
248
 
 
249
        /* Adjust for constraints and decorations */
 
250
        desiredRect = gw->constrainSize (*desiredSlot).subtractBorders (cw);
 
251
        /* Get current rect not including decorations */
 
252
        currentRect.setGeometry (cw->serverX (), cw->serverY (),
 
253
                                 cw->serverWidth (),
 
254
                                 cw->serverHeight ());
 
255
 
 
256
        if (desiredRect.y () == currentRect.y () &&
 
257
            desiredRect.height () == currentRect.height () &&
 
258
            where != GridMaximize && gw->lastTarget == where)
 
259
        {
 
260
            int slotWidth25  = workarea.width () / 4;
 
261
            int slotWidth33  = (workarea.width () / 3) + cw->border ().left;
 
262
            int slotWidth17  = slotWidth33 - slotWidth25;
 
263
            int slotWidth66  = workarea.width () - slotWidth33;
 
264
            int slotWidth75  = workarea.width () - slotWidth25;
 
265
 
 
266
            if (props.numCellsX == 2) /* keys (1, 4, 7, 3, 6, 9) */
 
267
            {
 
268
                if ((currentRect.width () == desiredRect.width () &&
 
269
                    currentRect.x () == desiredRect.x ()) ||
 
270
                    (gw->resizeCount < 1) || (gw->resizeCount > 5))
 
271
                    gw->resizeCount = 3;
 
272
 
 
273
                /* tricky, have to allow for window constraints when
 
274
                 * computing what the 33% and 66% offsets would be
 
275
                 */
 
276
                switch (gw->resizeCount)
 
277
                {
 
278
                    case 1:
 
279
                        desiredSlot->setWidth (slotWidth66);
 
280
                        desiredSlot->setX (workarea.x () +
 
281
                                          props.gravityRight * slotWidth33);
 
282
                        gw->resizeCount++;
 
283
                        break;
 
284
                    case 2:
 
285
                        gw->resizeCount++;
 
286
                        break;
 
287
                    case 3:
 
288
                        desiredSlot->setWidth (slotWidth33);
 
289
                        desiredSlot->setX (workarea.x () +
 
290
                                          props.gravityRight * slotWidth66);
 
291
                        gw->resizeCount++;
 
292
                        break;
 
293
                    case 4:
 
294
                        desiredSlot->setWidth (slotWidth25);
 
295
                        desiredSlot->setX (workarea.x () +
 
296
                                          props.gravityRight * slotWidth75);
 
297
                        gw->resizeCount++;
 
298
                        break;
 
299
                    case 5:
 
300
                        desiredSlot->setWidth (slotWidth75);
 
301
                        desiredSlot->setX (workarea.x () +
 
302
                                          props.gravityRight * slotWidth25);
 
303
                        gw->resizeCount++;
 
304
                        break;
 
305
                    default:
 
306
                        break;
 
307
                }
 
308
            }
 
309
            else /* keys (2, 5, 8) */
 
310
            {
 
311
 
 
312
                if ((currentRect.width () == desiredRect.width () &&
 
313
                    currentRect.x () == desiredRect.x ()) ||
 
314
                    (gw->resizeCount < 1) || (gw->resizeCount > 5))
 
315
                    gw->resizeCount = 1;
 
316
            
 
317
                switch (gw->resizeCount)
 
318
                {
 
319
                    case 1:
 
320
                        desiredSlot->setWidth (workarea.width () -
 
321
                                             (slotWidth17 * 2));
 
322
                        desiredSlot->setX (workarea.x () + slotWidth17);
 
323
                        gw->resizeCount++;
 
324
                        break;
 
325
                    case 2:
 
326
                        desiredSlot->setWidth ((slotWidth25 * 2) +
 
327
                                              (slotWidth17 * 2));
 
328
                        desiredSlot->setX (workarea.x () +
 
329
                                         (slotWidth25 - slotWidth17));
 
330
                        gw->resizeCount++;
 
331
                        break;
 
332
                    case 3:
 
333
                        desiredSlot->setWidth ((slotWidth25 * 2));
 
334
                        desiredSlot->setX (workarea.x () + slotWidth25);
 
335
                        gw->resizeCount++;
 
336
                        break;
 
337
                    case 4:
 
338
                        desiredSlot->setWidth (slotWidth33 -
 
339
                            (cw->border ().left + cw->border ().right));
 
340
                        desiredSlot->setX (workarea.x () + slotWidth33);
 
341
                        gw->resizeCount++;
 
342
                        break;
 
343
                    case 5:
 
344
                        gw->resizeCount++;
 
345
                        break;
 
346
                    default:
 
347
                        break;
 
348
                }
 
349
            }
 
350
 
 
351
            if (gw->resizeCount == 6)
 
352
                gw->resizeCount = 1;
 
353
 
 
354
            desiredRect = gw->constrainSize (*desiredSlot).subtractBorders (cw);
 
355
        }
 
356
 
 
357
        /* TODO: animate move+resize */
 
358
        if (resize)
 
359
        {
 
360
            xwc.x = desiredRect.x ();
 
361
            xwc.y = desiredRect.y ();
 
362
            xwc.width  = desiredRect.width ();
 
363
            xwc.height = desiredRect.height ();
 
364
 
 
365
            /* Store a copy of xwc since configureXWindow changes it's values */
 
366
            XWindowChanges wc = xwc;
 
367
            unsigned int   flags = (CWX | CWY | CWWidth | CWHeight);
 
368
 
 
369
            if (cw->mapNum ())
 
370
                cw->sendSyncRequest ();
 
371
 
 
372
            delete desiredSlot;
 
373
            desiredSlot = NULL;
 
374
 
 
375
            cw->configureXWindow (flags, &xwc);
 
376
            gw->isGridResized = true;
 
377
            gw->isGridMaximized = false;
 
378
        }
 
379
 
 
380
        gw->lastTarget = where;
 
381
    }
 
382
 
 
383
    return true;
 
384
}
 
385
 
 
386
CompRect
 
387
AnimatedGridRectangle::current ()
 
388
{
 
389
    /* Expand edges out to destination rect based on progress */
 
390
 
 
391
    CompRect ret = mFrom;
 
392
 
 
393
    ret.setTop (floor (mFrom.top () + (top () - mFrom.top ()) * mProgress));
 
394
    ret.setLeft (floor (mFrom.left () + (left () - mFrom.left ()) * mProgress));
 
395
    ret.setRight (floor (mFrom.right () + (right () - mFrom.right ()) * mProgress));
 
396
    ret.setBottom (floor (mFrom.bottom () + (bottom () - mFrom.bottom ()) * mProgress));
 
397
 
 
398
    return ret;
 
399
}
 
400
 
 
401
float
 
402
AnimatedGridRectangle::progress ()
 
403
{
 
404
    return mProgress;
 
405
}
 
406
 
 
407
void
 
408
AnimatedGridRectangle::setTime (unsigned int t)
 
409
{
 
410
    mTime = t;
 
411
}
 
412
 
 
413
void
 
414
AnimatedGridRectangle::setFrom (CompRect &f)
 
415
{
 
416
    mFrom = f;
 
417
}
 
418
 
 
419
void
 
420
AnimatedGridRectangle::setProgress (float p)
 
421
{
 
422
    mProgress = p;
 
423
 
 
424
    if (mProgress >= 1.0f)
 
425
        mProgress = 1.0f;
 
426
    else if (mProgress <= 0.0f)
 
427
        mProgress = 0.0f;
 
428
}
 
429
 
 
430
void
 
431
AnimatedGridRectangle::reset ()
 
432
{
 
433
    mProgress = 0.0f;
 
434
}
 
435
 
 
436
void
 
437
PaintableAnimatedGridRectangle::paint (const GLMatrix &mat)
 
438
{
 
439
    CompRect outline;
 
440
    CompRect fill = current ();
 
441
    GridScreen *gScreen = GridScreen::get (screen);
 
442
 
 
443
    if (gScreen->optionGetIndicatorType () == GridOptions::IndicatorTypeOutline)
 
444
    {
 
445
        GLint origSrc, origDst;
 
446
        CompOutput *o = &screen->outputDevs ().at (screen->outputDeviceForPoint (CompPoint (pointerX, pointerY)));
 
447
        float alpha = (float) gScreen->optionGetFillColorAlpha () / 65535.0f * progress ();
 
448
        
 
449
        glGetIntegerv (GL_BLEND_SRC, &origSrc);
 
450
        glGetIntegerv (GL_BLEND_DST, &origDst);
 
451
 
 
452
        glPushMatrix ();
 
453
 
 
454
        glLoadMatrixf (mat.getMatrix ());
 
455
 
 
456
        glDisableClientState (GL_TEXTURE_COORD_ARRAY);
 
457
        glEnable (GL_BLEND);
 
458
        glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
459
        
 
460
        glScissor (o->x (), screen->height () - o->y (), o->width (), o->height ());
 
461
 
 
462
        /* fill rectangle */
 
463
        glColor4f (((float) gScreen->optionGetFillColorRed () / 65535.0f) * alpha,
 
464
                   ((float) gScreen->optionGetFillColorGreen () / 65535.0f) * alpha,
 
465
                   ((float) gScreen->optionGetFillColorBlue () / 65535.0f) * alpha,
 
466
                   alpha);
 
467
        glRecti (fill.x1 (), fill.y2 (), fill.x2 (), fill.y1 ());
 
468
 
 
469
        /* Set outline rect smaller to avoid damage issues */
 
470
        outline.setGeometry (fill.x () + 1, fill.y () + 1,
 
471
                          fill.width () - 2,fill. height () - 2);
 
472
 
 
473
        /* draw outline */
 
474
        glColor4f ((float) gScreen->optionGetOutlineColorRed () / 65535.0f,
 
475
                   (float) gScreen->optionGetOutlineColorGreen () / 65535.0f,
 
476
                   (float) gScreen->optionGetOutlineColorBlue () / 65535.0f,
 
477
                   ((float) gScreen->optionGetOutlineColorAlpha () / 65535.0f) * progress ());
 
478
        glLineWidth (2.0);
 
479
        glBegin (GL_LINE_LOOP);
 
480
        glVertex2i (outline.x1 (), outline.y1 ());
 
481
        glVertex2i (outline.x2 (), outline.y1 ());
 
482
        glVertex2i (outline.x2 (), outline.y2 ());
 
483
        glVertex2i (outline.x1 (), outline.y2 ());
 
484
        glEnd ();
 
485
 
 
486
        /* clean up */
 
487
        glColor4usv (defaultColor);
 
488
        glBlendFunc (origSrc, origDst);
 
489
        glDisable (GL_BLEND);
 
490
        glEnableClientState (GL_TEXTURE_COORD_ARRAY);
 
491
        glPopMatrix ();
 
492
    }
 
493
}
 
494
 
 
495
bool
 
496
GridScreen::glPaintOutput (const GLScreenPaintAttrib &attrib,
 
497
                           const GLMatrix            &matrix,
 
498
                           const CompRegion          &region,
 
499
                           CompOutput                *output,
 
500
                           unsigned int              mask)
 
501
{
 
502
    bool     status;
 
503
    
 
504
    mAllowPaint = ((unsigned int) output->id () ==
 
505
                    (unsigned int) screen->outputDeviceForPoint (pointerX, pointerY));
 
506
 
 
507
    if (desiredSlot && optionGetDrawIndicator () &&
 
508
        !optionGetBehindWindow () && mAllowPaint)
 
509
    {
 
510
        GLMatrix sTransform (matrix);
 
511
        status = glScreen->glPaintOutput (attrib, matrix, region, output, mask);
 
512
 
 
513
        sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
 
514
        ((PaintableAnimatedGridRectangle *) desiredSlot)->paint (sTransform);
 
515
    }
 
516
    else
 
517
        status = glScreen->glPaintOutput (attrib, matrix, region, output, mask);
 
518
 
 
519
    return status;
 
520
}
 
521
 
 
522
GridType
 
523
GridScreen::edgeToGridType ()
 
524
{
 
525
    GridType ret;
 
526
 
 
527
    switch (edge) {
 
528
    case Left:
 
529
        ret = (GridType) optionGetLeftEdgeAction ();
 
530
        break;
 
531
    case Right:
 
532
        ret = (GridType) optionGetRightEdgeAction ();
 
533
        break;
 
534
    case Top:
 
535
        ret = (GridType) optionGetTopEdgeAction ();
 
536
        break;
 
537
    case Bottom:
 
538
        ret = (GridType) optionGetBottomEdgeAction ();
 
539
        break;
 
540
    case TopLeft:
 
541
        ret = (GridType) optionGetTopLeftCornerAction ();
 
542
        break;
 
543
    case TopRight:
 
544
        ret = (GridType) optionGetTopRightCornerAction ();
 
545
        break;
 
546
    case BottomLeft:
 
547
        ret = (GridType) optionGetBottomLeftCornerAction ();
 
548
        break;
 
549
    case BottomRight:
 
550
        ret = (GridType) optionGetBottomRightCornerAction ();
 
551
        break;
 
552
    case NoEdge:
 
553
    default:
 
554
        ret = GridUnknown;
 
555
        break;
 
556
    }
 
557
 
 
558
    return ret;
 
559
}
 
560
 
 
561
void
 
562
GridScreen::handleEvent (XEvent *event)
 
563
{
 
564
    CompOutput         out;
 
565
    CompOption::Vector opts;
 
566
    CompOption::Value  v = CompOption::Value ((int) mGrabWindow->id ());
 
567
    CompRect           *edgeBox = NULL;
 
568
    float              edgeDist; /* interpolated 0.0f -> 1.0f based on distance */
 
569
 
 
570
    screen->handleEvent (event);
 
571
 
 
572
    if (event->type != MotionNotify || !mGrabWindow)
 
573
        return;
 
574
 
 
575
    opts.resize (1);
 
576
    opts.at (0).setName ("window", CompOption::TypeInt);
 
577
    opts.at (0).set (v);
 
578
 
 
579
    out = screen->outputDevs ().at (
 
580
                   screen->outputDeviceForPoint (CompPoint (pointerX, pointerY)));
 
581
 
 
582
    /* Detect corners first */
 
583
    /* Bottom Left */
 
584
    if (pointerY > (out.y () + out.height () - optionGetBottomEdgeThreshold() - 1) &&
 
585
        pointerX < out.x () + optionGetLeftEdgeThreshold())
 
586
    {
 
587
        float xd, yd;
 
588
        unsigned int xptr = pointerX - out.x ();
 
589
        unsigned int yptr = (out.y () + out.height ()) - pointerY;
 
590
 
 
591
        if (xptr)
 
592
            xd = MIN (((float) xptr / (float) optionGetLeftEdgeThreshold ()), 1.0f);
 
593
        else
 
594
            xd = 0.0f;
 
595
 
 
596
        if (yptr)
 
597
            yd = MIN (((float) yptr / (float) (optionGetBottomEdgeThreshold () - 1)), 1.0f);
 
598
        else
 
599
            yd = 0.0f;
 
600
 
 
601
        if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
 
602
            edgeBox = new CompRect (out.x (), out.y () + (out.height () - mGrabWindow->height ()),
 
603
                                    mGrabWindow->width (), mGrabWindow->height ());
 
604
 
 
605
        edgeDist = (xd + yd) / 2.0f;
 
606
        edge = BottomLeft;
 
607
    }
 
608
    /* Bottom Right */
 
609
    else if (pointerY > (out.y () + out.height () - optionGetBottomEdgeThreshold() - 1) &&
 
610
             pointerX > (out.x () + out.width () - optionGetRightEdgeThreshold() - 1))
 
611
    {
 
612
        float xd, yd;
 
613
        unsigned int xptr = (out.x () + out.width ()) - pointerX;
 
614
        unsigned int yptr = (out.y () + out.height ()) - pointerY;
 
615
 
 
616
        if (xptr)
 
617
            xd = MIN (((float) xptr / (float) (optionGetRightEdgeThreshold () - 1)), 1.0f);
 
618
        else
 
619
            xd = 0.0f;
 
620
 
 
621
        if (yptr)
 
622
            yd = MIN (((float) yptr / (float) (optionGetBottomEdgeThreshold () - 1)), 1.0f);
 
623
        else
 
624
            yd = 0.0f;
 
625
 
 
626
        if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
 
627
            edgeBox = new CompRect (out.x () + (out.width () - mGrabWindow->width ()),
 
628
                                    out.y () + (out.height () - mGrabWindow->height ()),
 
629
                                    mGrabWindow->width (), mGrabWindow->height ());
 
630
 
 
631
        edgeDist = (xd + yd) / 2.0f;
 
632
        edge = BottomRight;
 
633
    }
 
634
    /* Top Left */
 
635
    else if (pointerY < optionGetTopEdgeThreshold() &&
 
636
            pointerX < optionGetLeftEdgeThreshold())
 
637
    {
 
638
        float xd, yd;
 
639
        unsigned int xptr = pointerX - out.x ();
 
640
        unsigned int yptr = pointerY - out.y ();
 
641
 
 
642
        if (xptr)
 
643
            xd = MIN (((float) xptr / (float) optionGetLeftEdgeThreshold ()), 1.0f);
 
644
        else
 
645
            xd = 0.0f;
 
646
 
 
647
        if (yptr)
 
648
            yd = MIN (((float) yptr / (float) optionGetTopEdgeThreshold ()), 1.0f);
 
649
        else
 
650
            yd = 0.0f;
 
651
 
 
652
        if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
 
653
            edgeBox = new CompRect (out.x (),
 
654
                                    out.y (),
 
655
                                    mGrabWindow->width (), mGrabWindow->height ());
 
656
 
 
657
        edgeDist = (xd + yd) / 2.0f;
 
658
        edge = TopLeft;
 
659
    }
 
660
    /* Top Right */
 
661
    else if (pointerY < out.y () + optionGetTopEdgeThreshold() &&
 
662
             pointerX > (out.x () + out.width () - optionGetRightEdgeThreshold() - 1))
 
663
    {
 
664
        float xd, yd;
 
665
        unsigned int xptr = (out.x () + out.width ()) - pointerX;
 
666
        unsigned int yptr = pointerY - out.y ();
 
667
 
 
668
        if (xptr)
 
669
            xd = MIN (((float) xptr / (float) (optionGetRightEdgeThreshold () - 1)), 1.0f);
 
670
        else
 
671
            xd = 0.0f;
 
672
 
 
673
        if (yptr)
 
674
            yd = MIN (((float) yptr / (float) optionGetTopEdgeThreshold ()), 1.0f);
 
675
        else
 
676
            yd = 0.0f;
 
677
 
 
678
        if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
 
679
            edgeBox = new CompRect (out.x () + (out.width () - mGrabWindow->width ()),
 
680
                                    out.y (),
 
681
                                    mGrabWindow->width (), mGrabWindow->height ());
 
682
 
 
683
        edgeDist = (xd + yd) / 2.0f;
 
684
        edge = TopRight;
 
685
    }
 
686
    /* Left */
 
687
    else if (pointerX < out.x () + optionGetLeftEdgeThreshold())
 
688
    {
 
689
        float xd;
 
690
        unsigned int xptr = pointerX - out.x ();
 
691
 
 
692
        if (xptr)
 
693
            xd = MIN (((float) xptr / (float) optionGetLeftEdgeThreshold ()), 1.0f);
 
694
        else
 
695
            xd = 0.0f;
 
696
 
 
697
        if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
 
698
            edgeBox = new CompRect (out.x (),
 
699
                                    out.y () + (out.height () / 2.0f) - mGrabWindow->height () / 2.0f,
 
700
                                    mGrabWindow->width (), mGrabWindow->height ());
 
701
 
 
702
        edgeDist = xd;
 
703
        edge = Left;
 
704
    }
 
705
    /* Right */
 
706
    else if (pointerX > (out.x () + out.width () - optionGetRightEdgeThreshold() - 1))
 
707
    {
 
708
        float xd;
 
709
        unsigned int xptr = (out.x () + out.width ()) - pointerX;
 
710
 
 
711
        if (xptr)
 
712
            xd = MIN (((float) xptr / (float) (optionGetRightEdgeThreshold () - 1)), 1.0f);
 
713
        else
 
714
            xd = 0.0f;
 
715
 
 
716
        if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
 
717
            edgeBox = new CompRect (out.x () + (out.width () - mGrabWindow->width ()),
 
718
                                    out.y () + (out.height () / 2.0f) - mGrabWindow->height () / 2.0f,
 
719
                                    mGrabWindow->width (), mGrabWindow->height ());
 
720
 
 
721
        edgeDist = xd;
 
722
        edge = Right;
 
723
    }
 
724
    /* Top */
 
725
    else if (pointerY < out.y () + optionGetTopEdgeThreshold())
 
726
    {
 
727
        float yd;
 
728
        unsigned int yptr = pointerY - out.y ();
 
729
 
 
730
        if (yptr)
 
731
            yd = MIN (((float) yptr / (float) optionGetTopEdgeThreshold ()), 1.0f);
 
732
        else
 
733
            yd = 0.0f;
 
734
 
 
735
        if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
 
736
            edgeBox = new CompRect (out.x () + (out.width () / 2.0f) - mGrabWindow->width () / 2.0f,
 
737
                                    out.y (),
 
738
                                    mGrabWindow->width (), mGrabWindow->height ());
 
739
 
 
740
        edgeDist = yd;
 
741
        edge = Top;
 
742
    }
 
743
    /* Bottom */
 
744
    else if (pointerY > (out.y () + out.height () - optionGetBottomEdgeThreshold() - 1))
 
745
    {
 
746
        float yd;
 
747
        unsigned int yptr = (out.y () + out.height ()) - pointerY;
 
748
 
 
749
        if (yptr)
 
750
            yd = MIN (((float) yptr / (float) (optionGetBottomEdgeThreshold () - 1)), 1.0f);
 
751
        else
 
752
            yd = 0.0f;
 
753
 
 
754
        if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
 
755
            edgeBox = new CompRect (out.x () + (out.width () / 2.0f) - mGrabWindow->width () / 2.0f,
 
756
                                    out.y () + (out.height () - mGrabWindow->height ()),
 
757
                                    mGrabWindow->width (), mGrabWindow->height ());
 
758
 
 
759
        edgeDist = yd;
 
760
        edge = Bottom;
 
761
    }
 
762
    /* No Edge */
 
763
    else
 
764
        edge = NoEdge;
 
765
 
 
766
    /* Detect when cursor enters another output */
 
767
 
 
768
    currentWorkarea = screen->getWorkareaForOutput
 
769
                            (screen->outputDeviceForPoint (pointerX, pointerY));
 
770
    if (lastWorkarea != currentWorkarea)
 
771
    {
 
772
        CompRect old;
 
773
 
 
774
        if (desiredSlot)
 
775
            old = *desiredSlot;
 
776
 
 
777
        lastWorkarea = currentWorkarea;
 
778
 
 
779
        if (compositingActive && cScreen)
 
780
            cScreen->damageRegion (old);
 
781
 
 
782
        initiateCommon (0, 0, opts, edgeToGridType (), false);
 
783
 
 
784
        if (edgeBox && desiredSlot)
 
785
        {
 
786
            desiredSlot->setFrom (*edgeBox);
 
787
            delete edgeBox;
 
788
        }
 
789
 
 
790
        if (compositingActive && cScreen)
 
791
            cScreen->damageRegion (desiredSlot ? *desiredSlot : old);
 
792
    }
 
793
 
 
794
    /* Detect edge region change */
 
795
    if (lastEdge != edge)
 
796
    {
 
797
        CompRect old;
 
798
 
 
799
        if (desiredSlot)
 
800
        {
 
801
            ((AnimatedGridRectangle *) desiredSlot)->reset ();
 
802
            old = *desiredSlot;
 
803
        }
 
804
 
 
805
        lastEdge = edge;
 
806
 
 
807
        if (compositingActive && cScreen)
 
808
            cScreen->damageRegion (old);
 
809
 
 
810
        initiateCommon (0, 0, opts, edgeToGridType (), false);
 
811
 
 
812
        if (edgeBox && desiredSlot)
 
813
        {
 
814
            desiredSlot->setFrom (*edgeBox);
 
815
            delete edgeBox;
 
816
        }
 
817
 
 
818
        if (compositingActive && cScreen)
 
819
            cScreen->damageRegion (desiredSlot ? *desiredSlot : old);
 
820
    }
 
821
 
 
822
    /* The closer the user gets to the edge, the more progress should go up */
 
823
    if (desiredSlot)
 
824
    {
 
825
        CompRect damage;
 
826
        CompRect sbr = mGrabWindow->serverBorderRect ();
 
827
 
 
828
        damage = ((AnimatedGridRectangle *) desiredSlot)->current ();
 
829
        cScreen->damageRegion (damage);
 
830
 
 
831
        if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromWindow)
 
832
            ((AnimatedGridRectangle *) desiredSlot)->setFrom (sbr);
 
833
        ((AnimatedGridRectangle *) desiredSlot)->setProgress (1.0f - edgeDist);
 
834
 
 
835
        damage = ((AnimatedGridRectangle *) desiredSlot)->current ();
 
836
        cScreen->damageRegion (damage);
 
837
    }
 
838
 
 
839
    GRID_WINDOW (mGrabWindow);
 
840
 
 
841
    if ((gw->pointerBufDx > SNAPOFF_THRESHOLD ||
 
842
         gw->pointerBufDy > SNAPOFF_THRESHOLD ||
 
843
         gw->pointerBufDx < -SNAPOFF_THRESHOLD ||
 
844
         gw->pointerBufDy < -SNAPOFF_THRESHOLD) &&
 
845
         gw->isGridResized &&
 
846
         optionGetSnapbackWindows ())
 
847
            restoreWindow (0, 0, opts);
 
848
}
 
849
 
 
850
bool
 
851
GridWindow::glDraw (const GLMatrix            &transform,
 
852
                    GLFragment::Attrib        &fragment,
 
853
                    const CompRegion          &region,
 
854
                    unsigned int              mask)
 
855
{
 
856
    CompRegion nRegion = region;
 
857
 
 
858
    if (gScreen->desiredSlot && gScreen->mAllowPaint)
 
859
    {
 
860
        nRegion = nRegion.united (gScreen->desiredSlot->current ());
 
861
 
 
862
        gScreen->desiredSlot->paint (transform);
 
863
    }
 
864
 
 
865
    return glWindow->glDraw (transform, fragment, nRegion, mask);
 
866
}
 
867
 
 
868
void
 
869
GridWindow::grabNotify (int          x,
 
870
                        int          y,
 
871
                        unsigned int state,
 
872
                        unsigned int mask)
 
873
{
 
874
    if (screen->grabExist ("move"))
 
875
    {
 
876
        screen->handleEventSetEnabled (gScreen, true);
 
877
        if (compositingActive)
 
878
        {
 
879
            if (gScreen->optionGetBehindWindow ())
 
880
                glWindow->glDrawSetEnabled (this, true);
 
881
            gScreen->glScreen->glPaintOutputSetEnabled (gScreen, true);
 
882
            gScreen->mAllowPaint  = false;
 
883
        }
 
884
        gScreen->mGrabWindow = window;
 
885
        pointerBufDx = pointerBufDy = 0;
 
886
 
 
887
        if (!isGridResized && gScreen->optionGetSnapbackWindows ())
 
888
            /* Store size not including borders when grabbing with cursor */
 
889
            originalSize = window->serverGeometry ();
 
890
    }
 
891
 
 
892
    if (screen->grabExist ("resize"))
 
893
    {
 
894
        isGridResized = false;
 
895
        resizeCount = 0;
 
896
    }
 
897
 
 
898
    window->grabNotify (x, y, state, mask);
 
899
}
 
900
 
 
901
void
 
902
GridWindow::ungrabNotify ()
 
903
{
 
904
    if (window == gScreen->mGrabWindow)
 
905
    {
 
906
        CompOption::Vector opts;
 
907
        CompRect           damage = gScreen->desiredSlot ? *gScreen->desiredSlot : CompRect (0, 0, 0, 0);
 
908
        CompOption::Value  v = CompOption::Value ((int) gScreen->mGrabWindow->id ());
 
909
 
 
910
        opts.resize (1);
 
911
        opts.at (0).setName ("window", CompOption::TypeInt);
 
912
        opts.at (0).set (v);
 
913
 
 
914
        gScreen->initiateCommon
 
915
                        (0, 0, opts, gScreen->edgeToGridType (), true);
 
916
 
 
917
        screen->handleEventSetEnabled (gScreen, false);
 
918
 
 
919
        if (compositingActive)
 
920
        {
 
921
            if (gScreen->optionGetBehindWindow ())
 
922
                glWindow->glDrawSetEnabled (this, false);
 
923
            gScreen->glScreen->glPaintOutputSetEnabled (gScreen, false);
 
924
            gScreen->mAllowPaint  = false;
 
925
            gScreen->cScreen->damageRegion (damage);
 
926
        }
 
927
 
 
928
        gScreen->mGrabWindow = NULL;
 
929
 
 
930
    }
 
931
 
 
932
    gScreen->edge = NoEdge;
 
933
 
 
934
    window->ungrabNotify ();
 
935
}
 
936
 
 
937
void
 
938
GridWindow::moveNotify (int dx, int dy, bool immediate)
 
939
{
 
940
    window->moveNotify (dx, dy, immediate);
 
941
 
 
942
    pointerBufDx += dx;
 
943
    pointerBufDy += dy;
 
944
}
 
945
 
 
946
bool
 
947
GridScreen::restoreWindow (CompAction         *action,
 
948
                           CompAction::State  state,
 
949
                           CompOption::Vector &option)
 
950
{
 
951
    XWindowChanges xwc;
 
952
    CompWindow *cw = screen->findWindow (screen->activeWindow ());
 
953
 
 
954
    if (!cw)
 
955
        return false;
 
956
 
 
957
    GRID_WINDOW (cw);
 
958
 
 
959
    if (!gw->isGridResized)
 
960
        return false;
 
961
 
 
962
    if (gw->isGridMaximized & !(cw->state () & MAXIMIZE_STATE))
 
963
            gw->isGridMaximized = false;
 
964
    else
 
965
    {
 
966
        if (cw == mGrabWindow)
 
967
        {
 
968
            xwc.x = pointerX - (gw->originalSize.width () >> 1);
 
969
            xwc.y = pointerY + (cw->border ().top >> 1);
 
970
        }
 
971
        else
 
972
        {
 
973
            xwc.x = gw->originalSize.x ();
 
974
            xwc.y = gw->originalSize.y ();
 
975
        }
 
976
        xwc.width  = gw->originalSize.width ();
 
977
        xwc.height = gw->originalSize.height ();
 
978
        cw->maximize (0);
 
979
        cw->configureXWindow (CWX | CWY | CWWidth | CWHeight, &xwc);
 
980
        gw->pointerBufDx = 0;
 
981
        gw->pointerBufDy = 0;
 
982
    }
 
983
    gw->isGridResized = false;
 
984
    gw->resizeCount = 0;
 
985
 
 
986
    return true;
 
987
}
 
988
 
 
989
GridScreen::GridScreen (CompScreen *screen) :
 
990
    PluginClassHandler<GridScreen, CompScreen> (screen),
 
991
    desiredSlot (NULL),
 
992
    mGrabWindow (NULL),
 
993
    mAllowPaint (false)
 
994
{
 
995
    if (compositingActive)
 
996
    {
 
997
        cScreen = CompositeScreen::get (screen);
 
998
        glScreen = GLScreen::get (screen);
 
999
 
 
1000
        CompositeScreenInterface::setHandler (cScreen, false);
 
1001
        GLScreenInterface::setHandler (glScreen, false);
 
1002
    }
 
1003
 
 
1004
    ScreenInterface::setHandler (screen, false);
 
1005
 
 
1006
    edge = lastEdge = NoEdge;
 
1007
    currentWorkarea = lastWorkarea = screen->getWorkareaForOutput
 
1008
                            (screen->outputDeviceForPoint (pointerX, pointerY));
 
1009
 
 
1010
#define GRIDSET(opt,where,resize)                                              \
 
1011
    optionSet##opt##Initiate (boost::bind (&GridScreen::initiateCommon, this,  \
 
1012
                                           _1, _2, _3, where, resize))
 
1013
 
 
1014
    GRIDSET (PutCenterKey, GridCenter, true);
 
1015
    GRIDSET (PutLeftKey, GridLeft, true);
 
1016
    GRIDSET (PutRightKey, GridRight, true);
 
1017
    GRIDSET (PutTopKey, GridTop, true);
 
1018
    GRIDSET (PutBottomKey, GridBottom, true);
 
1019
    GRIDSET (PutTopleftKey, GridTopLeft, true);
 
1020
    GRIDSET (PutToprightKey, GridTopRight, true);
 
1021
    GRIDSET (PutBottomleftKey, GridBottomLeft, true);
 
1022
    GRIDSET (PutBottomrightKey, GridBottomRight, true);
 
1023
    GRIDSET (PutMaximizeKey, GridMaximize, true);
 
1024
 
 
1025
#undef GRIDSET
 
1026
 
 
1027
    optionSetPutRestoreKeyInitiate (boost::bind (&GridScreen::
 
1028
                                            restoreWindow, this, _1, _2, _3));
 
1029
 
 
1030
}
 
1031
 
 
1032
GridWindow::GridWindow (CompWindow *window) :
 
1033
    PluginClassHandler <GridWindow, CompWindow> (window),
 
1034
    window (window),
 
1035
    glWindow (GLWindow::get (window)),
 
1036
    gScreen (GridScreen::get (screen)),
 
1037
    isGridResized (false),
 
1038
    isGridMaximized (false),
 
1039
    pointerBufDx (0),
 
1040
    pointerBufDy (0),
 
1041
    resizeCount (0),
 
1042
    lastTarget (GridUnknown)
 
1043
{
 
1044
    WindowInterface::setHandler (window);
 
1045
    GLWindowInterface::setHandler (glWindow, false);
 
1046
}
 
1047
 
 
1048
/* Initial plugin init function called. Checks to see if we are ABI
 
1049
 * compatible with core, otherwise unload */
 
1050
 
 
1051
bool
 
1052
GridPluginVTable::init ()
 
1053
{
 
1054
    if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION))
 
1055
        return false;
 
1056
 
 
1057
    if (!CompPlugin::checkPluginABI ("composite", COMPIZ_COMPOSITE_ABI) ||
 
1058
        !CompPlugin::checkPluginABI ("opengl", COMPIZ_OPENGL_ABI))
 
1059
        compositingActive = false;
 
1060
    else
 
1061
        compositingActive = true;
 
1062
 
 
1063
    return true;
 
1064
}