← Back to branch summary

~mc-return/compiz/compiz.merge-src-screen.cpp-improvements

« back to all changes in this revision

Viewing changes to plugins/zoom/src/zoom.cpp

  • Committer: Dennis kasprzyk
  • Author(s): Dennis Kasprzyk
  • Date: 2009-03-15 05:09:18 UTC
  • Revision ID: git-v1:163f6b6f3c3b7764987cbdf8e03cc355edeaa499
New generalized build system.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/zoom/src/zoom.cpp
 
1
/*
 
2
 * Copyright © 2005 Novell, Inc.
 
3
 *
 
4
 * Permission to use, copy, modify, distribute, and sell this software
 
5
 * and its documentation for any purpose is hereby granted without
 
6
 * fee, provided that the above copyright notice appear in all copies
 
7
 * and that both that copyright notice and this permission notice
 
8
 * appear in supporting documentation, and that the name of
 
9
 * Novell, Inc. not be used in advertising or publicity pertaining to
 
10
 * distribution of the software without specific, written prior permission.
 
11
 * Novell, Inc. makes no representations about the suitability of this
 
12
 * software for any purpose. It is provided "as is" without express or
 
13
 * implied warranty.
 
14
 *
 
15
 * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 
16
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
 
17
 * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 
18
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 
19
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 
20
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 
21
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
22
 *
 
23
 * Author: David Reveman <davidr@novell.com>
 
24
 */
 
25
 
 
26
#include "zoom.h"
 
27
 
 
28
COMPIZ_PLUGIN_20081216 (zoom, ZoomPluginVTable)
 
29
 
 
30
static int
 
31
adjustZoomVelocity (ZoomScreen *zs)
 
32
{
 
33
    float d, adjust, amount;
 
34
 
 
35
    d = (1.0f - zs->scale) * 10.0f;
 
36
 
 
37
    adjust = d * 0.002f;
 
38
    amount = fabs (d);
 
39
    if (amount < 1.0f)
 
40
        amount = 1.0f;
 
41
    else if (amount > 5.0f)
 
42
        amount = 5.0f;
 
43
 
 
44
    zs->velocity = (amount * zs->velocity + adjust) / (amount + 1.0f);
 
45
 
 
46
    return (fabs (d) < 0.02f && fabs (zs->velocity) < 0.005f);
 
47
}
 
48
 
 
49
void
 
50
ZoomScreen::zoomInEvent ()
 
51
{
 
52
    CompOption::Vector o (0);
 
53
 
 
54
    o.push_back (CompOption ("root", CompOption::TypeInt));
 
55
    o.push_back (CompOption ("output", CompOption::TypeInt));
 
56
    o.push_back (CompOption ("x1", CompOption::TypeInt));
 
57
    o.push_back (CompOption ("y1", CompOption::TypeInt));
 
58
    o.push_back (CompOption ("x2", CompOption::TypeInt));
 
59
    o.push_back (CompOption ("y2", CompOption::TypeInt));
 
60
 
 
61
    o[0].value ().set ((int) screen->root ());
 
62
    o[1].value ().set ((int) zoomOutput);
 
63
    o[2].value ().set ((int) current[zoomOutput].x1);
 
64
    o[3].value ().set ((int) current[zoomOutput].y1);
 
65
    o[4].value ().set ((int) current[zoomOutput].x2);
 
66
    o[5].value ().set ((int) current[zoomOutput].y2);
 
67
 
 
68
    screen->handleCompizEvent ("zoom", "in", o);
 
69
}
 
70
 
 
71
void
 
72
ZoomScreen::zoomOutEvent ()
 
73
{
 
74
    CompOption::Vector o (0);
 
75
 
 
76
    o.push_back (CompOption ("root", CompOption::TypeInt));
 
77
    o.push_back (CompOption ("output", CompOption::TypeInt));
 
78
 
 
79
    o[0].value ().set ((int) screen->root ());
 
80
    o[1].value ().set ((int) zoomOutput);
 
81
 
 
82
    screen->handleCompizEvent ("zoom", "out", o);
 
83
}
 
84
 
 
85
void
 
86
ZoomScreen::preparePaint (int ms)
 
87
{
 
88
    if (adjust)
 
89
    {
 
90
        int   steps;
 
91
        float amount;
 
92
 
 
93
        amount = ms * 0.35f * opt[ZOOM_OPTION_SPEED].value ().f ();
 
94
        steps  = amount / (0.5f * opt[ZOOM_OPTION_TIMESTEP].value ().f ());
 
95
        if (!steps) steps = 1;
 
96
 
 
97
        while (steps--)
 
98
        {
 
99
            if (adjustZoomVelocity (this))
 
100
            {
 
101
                BoxPtr pBox =
 
102
                    &screen->outputDevs ()[zoomOutput].region ()->extents;
 
103
 
 
104
                scale = 1.0f;
 
105
                velocity = 0.0f;
 
106
                adjust = false;
 
107
 
 
108
                if (current[zoomOutput].x1 == pBox->x1 &&
 
109
                    current[zoomOutput].y1 == pBox->y1 &&
 
110
                    current[zoomOutput].x2 == pBox->x2 &&
 
111
                    current[zoomOutput].y2 == pBox->y2)
 
112
                {
 
113
                    zoomed &= ~(1 << zoomOutput);
 
114
                    zoomOutEvent ();
 
115
                }
 
116
                else
 
117
                {
 
118
                    zoomInEvent ();
 
119
                }
 
120
 
 
121
                break;
 
122
            }
 
123
            else
 
124
            {
 
125
                scale += (velocity * ms) / (float) cScreen->redrawTime ();
 
126
            }
 
127
        }
 
128
    }
 
129
 
 
130
    cScreen->preparePaint (ms);
 
131
}
 
132
 
 
133
void
 
134
ZoomScreen::donePaint ()
 
135
{
 
136
    if (adjust)
 
137
        cScreen->damageScreen ();
 
138
 
 
139
    if (!adjust && zoomed == 0)
 
140
    {
 
141
        cScreen->preparePaintSetEnabled (this, false);
 
142
        cScreen->donePaintSetEnabled (this, false);
 
143
        gScreen->glPaintOutputSetEnabled (this, false);
 
144
    }
 
145
 
 
146
    cScreen->donePaint ();
 
147
}
 
148
 
 
149
bool
 
150
ZoomScreen::glPaintOutput (const GLScreenPaintAttrib &sAttrib,
 
151
                           const GLMatrix &transform,
 
152
                           const CompRegion &region,
 
153
                           CompOutput *output,
 
154
                           unsigned int mask)
 
155
{
 
156
    GLMatrix zTransform (transform);
 
157
    bool     status;
 
158
 
 
159
    if (output->id () != ~0 && (zoomed & (1 << output->id ())))
 
160
    {
 
161
        GLTexture::Filter saveFilter;
 
162
        ZoomBox           box;
 
163
        float             scale, x, y, x1, y1;
 
164
        float             oWidth = output->width ();
 
165
        float             oHeight = output->height ();
 
166
 
 
167
        mask &= ~PAINT_SCREEN_REGION_MASK;
 
168
 
 
169
        getCurrentZoom (output->id (), &box);
 
170
 
 
171
        x1 = box.x1 - output->x1 ();
 
172
        y1 = box.y1 - output->y1 ();
 
173
 
 
174
        scale = oWidth / (box.x2 - box.x1);
 
175
 
 
176
        x = ((oWidth  / 2.0f) - x1) / oWidth;
 
177
        y = ((oHeight / 2.0f) - y1) / oHeight;
 
178
 
 
179
        x = 0.5f - x * scale;
 
180
        y = 0.5f - y * scale;
 
181
 
 
182
        zTransform.translate (-x, y, 0.0f);
 
183
        zTransform.scale (scale, scale, 1.0f);
 
184
 
 
185
        mask |= PAINT_SCREEN_TRANSFORMED_MASK;
 
186
 
 
187
        saveFilter = gScreen->filter (SCREEN_TRANS_FILTER);
 
188
 
 
189
        if ((zoomOutput != output->id () || !adjust) && scale > 3.9f &&
 
190
            !opt[ZOOM_OPTION_FILTER_LINEAR].value ().b ())
 
191
            gScreen->setFilter (SCREEN_TRANS_FILTER, GLTexture::Fast);
 
192
 
 
193
        status = gScreen->glPaintOutput (sAttrib, zTransform, region, output,
 
194
                                         mask);
 
195
 
 
196
        gScreen->setFilter (SCREEN_TRANS_FILTER, saveFilter);
 
197
    }
 
198
    else
 
199
    {
 
200
        status = gScreen->glPaintOutput (sAttrib, transform, region, output,
 
201
                                         mask);
 
202
    }
 
203
 
 
204
    if (status && grab)
 
205
    {
 
206
        int x1, x2, y1, y2;
 
207
 
 
208
        x1 = MIN (this->x1, this->x2);
 
209
        y1 = MIN (this->y1, this->y2);
 
210
        x2 = MAX (this->x1, this->x2);
 
211
        y2 = MAX (this->y1, this->y2);
 
212
 
 
213
        if (grabIndex)
 
214
        {
 
215
            zTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
 
216
 
 
217
            glPushMatrix ();
 
218
            glLoadMatrixf (zTransform.getMatrix ());
 
219
            glDisableClientState (GL_TEXTURE_COORD_ARRAY);
 
220
            glEnable (GL_BLEND);
 
221
            glColor4us (0x2fff, 0x2fff, 0x4fff, 0x4fff);
 
222
            glRecti (x1, y2, x2, y1);
 
223
            glColor4us (0x2fff, 0x2fff, 0x4fff, 0x9fff);
 
224
            glBegin (GL_LINE_LOOP);
 
225
            glVertex2i (x1, y1);
 
226
            glVertex2i (x2, y1);
 
227
            glVertex2i (x2, y2);
 
228
            glVertex2i (x1, y2);
 
229
            glEnd ();
 
230
            glColor4usv (defaultColor);
 
231
            glDisable (GL_BLEND);
 
232
            glEnableClientState (GL_TEXTURE_COORD_ARRAY);
 
233
            glPopMatrix ();
 
234
        }
 
235
    }
 
236
 
 
237
    return status;
 
238
}
 
239
 
 
240
 
 
241
void
 
242
ZoomScreen::initiateForSelection (int output)
 
243
{
 
244
    int tmp;
 
245
 
 
246
    if (x1 > x2)
 
247
    {
 
248
        tmp = x1;
 
249
        x1 = x2;
 
250
        x2 = tmp;
 
251
    }
 
252
 
 
253
    if (y1 > y2)
 
254
    {
 
255
        tmp = y1;
 
256
        y1 = y2;
 
257
        y2 = tmp;
 
258
    }
 
259
 
 
260
    if (x1 < x2 && y1 < y2)
 
261
    {
 
262
        float  oWidth, oHeight;
 
263
        float  xScale, yScale, scale;
 
264
        BoxRec box;
 
265
        int    cx, cy;
 
266
        int    width, height;
 
267
 
 
268
        oWidth  = screen->outputDevs ()[output].width ();
 
269
        oHeight = screen->outputDevs ()[output].height ();
 
270
 
 
271
        cx = (int) ((x1 + x2) / 2.0f + 0.5f);
 
272
        cy = (int) ((y1 + y2) / 2.0f + 0.5f);
 
273
 
 
274
        width  = x2 - x1;
 
275
        height = y2 - y1;
 
276
 
 
277
        xScale = oWidth  / width;
 
278
        yScale = oHeight / height;
 
279
 
 
280
        scale = MAX (MIN (xScale, yScale), 1.0f);
 
281
 
 
282
        box.x1 = cx - (oWidth  / scale) / 2.0f;
 
283
        box.y1 = cy - (oHeight / scale) / 2.0f;
 
284
        box.x2 = cx + (oWidth  / scale) / 2.0f;
 
285
        box.y2 = cy + (oHeight / scale) / 2.0f;
 
286
 
 
287
        if (box.x1 < screen->outputDevs ()[output].x1 ())
 
288
        {
 
289
            box.x2 += screen->outputDevs ()[output].x1 () - box.x1;
 
290
            box.x1 = screen->outputDevs ()[output].x1 ();
 
291
        }
 
292
        else if (box.x2 > screen->outputDevs ()[output].x2 ())
 
293
        {
 
294
            box.x1 -= box.x2 - screen->outputDevs ()[output].x2 ();
 
295
            box.x2 = screen->outputDevs ()[output].x2 ();
 
296
        }
 
297
 
 
298
        if (box.y1 < screen->outputDevs ()[output].y1 ())
 
299
        {
 
300
            box.y2 += screen->outputDevs ()[output].y1 () - box.y1;
 
301
            box.y1 = screen->outputDevs ()[output].y1 ();
 
302
        }
 
303
        else if (box.y2 > screen->outputDevs ()[output].y2 ())
 
304
        {
 
305
            box.y1 -= box.y2 - screen->outputDevs ()[output].y2 ();
 
306
            box.y2 = screen->outputDevs ()[output].y2 ();
 
307
        }
 
308
 
 
309
        if (zoomed & (1 << output))
 
310
        {
 
311
            getCurrentZoom (output, &last[output]);
 
312
        }
 
313
        else
 
314
        {
 
315
            last[output].x1 = screen->outputDevs ()[output].x1 ();
 
316
            last[output].y1 = screen->outputDevs ()[output].y1 ();
 
317
            last[output].x2 = screen->outputDevs ()[output].x2 ();
 
318
            last[output].y2 = screen->outputDevs ()[output].y2 ();
 
319
        }
 
320
 
 
321
        current[output].x1 = box.x1;
 
322
        current[output].y1 = box.y1;
 
323
        current[output].x2 = box.x2;
 
324
        current[output].y2 = box.y2;
 
325
 
 
326
        this->scale = 0.0f;
 
327
        adjust = true;
 
328
        cScreen->preparePaintSetEnabled (this, true);
 
329
        cScreen->donePaintSetEnabled (this, true);
 
330
        gScreen->glPaintOutputSetEnabled (this, true);
 
331
        zoomOutput = output;
 
332
        zoomed |= (1 << output);
 
333
 
 
334
        cScreen->damageScreen ();
 
335
    }
 
336
}
 
337
 
 
338
static bool
 
339
zoomIn (CompAction         *action,
 
340
        CompAction::State  state,
 
341
        CompOption::Vector &options)
 
342
{
 
343
    float   w, h, x0, y0;
 
344
    int     output;
 
345
    ZoomBox box;
 
346
 
 
347
    ZOOM_SCREEN (screen);
 
348
 
 
349
    output = screen->outputDeviceForPoint (pointerX, pointerY);
 
350
 
 
351
    if (!zs->grabIndex)
 
352
    {
 
353
        zs->grabIndex = screen->pushGrab (None, "zoom");
 
354
        screen->handleEventSetEnabled (zs, true);
 
355
    }
 
356
 
 
357
    if (zs->zoomed & (1 << output))
 
358
    {
 
359
        zs->getCurrentZoom (output, &box);
 
360
    }
 
361
    else
 
362
    {
 
363
        box.x1 = screen->outputDevs ()[output].x1 ();
 
364
        box.y1 = screen->outputDevs ()[output].y1 ();
 
365
        box.x2 = screen->outputDevs ()[output].x2 ();
 
366
        box.y2 = screen->outputDevs ()[output].y2 ();
 
367
    }
 
368
 
 
369
    w = (box.x2 - box.x1) /
 
370
        zs->opt[ZOOM_OPTION_ZOOM_FACTOR].value ().f ();
 
371
    h = (box.y2 - box.y1) /
 
372
        zs->opt[ZOOM_OPTION_ZOOM_FACTOR].value ().f ();
 
373
 
 
374
    x0 = (pointerX - screen->outputDevs ()[output].x1 ()) / (float)
 
375
        screen->outputDevs ()[output].width ();
 
376
    y0 = (pointerY - screen->outputDevs ()[output].y1 ()) / (float)
 
377
        screen->outputDevs ()[output].height ();
 
378
 
 
379
    zs->x1 = box.x1 + (x0 * (box.x2 - box.x1) - x0 * w + 0.5f);
 
380
    zs->y1 = box.y1 + (y0 * (box.y2 - box.y1) - y0 * h + 0.5f);
 
381
    zs->x2 = zs->x1 + w;
 
382
    zs->y2 = zs->y1 + h;
 
383
 
 
384
    zs->initiateForSelection (output);
 
385
 
 
386
    return TRUE;
 
387
}
 
388
 
 
389
static bool
 
390
zoomInitiate (CompAction         *action,
 
391
              CompAction::State  state,
 
392
              CompOption::Vector &options)
 
393
{
 
394
    int   output, x1, y1;
 
395
    float scale;
 
396
 
 
397
    ZOOM_SCREEN (screen);
 
398
 
 
399
    if (screen->otherGrabExist ("zoom", 0))
 
400
        return false;
 
401
 
 
402
    if (!zs->grabIndex)
 
403
    {
 
404
        zs->grabIndex = screen->pushGrab (None, "zoom");
 
405
        screen->handleEventSetEnabled (zs, true);
 
406
    }
 
407
 
 
408
    if (state & CompAction::StateInitButton)
 
409
        action->setState (action->state () | CompAction::StateTermButton);
 
410
 
 
411
    /* start selection zoom rectangle */
 
412
 
 
413
    output = screen->outputDeviceForPoint (pointerX, pointerY);
 
414
 
 
415
    if (zs->zoomed & (1 << output))
 
416
    {
 
417
        ZoomBox box;
 
418
        float   oWidth;
 
419
 
 
420
        zs->getCurrentZoom (output, &box);
 
421
 
 
422
        oWidth = screen->outputDevs ()[output].width ();
 
423
        scale = oWidth / (box.x2 - box.x1);
 
424
 
 
425
        x1 = box.x1;
 
426
        y1 = box.y1;
 
427
    }
 
428
    else
 
429
    {
 
430
        scale = 1.0f;
 
431
        x1 = screen->outputDevs ()[output].x1 ();
 
432
        y1 = screen->outputDevs ()[output].y1 ();
 
433
    }
 
434
 
 
435
    zs->x1 = zs->x2 = x1 +
 
436
        ((pointerX - screen->outputDevs ()[output].x1 ()) /
 
437
            scale + 0.5f);
 
438
    zs->y1 = zs->y2 = y1 +
 
439
        ((pointerY - screen->outputDevs ()[output].y1 ()) /
 
440
            scale + 0.5f);
 
441
 
 
442
    zs->zoomOutput = output;
 
443
 
 
444
    zs->grab = true;
 
445
    zs->gScreen->glPaintOutputSetEnabled (zs, true);
 
446
 
 
447
    zs->cScreen->damageScreen ();
 
448
 
 
449
    return true;
 
450
}
 
451
 
 
452
static bool
 
453
zoomOut (CompAction         *action,
 
454
         CompAction::State  state,
 
455
         CompOption::Vector &options)
 
456
{
 
457
    int output;
 
458
 
 
459
    ZOOM_SCREEN (screen);
 
460
 
 
461
    output = screen->outputDeviceForPoint (pointerX, pointerY);
 
462
 
 
463
    zs->getCurrentZoom (output, &zs->last[output]);
 
464
 
 
465
    zs->current[output].x1 = screen->outputDevs ()[output].x1 ();
 
466
    zs->current[output].y1 = screen->outputDevs ()[output].y1 ();
 
467
    zs->current[output].x2 = screen->outputDevs ()[output].x2 ();
 
468
    zs->current[output].y2 = screen->outputDevs ()[output].y2 ();
 
469
 
 
470
    zs->zoomOutput = output;
 
471
    zs->scale = 0.0f;
 
472
    zs->adjust = true;
 
473
    zs->grab = false;
 
474
 
 
475
    if (zs->grabIndex)
 
476
    {
 
477
        screen->removeGrab (zs->grabIndex, NULL);
 
478
        zs->grabIndex = 0;
 
479
        screen->handleEventSetEnabled (zs, false);
 
480
    }
 
481
 
 
482
    zs->cScreen->damageScreen ();
 
483
 
 
484
    return true;
 
485
}
 
486
 
 
487
static bool
 
488
zoomTerminate (CompAction         *action,
 
489
               CompAction::State  state,
 
490
               CompOption::Vector &options)
 
491
{
 
492
    ZOOM_SCREEN (screen);
 
493
 
 
494
    if (zs->grab)
 
495
    {
 
496
        int output;
 
497
 
 
498
        output = screen->outputDeviceForPoint (zs->x1, zs->y1);
 
499
 
 
500
        if (zs->x2 > screen->outputDevs ()[output].x2 ())
 
501
            zs->x2 = screen->outputDevs ()[output].x2 ();
 
502
 
 
503
        if (zs->y2 > screen->outputDevs ()[output].y2 ())
 
504
            zs->y2 = screen->outputDevs ()[output].y2 ();
 
505
 
 
506
        zs->initiateForSelection (output);
 
507
 
 
508
        zs->grab = false;
 
509
    }
 
510
    else
 
511
    {
 
512
        zoomOut (action, state, noOptions);
 
513
    }
 
514
    action->setState (action->state () & ~(CompAction::StateTermKey |
 
515
                                           CompAction::StateTermButton));
 
516
}
 
517
 
 
518
static bool
 
519
zoomInitiatePan (CompAction         *action,
 
520
                 CompAction::State  state,
 
521
                 CompOption::Vector &options)
 
522
{
 
523
    int output;
 
524
 
 
525
    ZOOM_SCREEN (screen);
 
526
 
 
527
    output = screen->outputDeviceForPoint (pointerX, pointerY);
 
528
 
 
529
    if (!(zs->zoomed & (1 << output)))
 
530
        return false;
 
531
 
 
532
    if (screen->otherGrabExist ("zoom", 0))
 
533
        return false;
 
534
 
 
535
    if (state & CompAction::StateInitButton)
 
536
        action->setState (action->state () | CompAction::StateTermButton);
 
537
 
 
538
    if (!zs->panGrabIndex)
 
539
        zs->panGrabIndex = screen->pushGrab (zs->panCursor, "zoom-pan");
 
540
 
 
541
    zs->zoomOutput = output;
 
542
 
 
543
    return true;
 
544
}
 
545
 
 
546
static bool
 
547
zoomTerminatePan (CompAction         *action,
 
548
                  CompAction::State  state,
 
549
                  CompOption::Vector &options)
 
550
{
 
551
    ZOOM_SCREEN (screen);
 
552
 
 
553
    if (zs->panGrabIndex)
 
554
    {
 
555
        screen->removeGrab (zs->panGrabIndex, NULL);
 
556
        zs->panGrabIndex = 0;
 
557
 
 
558
        zs->zoomInEvent ();
 
559
    }
 
560
 
 
561
    return true;
 
562
}
 
563
 
 
564
void
 
565
ZoomScreen::getCurrentZoom (int output, ZoomBox *pBox)
 
566
{
 
567
    if (output == zoomOutput)
 
568
    {
 
569
        float inverse;
 
570
 
 
571
        inverse = 1.0f - scale;
 
572
 
 
573
        pBox->x1 = scale * current[output].x1 +
 
574
            inverse * last[output].x1;
 
575
        pBox->y1 = scale * current[output].y1 +
 
576
            inverse * last[output].y1;
 
577
        pBox->x2 = scale * current[output].x2 +
 
578
            inverse * last[output].x2;
 
579
        pBox->y2 = scale * current[output].y2 +
 
580
            inverse * last[output].y2;
 
581
    }
 
582
    else
 
583
    {
 
584
        pBox->x1 = current[output].x1;
 
585
        pBox->y1 = current[output].y1;
 
586
        pBox->x2 = current[output].x2;
 
587
        pBox->y2 = current[output].y2;
 
588
    }
 
589
}
 
590
 
 
591
void
 
592
ZoomScreen::handleMotionEvent (int xRoot, int yRoot)
 
593
{
 
594
    if (grabIndex)
 
595
    {
 
596
        int     output = zoomOutput;
 
597
        ZoomBox box;
 
598
        float   scale, oWidth = screen->outputDevs ()[output].width ();
 
599
 
 
600
        getCurrentZoom (output, &box);
 
601
 
 
602
        if (zoomed & (1 << output))
 
603
            scale = oWidth / (box.x2 - box.x1);
 
604
        else
 
605
            scale = 1.0f;
 
606
 
 
607
        if (panGrabIndex)
 
608
        {
 
609
            float dx, dy;
 
610
 
 
611
            dx = (xRoot - lastPointerX) / scale;
 
612
            dy = (yRoot - lastPointerY) / scale;
 
613
 
 
614
            box.x1 -= dx;
 
615
            box.y1 -= dy;
 
616
            box.x2 -= dx;
 
617
            box.y2 -= dy;
 
618
 
 
619
            if (box.x1 < screen->outputDevs ()[output].x1 ())
 
620
            {
 
621
                box.x2 += screen->outputDevs ()[output].x1 () - box.x1;
 
622
                box.x1 = screen->outputDevs ()[output].x1 ();
 
623
            }
 
624
            else if (box.x2 > screen->outputDevs ()[output].x2 ())
 
625
            {
 
626
                box.x1 -= box.x2 - screen->outputDevs ()[output].x2 ();
 
627
                box.x2 = screen->outputDevs ()[output].x2 ();
 
628
            }
 
629
 
 
630
            if (box.y1 < screen->outputDevs ()[output].y1 ())
 
631
            {
 
632
                box.y2 += screen->outputDevs ()[output].y1 () - box.y1;
 
633
                box.y1 = screen->outputDevs ()[output].y1 ();
 
634
            }
 
635
            else if (box.y2 > screen->outputDevs ()[output].y2 ())
 
636
            {
 
637
                box.y1 -= box.y2 - screen->outputDevs ()[output].y2 ();
 
638
                box.y2 = screen->outputDevs ()[output].y2 ();
 
639
            }
 
640
 
 
641
            current[output] = box;
 
642
 
 
643
            cScreen->damageScreen ();
 
644
        }
 
645
        else
 
646
        {
 
647
            int x1, y1;
 
648
 
 
649
            if (zoomed & (1 << output))
 
650
            {
 
651
                x1 = box.x1;
 
652
                y1 = box.y1;
 
653
            }
 
654
            else
 
655
            {
 
656
                x1 = screen->outputDevs ()[output].x1 ();
 
657
                y1 = screen->outputDevs ()[output].y1 ();
 
658
            }
 
659
 
 
660
            this->x2 = x1 +
 
661
                ((xRoot - screen->outputDevs ()[output].x1 ()) /
 
662
                 scale + 0.5f);
 
663
            this->y2 = y1 +
 
664
                ((yRoot - screen->outputDevs ()[output].y1 ()) /
 
665
                 scale + 0.5f);
 
666
 
 
667
            cScreen->damageScreen ();
 
668
        }
 
669
    }
 
670
}
 
671
 
 
672
void
 
673
ZoomScreen::handleEvent (XEvent *event)
 
674
{
 
675
    switch (event->type) {
 
676
        case MotionNotify:
 
677
            if (event->xmotion.root == screen->root ())
 
678
                handleMotionEvent (pointerX, pointerY);
 
679
            break;
 
680
        case EnterNotify:
 
681
        case LeaveNotify:
 
682
            if (event->xcrossing.root == screen->root ())
 
683
                handleMotionEvent (pointerX, pointerY);
 
684
        default:
 
685
            break;
 
686
    }
 
687
 
 
688
    screen->handleEvent (event);
 
689
}
 
690
 
 
691
 
 
692
CompOption::Vector &
 
693
ZoomScreen::getOptions ()
 
694
{
 
695
    return opt;
 
696
}
 
697
 
 
698
bool
 
699
ZoomScreen::setOption (const char        *name,
 
700
                       CompOption::Value &value)
 
701
{
 
702
    CompOption *o;
 
703
    unsigned int index;
 
704
 
 
705
    o = CompOption::findOption (opt, name, &index);
 
706
    if (!o)
 
707
        return false;
 
708
 
 
709
    return CompOption::setOption (*o, value);
 
710
}
 
711
 
 
712
static const CompMetadata::OptionInfo zoomOptionInfo[] = {
 
713
    { "initiate_button", "button", 0, zoomInitiate, zoomTerminate },
 
714
    { "zoom_in_button", "button", 0, zoomIn, 0 },
 
715
    { "zoom_out_button", "button", 0, zoomOut, 0 },
 
716
    { "zoom_pan_button", "button", 0, zoomInitiatePan, zoomTerminatePan },
 
717
    { "speed", "float", "<min>0.1</min>", 0, 0 },
 
718
    { "timestep", "float", "<min>0.1</min>", 0, 0 },
 
719
    { "zoom_factor", "float", "<min>1.01</min>", 0, 0 },
 
720
    { "filter_linear", "bool", 0, 0, 0 }
 
721
};
 
722
 
 
723
ZoomScreen::ZoomScreen (CompScreen *screen) :
 
724
    PrivateHandler<ZoomScreen,CompScreen> (screen),
 
725
    cScreen (CompositeScreen::get (screen)),
 
726
    gScreen (GLScreen::get (screen)),
 
727
    opt(ZOOM_OPTION_NUM),
 
728
    grabIndex (0),
 
729
    grab (false),
 
730
    zoomed (0),
 
731
    adjust (false),
 
732
    panGrabIndex (0),
 
733
    velocity (0.0),
 
734
    scale (0.0),
 
735
    zoomOutput (0)
 
736
{
 
737
    if (!zoomVTable->getMetadata ()->initOptions (zoomOptionInfo,
 
738
                                                  ZOOM_OPTION_NUM, opt))
 
739
    {
 
740
        setFailed ();
 
741
        return;
 
742
    }
 
743
 
 
744
    panCursor = XCreateFontCursor (screen->dpy (), XC_fleur);
 
745
 
 
746
    memset (&current, 0, sizeof (current));
 
747
    memset (&last, 0, sizeof (last));
 
748
 
 
749
    ScreenInterface::setHandler (screen, false);
 
750
    CompositeScreenInterface::setHandler (cScreen, false);
 
751
    GLScreenInterface::setHandler (gScreen, false);
 
752
}
 
753
 
 
754
 
 
755
ZoomScreen::~ZoomScreen ()
 
756
{
 
757
    if (panCursor)
 
758
        XFreeCursor (screen->dpy (), panCursor);
 
759
}
 
760
 
 
761
bool
 
762
ZoomPluginVTable::init ()
 
763
{
 
764
    if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION) |
 
765
        !CompPlugin::checkPluginABI ("composite", COMPIZ_COMPOSITE_ABI) |
 
766
        !CompPlugin::checkPluginABI ("opengl", COMPIZ_OPENGL_ABI))
 
767
         return false;
 
768
 
 
769
    getMetadata ()->addFromOptionInfo (zoomOptionInfo, ZOOM_OPTION_NUM);
 
770
    getMetadata ()->addFromFile (name ());
 
771
 
 
772
    return true;
 
773
}
 
774