« back to all changes in this revision
Viewing changes to plugins/freewins/src/action.cpp
- browse files at revision 3644
- compare with another revision
- download diff
- download tarball
- view history from revision 3644
- Committer: Tarmac
- Author(s): Daniel van Vugt
- Date: 2013-04-02 19:24:11 UTC
- mfrom: (3643.1.3 back-to-raring)
- Revision ID: tarmac-20130402192411-8jqkwbion75aazvt
Make lp:compiz/0.9.9 identical to lp:compiz/raring, so we can use it for
raring maintenance and eliminate lp:compiz/raring.
The changes that this proposal "undoes" have not been lost. They have just
moved to the new development series: lp:compiz/0.9.10 (lp:compiz now points
to this).
Approved by PS Jenkins bot, Sam Spilsbury.
raring maintenance and eliminate lp:compiz/raring.
The changes that this proposal "undoes" have not been lost. They have just
moved to the new development series: lp:compiz/0.9.10 (lp:compiz now points
to this).
Approved by PS Jenkins bot, Sam Spilsbury.
- files removed:
- plugins/freewins
- plugins/freewins/src
- files modified:
- compizconfig/tests/compizconfig_backend_concept_test.h
added
removed
plugins/freewins/src/action.cpp
1
/**
2
* Compiz Fusion Freewins plugin
3
*
4
* action.cpp
5
*
6
* Copyright (C) 2007 Rodolfo Granata <warlock.cc@gmail.com>
7
*
8
* This program is free software; you can redistribute it and/or
9
* modify it under the terms of the GNU General Public License
10
* as published by the Free Software Foundation; either version 2
11
* of the License, or (at your option) any later version.
12
*
13
* This program is distributed in the hope that it will be useful,
14
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
* GNU General Public License for more details.
17
*
18
* Author(s):
19
* Rodolfo Granata <warlock.cc@gmail.com>
20
* Sam Spilsbury <smspillaz@gmail.com>
21
*
22
* Button binding support and Reset added by:
23
* enigma_0Z <enigma.0ZA@gmail.com>
24
*
25
* Most of the input handling here is based on
26
* the shelf plugin by
27
* : Kristian Lyngstøl <kristian@bohemians.org>
28
* : Danny Baumann <maniac@opencompositing.org>
29
*
30
* Description:
31
*
32
* This plugin allows you to freely transform the texture of a window,
33
* whether that be rotation or scaling to make better use of screen space
34
* or just as a toy.
35
*
36
* Todo:
37
* - Fully implement an input redirection system by
38
* finding an inverse matrix, multiplying by it,
39
* translating to the actual window co-ords and
40
* XSendEvent() the co-ords to the actual window.
41
* - Code could be cleaner
42
* - Add timestep and speed options to animation
43
* - Add window hover-over info via paintOutput : i.e
44
* - Resize borders
45
* - 'Reset' Button
46
* - 'Scale' Button
47
* - 'Rotate' Button
48
*/
49
50
/* TODO: Finish porting stuff to actions */
51
52
#include "freewins.h"
53
54
55
/* ------ Actions -------------------------------------------------------*/
56
57
/* Initiate Mouse Rotation */
58
bool
59
FWScreen::initiateFWRotate (CompAction *action,
60
CompAction::State state,
61
CompOption::Vector options)
62
{
63
CompWindow* w;
64
CompWindow *useW;
65
Window xid;
66
67
xid = CompOption::getIntOptionNamed (options, "window", 0);
68
69
w = screen->findWindow (xid);
70
useW = screen->findWindow (xid);
71
72
if (w)
73
{
74
75
foreach (FWWindowInputInfo *info, mTransformedWindows)
76
{
77
if (info->ipw)
78
if (w->id () == info->ipw)
79
/* The window we just grabbed was actually
80
* an IPW, get the real window instead
81
*/
82
useW = getRealWindow (w);
83
}
84
85
mRotateCursor = XCreateFontCursor (screen->dpy (), XC_fleur);
86
87
if (!screen->otherGrabExist ("freewins", 0))
88
if (!mGrabIndex)
89
{
90
mGrabIndex = screen->pushGrab (0, "freewins");
91
}
92
}
93
94
if (useW)
95
{
96
if (true || optionGetShapeWindowTypes ().evaluate (useW))
97
{
98
FREEWINS_WINDOW (useW);
99
100
int x = CompOption::getIntOptionNamed (options, "x",
101
useW->x () + (useW->width () / 2));
102
int y = CompOption::getIntOptionNamed (options, "y",
103
useW->y () + (useW->height () / 2));
104
105
int mods = CompOption::getIntOptionNamed (options, "modifiers", 0);
106
107
mGrabWindow = useW;
108
109
fww->mGrab = grabRotate;
110
111
/* Save current scales and angles */
112
113
fww->mAnimate.oldAngX = fww->mTransform.angX;
114
fww->mAnimate.oldAngY = fww->mTransform.angY;
115
fww->mAnimate.oldAngZ = fww->mTransform.angZ;
116
fww->mAnimate.oldScaleX = fww->mTransform.scaleX;
117
fww->mAnimate.oldScaleY = fww->mTransform.scaleY;
118
119
if (pointerY > fww->mIMidY)
120
{
121
if (pointerX > fww->mIMidX)
122
fww->mCorner = CornerBottomRight;
123
else if (pointerX < fww->mIMidX)
124
fww->mCorner = CornerBottomLeft;
125
}
126
else if (pointerY < fww->mIMidY)
127
{
128
if (pointerX > fww->mIMidX)
129
fww->mCorner = CornerTopRight;
130
else if (pointerX < fww->mIMidX)
131
fww->mCorner = CornerTopLeft;
132
}
133
134
switch (optionGetZAxisRotation ())
135
{
136
case ZAxisRotationAlways3d:
137
fww->mCan3D = TRUE;
138
fww->mCan2D = FALSE;
139
break;
140
141
case ZAxisRotationAlways2d:
142
fww->mCan3D = FALSE;
143
fww->mCan2D = TRUE;
144
break;
145
146
case ZAxisRotationDetermineOnClick:
147
case ZAxisRotationSwitch:
148
fww->determineZAxisClick (pointerX, pointerY, FALSE);
149
break;
150
151
case ZAxisRotationInterchangeable:
152
fww->mCan3D = TRUE;
153
fww->mCan2D = TRUE;
154
break;
155
156
default:
157
break;
158
}
159
160
/* Set the rotation axis */
161
162
switch (optionGetRotationAxis ())
163
{
164
case RotationAxisAlwaysCentre:
165
default:
166
fww->calculateInputOrigin (WIN_REAL_X (mGrabWindow) +
167
WIN_REAL_W (mGrabWindow) / 2.0f,
168
WIN_REAL_Y (mGrabWindow) +
169
WIN_REAL_H (mGrabWindow) / 2.0f);
170
fww->calculateOutputOrigin (WIN_OUTPUT_X (mGrabWindow) +
171
WIN_OUTPUT_W (mGrabWindow) / 2.0f,
172
WIN_OUTPUT_Y (mGrabWindow) +
173
WIN_OUTPUT_H (mGrabWindow) / 2.0f);
174
break;
175
176
case RotationAxisClickPoint:
177
fww->calculateInputOrigin (mClick_root_x, mClick_root_y);
178
fww->calculateOutputOrigin (mClick_root_x, mClick_root_y);
179
break;
180
181
case RotationAxisOppositeToClick:
182
fww->calculateInputOrigin (useW->x () + useW->width () - mClick_root_x,
183
useW->y () + useW->height () - mClick_root_y);
184
fww->calculateOutputOrigin (useW->x () + useW->width () - mClick_root_x,
185
useW->y () + useW->height () - mClick_root_y);
186
break;
187
}
188
189
/* Announce that we grabbed the window */
190
useW->grabNotify (x, y, mods, CompWindowGrabMoveMask |
191
CompWindowGrabButtonMask);
192
193
/* Shape the window beforehand and avoid a stale grab */
194
if (fww->canShape ())
195
if (fww->handleWindowInputInfo ())
196
fww->adjustIPW ();
197
198
cScreen->damageScreen ();
199
200
if (state & CompAction::StateInitButton)
201
action->setState (action->state () | CompAction::StateTermButton);
202
203
}
204
}
205
return true;
206
}
207
208
bool
209
FWScreen::terminateFWRotate (CompAction *action,
210
CompAction::State state,
211
CompOption::Vector options)
212
{
213
if (mGrabWindow && mGrabIndex)
214
{
215
FREEWINS_WINDOW (mGrabWindow);
216
if (fww->mGrab == grabRotate)
217
{
218
int distX, distY;
219
220
fww->window->ungrabNotify ();
221
222
switch (optionGetRotationAxis ())
223
{
224
case RotationAxisClickPoint:
225
case RotationAxisOppositeToClick:
226
227
distX = (fww->mOutputRect.x1 () +
228
(fww->mOutputRect.width ()) / 2.0f) -
229
(WIN_REAL_X (mGrabWindow) +
230
WIN_REAL_W (mGrabWindow) / 2.0f);
231
distY = (fww->mOutputRect.y1 () +
232
(fww->mOutputRect.height ()) / 2.0f) -
233
(WIN_REAL_Y (mGrabWindow) +
234
WIN_REAL_H (mGrabWindow) / 2.0f);
235
236
mGrabWindow->move (distX, distY, true);
237
238
fww->calculateInputOrigin (WIN_REAL_X (mGrabWindow) +
239
WIN_REAL_W (mGrabWindow) / 2.0f,
240
WIN_REAL_Y (mGrabWindow) +
241
WIN_REAL_H (mGrabWindow) / 2.0f);
242
fww->calculateOutputOrigin (WIN_OUTPUT_X (mGrabWindow) +
243
WIN_OUTPUT_W (mGrabWindow) / 2.0f,
244
WIN_OUTPUT_Y (mGrabWindow) +
245
WIN_OUTPUT_H (mGrabWindow) / 2.0f);
246
247
break;
248
default:
249
break;
250
}
251
252
if (fww->canShape ())
253
if (fww->handleWindowInputInfo ())
254
fww->adjustIPW ();
255
256
screen->removeGrab (mGrabIndex, 0);
257
mGrabIndex = 0;
258
mGrabWindow = NULL;
259
fww->mGrab = grabNone;
260
}
261
}
262
263
action->setState (action->state () & ~(CompAction::StateTermKey |
264
CompAction::StateTermButton));
265
266
return false;
267
}
268
269
/*static void FWMoveWindowToCorrectPosition (CompWindow *w, float distX, float distY)
270
{
271
272
FREEWINS_WINDOW (w); action->setState (action->state () & ~(CompAction::StateTermKey |
273
CompAction::StateTermButton));
274
275
fprintf(stderr, "distX is %f distY is %f midX and midY are %f %f\n", distX, distY, fww->mIMidX, fww->mIMidY);
276
277
moveWindow (w, distX * (1 + (1 - fww->mTransform.scaleX)), distY * (1 + (1 - fww->mTransform.scaleY)), TRUE, FALSE);
278
279
syncWindowPosition (w);
280
}*/
281
282
/* Initiate Scaling */
283
bool
284
FWScreen::initiateFWScale (CompAction *action,
285
CompAction::State state,
286
CompOption::Vector options)
287
{
288
CompWindow* w;
289
CompWindow *useW;
290
Window xid;
291
292
xid = CompOption::getIntOptionNamed (options, "window", 0);
293
w = screen->findWindow (xid);
294
useW = screen->findWindow (xid);
295
296
if (w)
297
{
298
foreach (FWWindowInputInfo *info, mTransformedWindows)
299
{
300
if (info->ipw)
301
if (w->id () == info->ipw)
302
/* The window we just grabbed was actually
303
* an IPW, get the real window instead
304
*/
305
useW = getRealWindow (w);
306
}
307
308
mRotateCursor = XCreateFontCursor (screen->dpy (), XC_fleur);
309
310
if (!screen->otherGrabExist ("freewins", 0))
311
if (!mGrabIndex)
312
mGrabIndex = screen->pushGrab (mRotateCursor, "freewins");
313
}
314
315
if (useW)
316
{
317
if (optionGetShapeWindowTypes ().evaluate (useW))
318
{
319
FREEWINS_WINDOW (useW);
320
321
int x = CompOption::getIntOptionNamed (options, "x",
322
useW->x () + (useW->width () / 2));
323
int y = CompOption::getIntOptionNamed (options, "y",
324
useW->y () + (useW->height () / 2));
325
326
int mods = CompOption::getIntOptionNamed (options, "modifiers", 0);
327
328
mGrabWindow = useW;
329
330
/* Find out the corner we clicked in */
331
332
float MidX = fww->mInputRect.centerX ();
333
float MidY = fww->mInputRect.centerY ();
334
335
/* Check for Y axis clicking (Top / Bottom) */
336
if (pointerY > MidY)
337
{
338
/* Check for X axis clicking (Left / Right) */
339
if (pointerX > MidX)
340
fww->mCorner = CornerBottomRight;
341
else if (pointerX < MidX)
342
fww->mCorner = CornerBottomLeft;
343
}
344
else if (pointerY < MidY)
345
{
346
/* Check for X axis clicking (Left / Right) */
347
if (pointerX > MidX)
348
fww->mCorner = CornerTopRight;
349
else if (pointerX < MidX)
350
fww->mCorner = CornerTopLeft;
351
}
352
353
switch (optionGetScaleMode ())
354
{
355
case ScaleModeToCentre:
356
fww->calculateInputOrigin(WIN_REAL_X (useW) + WIN_REAL_W (useW) / 2.0f,
357
WIN_REAL_Y (useW) + WIN_REAL_H (useW) / 2.0f);
358
fww->calculateOutputOrigin(WIN_OUTPUT_X (useW) + WIN_OUTPUT_W (useW) / 2.0f,
359
WIN_OUTPUT_Y (useW) + WIN_OUTPUT_H (useW) / 2.0f);
360
break;
361
/*
362
*Experimental scale to corners mode
363
*/
364
case ScaleModeToOppositeCorner:
365
switch (fww->mCorner)
366
{
367
case CornerBottomRight:
368
/* Translate origin to the top left of the window */
369
//FWMoveWindowToCorrectPosition (w, fww->inputRect.x1 - WIN_REAL_X (useW), fww->inputRect.y1 - WIN_REAL_Y (useW));
370
fww->calculateInputOrigin (WIN_REAL_X (useW), WIN_REAL_Y (useW));
371
break;
372
373
case CornerBottomLeft:
374
/* Translate origin to the top right of the window */
375
//FWMoveWindowToCorrectPosition (w, fww->inputRect.x2 - (WIN_REAL_X (useW) + WIN_REAL_W (useW)), fww->inputRect.y1 - WIN_REAL_Y (useW));
376
fww->calculateInputOrigin (WIN_REAL_X (useW) + (WIN_REAL_W (useW)), WIN_REAL_Y (useW));
377
break;
378
379
case CornerTopRight:
380
/* Translate origin to the bottom left of the window */
381
//FWMoveWindowToCorrectPosition (w, fww->inputRect.x1 - WIN_REAL_X (useW) , fww->inputRect.y1 - (WIN_REAL_Y (useW) + WIN_REAL_H (useW)));
382
fww->calculateInputOrigin (WIN_REAL_X (useW), WIN_REAL_Y (useW) + (WIN_REAL_H (useW)));
383
break;
384
385
case CornerTopLeft:
386
/* Translate origin to the bottom right of the window */
387
//FWMoveWindowToCorrectPosition (w, fww->inputRect.x1 -(WIN_REAL_X (useW) + WIN_REAL_W (useW)) , fww->inputRect.y1 - (WIN_REAL_Y (useW) + WIN_REAL_H (useW)));
388
fww->calculateInputOrigin (WIN_REAL_X (useW) + (WIN_REAL_W (useW)), WIN_REAL_Y (useW) + (WIN_REAL_H (useW)));
389
break;
390
}
391
break;
392
}
393
394
fww->mGrab = grabScale;
395
396
/* Announce that we grabbed the window */
397
useW->grabNotify (x, y, mods, CompWindowGrabMoveMask |
398
CompWindowGrabButtonMask);
399
400
cScreen->damageScreen ();
401
402
/* Shape the window beforehand and avoid a stale grab */
403
if (fww->canShape ())
404
if (fww->handleWindowInputInfo ())
405
fww->adjustIPW ();
406
407
408
if (state & CompAction::StateInitButton)
409
action->setState (action->state () | CompAction::StateTermButton);
410
}
411
}
412
413
return TRUE;
414
}
415
416
bool
417
FWScreen::terminateFWScale (CompAction *action,
418
CompAction::State state,
419
CompOption::Vector options)
420
{
421
if (mGrabWindow && mGrabIndex)
422
{
423
FREEWINS_WINDOW (mGrabWindow);
424
if (fww->mGrab == grabScale)
425
{
426
fww->window->ungrabNotify ();
427
428
switch (optionGetScaleMode ())
429
{
430
int distX, distY;
431
432
case ScaleModeToOppositeCorner:
433
distX = (fww->mOutputRect.x1 () + (fww->mOutputRect.width () / 2.0f) - (WIN_REAL_X (mGrabWindow) + WIN_REAL_W (mGrabWindow) / 2.0f));
434
distY = (fww->mOutputRect.y1 () + (fww->mOutputRect.width () / 2.0f) - (WIN_REAL_Y (mGrabWindow) + WIN_REAL_H (mGrabWindow) / 2.0f));
435
436
mGrabWindow->move (distX, distY, true);
437
438
fww->calculateInputOrigin (WIN_REAL_X (mGrabWindow) +
439
WIN_REAL_W (mGrabWindow) / 2.0f,
440
WIN_REAL_Y (mGrabWindow) +
441
WIN_REAL_H (mGrabWindow) / 2.0f);
442
fww->calculateOutputOrigin (WIN_OUTPUT_X (mGrabWindow) +
443
WIN_OUTPUT_W (mGrabWindow) / 2.0f,
444
WIN_OUTPUT_Y (mGrabWindow) +
445
WIN_OUTPUT_H (mGrabWindow) / 2.0f);
446
447
break;
448
449
default:
450
break;
451
452
}
453
454
screen->removeGrab (mGrabIndex, 0);
455
mGrabIndex = 0;
456
mGrabWindow = NULL;
457
fww->mGrab = grabNone;
458
}
459
}
460
461
action->setState (action->state () & ~(CompAction::StateTermKey |
462
CompAction::StateTermButton));
463
464
return FALSE;
465
}
466
467
/* Repetitive Stuff */
468
469
void
470
FWWindow::setPrepareRotation (float dx,
471
float dy,
472
float dz,
473
float dsu,
474
float dsd)
475
{
476
if (FWScreen::get (screen)->optionGetShapeWindowTypes ().evaluate (window))
477
{
478
calculateInputOrigin (WIN_REAL_X (window) +
479
WIN_REAL_W (window) / 2.0f,
480
WIN_REAL_Y (window) +
481
WIN_REAL_H (window) / 2.0f);
482
calculateOutputOrigin (WIN_OUTPUT_X (window) +
483
WIN_OUTPUT_W (window) / 2.0f,
484
WIN_OUTPUT_Y (window) +
485
WIN_OUTPUT_H (window) / 2.0f);
486
487
mTransform.unsnapAngX += dy;
488
mTransform.unsnapAngY -= dx;
489
mTransform.unsnapAngZ += dz;
490
491
mTransform.unsnapScaleX += dsu;
492
mTransform.unsnapScaleY += dsd;
493
494
mAnimate.oldAngX = mTransform.angX;
495
mAnimate.oldAngY = mTransform.angY;
496
mAnimate.oldAngZ = mTransform.angZ;
497
498
mAnimate.oldScaleX = mTransform.scaleX;
499
mAnimate.oldScaleY = mTransform.scaleY;
500
501
mAnimate.destAngX = mTransform.angX + dy;
502
mAnimate.destAngY = mTransform.angY - dx;
503
mAnimate.destAngZ = mTransform.angZ + dz;
504
505
mAnimate.destScaleX = mTransform.scaleX + dsu;
506
mAnimate.destScaleY = mTransform.scaleY + dsd;
507
508
}
509
}
510
511
#define ROTATE_INC freewinsGetRotateIncrementAmount (w->screen)
512
#define NEG_ROTATE_INC freewinsGetRotateIncrementAmount (w->screen) *-1
513
514
#define SCALE_INC freewinsGetScaleIncrementAmount (w->screen)
515
#define NEG_SCALE_INC freewinsGetScaleIncrementAmount (w->screen) *-1
516
517
bool
518
FWScreen::rotate (CompAction *action,
519
CompAction::State state,
520
CompOption::Vector options, int dx, int dy, int dz)
521
{
522
CompWindow *w = screen->findWindow (CompOption::getIntOptionNamed (options,
523
"window",
524
0));
525
foreach (FWWindowInputInfo *info, mTransformedWindows)
526
{
527
if (info->ipw == w->id ())
528
{
529
w = getRealWindow (w);
530
}
531
}
532
533
FREEWINS_WINDOW (w);
534
535
fww->setPrepareRotation (dx, dy, dz, 0, 0);
536
537
if (fww->canShape ())
538
if (fww->handleWindowInputInfo ())
539
fww->adjustIPW ();
540
541
return true;
542
}
543
544
bool
545
FWScreen::scale (CompAction *action,
546
CompAction::State state,
547
CompOption::Vector options,
548
int scale)
549
{
550
CompWindow *w = screen->findWindow (CompOption::getIntOptionNamed (options,
551
"window",
552
0));
553
foreach (FWWindowInputInfo *info, mTransformedWindows)
554
{
555
if (info->ipw == w->id ())
556
{
557
w = getRealWindow (w);
558
}
559
}
560
561
FREEWINS_WINDOW (w);
562
563
fww->setPrepareRotation (0, 0, 0, scale, scale);
564
fww->cWindow->addDamage ();
565
566
if (fww->canShape ())
567
if (fww->handleWindowInputInfo ())
568
fww->adjustIPW ();
569
570
if (!optionGetAllowNegative ())
571
{
572
float minScale = optionGetMinScale ();
573
574
if (fww->mAnimate.destScaleX < minScale)
575
fww->mAnimate.destScaleX = minScale;
576
577
if (fww->mAnimate.destScaleY < minScale)
578
fww->mAnimate.destScaleY = minScale;
579
}
580
581
return true;
582
}
583
584
/* Reset the Rotation and Scale to 0 and 1 */
585
bool
586
FWScreen::resetFWTransform (CompAction *action,
587
CompAction::State state,
588
CompOption::Vector options)
589
{
590
CompWindow *w = screen->findWindow (CompOption::getIntOptionNamed (options,
591
"window",
592
0));
593
foreach (FWWindowInputInfo *info, mTransformedWindows)
594
{
595
if (info->ipw == w->id ())
596
{
597
w = getRealWindow (w);
598
}
599
}
600
601
if (w)
602
{
603
FREEWINS_WINDOW (w);
604
fww->setPrepareRotation (fww->mTransform.angY,
605
-fww->mTransform.angX,
606
-fww->mTransform.angZ,
607
(1 - fww->mTransform.scaleX),
608
(1 - fww->mTransform.scaleY));
609
fww->cWindow->addDamage ();
610
611
fww->mTransformed = FALSE;
612
613
if (fww->canShape ())
614
if (fww->handleWindowInputInfo ())
615
fww->adjustIPW ();
616
617
fww->mResetting = TRUE;
618
}
619
620
return TRUE;
621
}
622
623
/* Callable action to rotate a window to the angle provided
624
* x: Set angle to x degrees
625
* y: Set angle to y degrees
626
* z: Set angle to z degrees
627
* window: The window to apply the transformation to
628
*/
629
bool
630
FWScreen::rotateAction (CompAction *action,
631
CompAction::State state,
632
CompOption::Vector options)
633
{
634
CompWindow *w;
635
636
w = screen->findWindow (CompOption::getIntOptionNamed (options, "window", 0));
637
638
if (w)
639
{
640
FREEWINS_WINDOW (w);
641
642
float x = CompOption::getFloatOptionNamed(options, "x", 0.0f);
643
float y = CompOption::getFloatOptionNamed(options, "y", 0.0f);
644
float z = CompOption::getFloatOptionNamed(options, "z", 0.0f);
645
646
fww->setPrepareRotation (x - fww->mAnimate.destAngX,
647
y - fww->mAnimate.destAngY,
648
z - fww->mAnimate.destAngZ, 0, 0);
649
fww->cWindow->addDamage ();
650
651
}
652
else
653
{
654
return false;
655
}
656
657
return true;
658
}
659
660
/* Callable action to increment window rotation by the angles provided
661
* x: Increment angle by x degrees
662
* y: Increment angle by y degrees
663
* z: Increment angle by z degrees
664
* window: The window to apply the transformation to
665
*/
666
bool
667
FWScreen::incrementRotateAction (CompAction *action,
668
CompAction::State state,
669
CompOption::Vector options)
670
{
671
CompWindow *w;
672
673
w = screen->findWindow (CompOption::getIntOptionNamed (options, "window", 0));
674
675
if (w)
676
{
677
FREEWINS_WINDOW (w);
678
679
float x = CompOption::getFloatOptionNamed(options, "x", 0.0f);
680
float y = CompOption::getFloatOptionNamed(options, "y", 0.0f);
681
float z = CompOption::getFloatOptionNamed(options, "z", 0.0f);
682
683
fww->setPrepareRotation (x,
684
y,
685
z, 0, 0);
686
fww->cWindow->addDamage ();
687
688
}
689
else
690
{
691
return false;
692
}
693
694
return true;
695
}
696
697
/* Callable action to scale a window to the scale provided
698
* x: Set scale to x factor
699
* y: Set scale to y factor
700
* window: The window to apply the transformation to
701
*/
702
bool
703
FWScreen::scaleAction (CompAction *action,
704
CompAction::State state,
705
CompOption::Vector options)
706
{
707
CompWindow *w;
708
709
w = screen->findWindow (CompOption::getIntOptionNamed (options, "window", 0));
710
711
if (w)
712
{
713
FREEWINS_WINDOW (w);
714
715
float x = CompOption::getFloatOptionNamed (options, "x", 0.0f);
716
float y = CompOption::getFloatOptionNamed (options, "y", 0.0f);
717
718
fww->setPrepareRotation (0, 0, 0,
719
x - fww->mAnimate.destScaleX,
720
y - fww->mAnimate.destScaleY);
721
if (fww->canShape ())
722
if (fww->handleWindowInputInfo ())
723
fww->adjustIPW ();
724
725
/* Stop scale at threshold specified */
726
if (!optionGetAllowNegative ())
727
{
728
float minScale = optionGetMinScale ();
729
if (fww->mAnimate.destScaleX < minScale)
730
fww->mAnimate.destScaleX = minScale;
731
732
if (fww->mAnimate.destScaleY < minScale)
733
fww->mAnimate.destScaleY = minScale;
734
}
735
736
fww->cWindow->addDamage ();
737
738
if (fww->canShape ())
739
fww->handleWindowInputInfo ();
740
741
}
742
else
743
{
744
return false;
745
}
746
747
return true;
748
}
749
750
/* Toggle Axis-Help Display */
751
bool
752
FWScreen::toggleFWAxis (CompAction *action,
753
CompAction::State state,
754
CompOption::Vector options)
755
{
756
mAxisHelp = !mAxisHelp;
757
758
cScreen->damageScreen ();
759
760
return TRUE;
761
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1