Merge lp:~vanvugt/compiz/back-to-raring into lp:compiz/0.9.9

[Daniel van Vugt]

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)

To review this proposal, all you need to do is verify that it makes lp:compiz/0.9.9 identical to lp:compiz/raring

[Sam Spilsbury (smspillaz)]

Thanks.

Can you make sure that that lp:~compiz-team/compiz/0.9.10 is set to append_only revisions? That way we can eliminate any potential February 10 disasters before they happen again.

review: Approve

[Daniel van Vugt (vanvugt)]

Yep, I already set append_only a few minutes ago.

[Sam Spilsbury (smspillaz)]

Awesome, thanks.

On Tue, Apr 2, 2013 at 3:13 PM, Daniel van Vugt
<email address hidden> wrote:
> Yep, I already set append_only a few minutes ago.
> --
> https://code.launchpad.net/~vanvugt/compiz/back-to-raring/+merge/156459
> You are reviewing the proposed merge of lp:~vanvugt/compiz/back-to-raring into lp:compiz/0.9.9.

--
Sam Spilsbury

[Didier Roche-Tolomelli (didrocks)]

@Daniel: if you are wanting to make 0.9.9 the new "raring" branch, it's better to do the other way around:
- having lp:compiz/raring being 0.9.9
- merging the old 0.9.9 (moved elsewhere) merged in this 0.9.9 branch which was raring

-> This is needed for "Automatic snapshot from revision 3641" as rev 3641 will not correspond to anything otherwise.
Another way will be to add a changelog with a fake Automatic snapshot from revision <…> which will be the first revision not in raring but in old 0.9.9.

review: Needs Fixing

[lp:~vanvugt/compiz/back-to-raring]

3645. By Daniel van Vugt on 2013-04-02

Update debian changelog

3646. By Daniel van Vugt on 2013-04-02

Modify changelog comment so that robots can understand it and insert accurate
bug info.

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'compizconfig/tests/compizconfig_backend_concept_test.h'
--- compizconfig/tests/compizconfig_backend_concept_test.h	2013-03-06 13:44:06 +0000
+++ compizconfig/tests/compizconfig_backend_concept_test.h	2013-04-02 07:48:28 +0000
@@ -90,7 +90,7 @@
 	CCSBackendConceptTestEnvironmentInterface::Ptr
 	ConstructTestEnv ()
 	{
-	    return boost::make_shared <I> ();
+	    return boost::shared_static_cast <I> (boost::make_shared <I> ());
 	}
 };
 

=== modified file 'debian/changelog'
--- debian/changelog	2013-02-28 04:02:41 +0000
+++ debian/changelog	2013-04-02 07:48:28 +0000
@@ -1,3 +1,83 @@
+compiz (1:0.9.9~daily13.04.02-0ubuntu1) UNRELEASED; urgency=low
+
+  [Daniel van Vugt]
+  * Merge lp:compiz/raring back in to lp:compiz/0.9.9 so we can maintain
+    raring from lp:compiz/0.9.9. The last common revision was 3629, so...
+  * Automatic snapshot from revision 3629
+
+ -- Daniel van Vugt <[e-mail]>  Tue, 02 Apr 2013 15:22:54 +0800
+
+compiz (1:0.9.9~daily13.03.29-0ubuntu1) raring; urgency=low
+
+  [ Michael Terry ]
+  * [regression-r3635] Guake window appears placed by offset non-
+    existent decoration (LP: #1159324)
+
+  [ Ubuntu daily release ]
+  * Automatic snapshot from revision 3641
+
+ -- Ubuntu daily release <[e-mail]>  Fri, 29 Mar 2013 07:23:54 +0000
+
+compiz (1:0.9.9~daily13.03.25-0ubuntu1) raring; urgency=low
+
+  [ Michael Terry ]
+  * [regression] Unmaximized windows can't be closed, minimized, moved
+    (LP: #1158161)
+
+  [ MC Return ]
+  * Multimonitor: Grid plugin: Wrong calculation of top left mouse-grid-
+    resize corner coordinates (LP: #1139835)
+
+  [ Ubuntu daily release ]
+  * Automatic snapshot from revision 3639
+
+ -- Ubuntu daily release <[e-mail]>  Mon, 25 Mar 2013 04:02:57 +0000
+
+compiz (1:0.9.9~daily13.03.20-0ubuntu1) raring; urgency=low
+
+  [ Sam Spilsbury ]
+  * Latest compiz update breaks Java Swing decorations (LP: #1138517)
+  * [regression-r3623] Wallpaper bleeds through on top right when a
+    window is opened maximized (LP: #1140505)
+
+  [ Ubuntu daily release ]
+  * Automatic snapshot from revision 3636
+
+ -- Ubuntu daily release <[e-mail]>  Wed, 20 Mar 2013 04:02:51 +0000
+
+compiz (1:0.9.9~daily13.03.08-0ubuntu1) raring; urgency=low
+
+  [ Brandon Schaefer ]
+  * [regression] Shortcut overlay does not hide when modifier key is
+    pressed (LP: #1075207)
+  * Unity blocks other programs from binding globally to Super+* (* =
+    any key) (LP: #950160)
+
+  [ Automatic PS uploader ]
+  * Automatic snapshot from revision 3633
+
+ -- Automatic PS uploader <[e-mail]>  Fri, 08 Mar 2013 10:34:21 +0000
+
+compiz (1:0.9.9~daily13.03.06-0ubuntu1) raring; urgency=low
+
+  [ Łukasz 'sil2100' Zemczak ]
+  * Latest compiz update breaks Java Swing decorations (LP: #1138517)
+
+  [ Automatic PS uploader ]
+  * Automatic snapshot from revision 3631
+
+ -- Automatic PS uploader <[e-mail]>  Wed, 06 Mar 2013 13:26:19 +0000
+
+compiz (1:0.9.9~daily13.03.01-0ubuntu1) raring; urgency=low
+
+  [ MC Return ]
+  * Multiple minor code and style issues (LP: #1134251)
+
+  [ Automatic PS uploader ]
+  * Automatic snapshot from revision 3629
+
+ -- Automatic PS uploader <[e-mail]>  Fri, 01 Mar 2013 04:02:19 +0000
+
 compiz (1:0.9.9~daily13.02.28-0ubuntu1) raring; urgency=low
 
   [ Sam Spilsbury ]

=== modified file 'debian/compiz-plugins.install'
--- debian/compiz-plugins.install	2013-02-26 16:48:27 +0000
+++ debian/compiz-plugins.install	2013-04-02 07:48:28 +0000
@@ -11,7 +11,6 @@
 debian/tmp/usr/*/compiz/*extrawm.*
 debian/tmp/usr/*/compiz/*fadedesktop.*
 debian/tmp/usr/*/compiz/*firepaint.*
-debian/tmp/usr/*/compiz/*freewins.*
 debian/tmp/usr/*/compiz/*gears.*
 debian/tmp/usr/*/compiz/*imgjpeg.*
 debian/tmp/usr/*/compiz/*imgsvg.*

=== modified file 'gtk/window-decorator/tests/test_gwd_settings.cpp'
--- gtk/window-decorator/tests/test_gwd_settings.cpp	2013-03-06 13:44:06 +0000
+++ gtk/window-decorator/tests/test_gwd_settings.cpp	2013-04-02 07:48:28 +0000
@@ -1473,7 +1473,7 @@
 };
 
 INSTANTIATE_TEST_CASE_P (MockStorageUpdates, GWDSettingsTestStorageUpdates,
-			 ::testing::Values (boost::shared_ptr <GWDSettingsStorageFactoryWrapperInterface> (new GWDMockSettingsStorageFactoryWrapper ())));
+			 ::testing::Values (boost::shared_static_cast <GWDSettingsStorageFactoryWrapperInterface> (boost::make_shared <GWDMockSettingsStorageFactoryWrapper> ())));
 
 #ifdef USE_GSETTINGS
 class GWDSettingsStorageGSettingsTest :
@@ -1625,6 +1625,6 @@
 };
 
 INSTANTIATE_TEST_CASE_P (GSettingsStorageUpdates, GWDSettingsTestStorageUpdates,
-			 ::testing::Values (boost::shared_ptr <GWDSettingsStorageFactoryWrapperInterface> (new GWDSettingsStorageGSettingsFactoryWrapper ())));
+			 ::testing::Values (boost::shared_static_cast <GWDSettingsStorageFactoryWrapperInterface> (boost::make_shared <GWDSettingsStorageGSettingsFactoryWrapper> ())));
 
 #endif

=== modified file 'include/core/window.h'
--- include/core/window.h	2013-03-26 22:02:39 +0000
+++ include/core/window.h	2013-04-02 07:48:28 +0000
@@ -440,6 +440,8 @@
 
 	void move (int dx, int dy, bool immediate = true);
 
+	void syncPosition ();
+
 	void moveInputFocusTo ();
 
 	void moveInputFocusToOtherWindow ();

=== modified file 'plugins/CMakeLists.txt'
--- plugins/CMakeLists.txt	2013-03-08 18:42:22 +0000
+++ plugins/CMakeLists.txt	2013-04-02 07:48:28 +0000
@@ -23,7 +23,6 @@
 # disable plugins which won't work on ES2 builds
 if (BUILD_GLES)
 
-    set (COMPIZ_DISABLE_PLUGIN_FREEWINS ON)
     set (COMPIZ_DISABLE_PLUGIN_GEARS ON)
     set (COMPIZ_DISABLE_PLUGIN_TD ON)
     set (COMPIZ_DISABLE_PLUGIN_COLORFILTER ON)

=== modified file 'plugins/composite/src/pixmapbinding/tests/test-composite-pixmapbinding.cpp'
--- plugins/composite/src/pixmapbinding/tests/test-composite-pixmapbinding.cpp	2013-03-06 13:44:06 +0000
+++ plugins/composite/src/pixmapbinding/tests/test-composite-pixmapbinding.cpp	2013-04-02 07:48:28 +0000
@@ -167,7 +167,7 @@
     EXPECT_CALL (msg, grabServer ());
     EXPECT_CALL (msg, syncServer ()).Times (2);
     EXPECT_CALL (mwag, getAttributes (_)).WillOnce (Invoke (&fwag, &FakeWindowAttributesGet::getAttributes));
-    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (wp));
+    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (boost::shared_static_cast <WindowPixmapInterface> (wp)));
 
     EXPECT_CALL (*wp, pixmap ()).WillOnce (Return (1));
 
@@ -214,7 +214,7 @@
     EXPECT_CALL (msg, grabServer ());
     EXPECT_CALL (msg, syncServer ()).Times (2);
     EXPECT_CALL (mwag, getAttributes (_)).WillOnce (Invoke (&fwag, &FakeWindowAttributesGet::getAttributes));
-    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (wp));
+    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (boost::shared_static_cast <WindowPixmapInterface> (wp)));
 
     EXPECT_CALL (*wp, pixmap ()).WillOnce (Return (1));
 
@@ -262,7 +262,7 @@
     EXPECT_CALL (msg, grabServer ());
     EXPECT_CALL (msg, syncServer ()).Times (2);
     EXPECT_CALL (mwag, getAttributes (_)).WillOnce (Invoke (&fwag, &FakeWindowAttributesGet::getAttributes));
-    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (wp));
+    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (boost::shared_static_cast <WindowPixmapInterface> (wp)));
 
     EXPECT_CALL (*wp, pixmap ()).WillOnce (Return (1));
 
@@ -284,7 +284,7 @@
     EXPECT_CALL (msg, grabServer ());
     EXPECT_CALL (msg, syncServer ()).Times (2);
     EXPECT_CALL (mwag, getAttributes (_)).WillOnce (Invoke (&fwag, &FakeWindowAttributesGet::getAttributes));
-    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (wp));
+    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (boost::shared_static_cast <WindowPixmapInterface> (wp)));
 
     EXPECT_CALL (*wp, pixmap ()).WillOnce (Return (1));
 
@@ -331,7 +331,7 @@
     EXPECT_CALL (msg, grabServer ());
     EXPECT_CALL (msg, syncServer ()).Times (2);
     EXPECT_CALL (mwag, getAttributes (_)).WillOnce (Invoke (&fwag, &FakeWindowAttributesGet::getAttributes));
-    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (wp));
+    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (boost::shared_static_cast <WindowPixmapInterface> (wp)));
 
     EXPECT_CALL (*wp, pixmap ()).WillOnce (Return (1));
 
@@ -450,7 +450,7 @@
     EXPECT_CALL (msg, grabServer ());
     EXPECT_CALL (msg, syncServer ()).Times (2);
     EXPECT_CALL (mwag, getAttributes (_)).WillOnce (Invoke (&fwag, &FakeWindowAttributesGet::getAttributes));
-    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (wp));
+    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (boost::shared_static_cast <WindowPixmapInterface> (wp)));
 
     EXPECT_CALL (*wp, pixmap ()).WillOnce (Return (0));
 
@@ -510,7 +510,7 @@
     EXPECT_CALL (msg, grabServer ());
     EXPECT_CALL (msg, syncServer ()).Times (2);
     EXPECT_CALL (mwag, getAttributes (_)).WillOnce (Invoke (&fwag2, &FakeWindowAttributesGet::getAttributes));
-    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (wp));
+    EXPECT_CALL (mwpg, getPixmap ()).WillOnce (Return (boost::shared_static_cast <WindowPixmapInterface> (wp)));
 
     EXPECT_CALL (msg, ungrabServer ());
 

=== modified file 'plugins/decor/src/decor.cpp'
--- plugins/decor/src/decor.cpp	2013-03-27 01:31:21 +0000
+++ plugins/decor/src/decor.cpp	2013-04-02 07:48:28 +0000
@@ -395,7 +395,7 @@
 
     DecorPixmap::Ptr pm = boost::make_shared <DecorPixmap> (pixmap, mReleasePool);
 
-    DecorTexture *texture = new DecorTexture (pm);
+    DecorTexture *texture = new DecorTexture (boost::shared_static_cast <DecorPixmapInterface> (pm));
 
     if (!texture->status)
     {
@@ -1297,7 +1297,7 @@
 	if (d->frameType == frameType &&
 	    d->frameState == frameState &&
 	    d->frameActions == frameActions)
-	    return d;
+	    return boost::shared_static_cast <DecorationInterface> (d);
     }
 
     return DecorationInterface::Ptr ();
@@ -3106,7 +3106,7 @@
 				   0,
 				   0,
 				   None,
-				   boost::shared_array <decor_quad_t> (static_cast <decor_quad_t *> (NULL)),
+				   boost::shared_array <decor_quad_t> (NULL),
 				   0,
 				   screen->root (),
 				   NULL)),

=== modified file 'plugins/decor/src/pixmap-requests/tests/test-decor-pixmap-requests.cpp'
--- plugins/decor/src/pixmap-requests/tests/test-decor-pixmap-requests.cpp	2013-03-06 13:44:06 +0000
+++ plugins/decor/src/pixmap-requests/tests/test-decor-pixmap-requests.cpp	2013-04-02 07:48:28 +0000
@@ -45,7 +45,7 @@
 TEST(DecorPixmapRequestsTest, TestDestroyPixmapDeletes)
 {
     boost::shared_ptr <MockDecorPixmapDeletor> mockDeletor = boost::make_shared <MockDecorPixmapDeletor> ();
-    DecorPixmap pm (1, mockDeletor);
+    DecorPixmap pm (1, boost::shared_static_cast<PixmapDestroyQueue> (mockDeletor));
 
     EXPECT_CALL (*(mockDeletor.get ()), destroyUnusedPixmap (1)).WillOnce (Return (1));
 }

=== modified file 'plugins/expo/src/expo.cpp'
--- plugins/expo/src/expo.cpp	2013-03-26 22:02:39 +0000
+++ plugins/expo/src/expo.cpp	2013-04-02 07:48:28 +0000
@@ -247,6 +247,7 @@
 void
 ExpoScreen::finishWindowMovement ()
 {
+    dndWindow->syncPosition ();
     dndWindow->ungrabNotify ();
 
     screen->moveViewport (screen->vp ().x () - selectedVp.x (),

=== removed directory 'plugins/freewins'
=== removed file 'plugins/freewins/AUTHORS'
--- plugins/freewins/AUTHORS	2012-07-22 08:50:52 +0000
+++ plugins/freewins/AUTHORS	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-The freewins plugin was written by:
-
-Rodolfo D. Granata (warlock_mza) <[e-mail]>
-Sam Spilsbury (smspillaz) <[e-mail]>
-
-Modifications by
-
-enigma_0Z <[e-mail]>

=== removed file 'plugins/freewins/CMakeLists.txt'
--- plugins/freewins/CMakeLists.txt	2012-07-22 08:50:52 +0000
+++ plugins/freewins/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-find_package (Compiz REQUIRED)
-
-include (CompizPlugin)
-include (FindOpenGL)
-
-if (OPENGL_GLU_FOUND)
-compiz_plugin (freewins PLUGINDEPS composite opengl PKGDEPS cairo-xlib cairo LIBRARIES ${OPENGL_glu_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR} LDFLAGSADD)
-endif (OPENGL_GLU_FOUND)

=== removed file 'plugins/freewins/COPYING'
--- plugins/freewins/COPYING	2012-07-22 08:50:52 +0000
+++ plugins/freewins/COPYING	1970-01-01 00:00:00 +0000
@@ -1,340 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-

-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-

-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-

-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-

-	    How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year  name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Library General
-Public License instead of this License.

=== removed file 'plugins/freewins/freewins.xml.in'
--- plugins/freewins/freewins.xml.in	2013-02-20 11:06:38 +0000
+++ plugins/freewins/freewins.xml.in	1970-01-01 00:00:00 +0000
@@ -1,398 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<compiz>
-    <plugin name="freewins" useBcop="true">
-	<_short>Freely Transformable Windows</_short>
-	<_long>Freely transform windows</_long>
-	<category>Effects</category>
-	<deps>
-		<requirement>
-			<plugin>opengl</plugin>
-		</requirement>
-		<relation type="after">
-			<plugin>opengl</plugin>
-			<plugin>scale</plugin>
-			<plugin>ring</plugin>
-			<plugin>shift</plugin>
-			<plugin>shelf</plugin>
-			<plugin>group</plugin>
-			<plugin>wobbly</plugin>
-			<plugin>animation</plugin>
-			<plugin>water</plugin>
-			<plugin>cubeaddon</plugin>
-			<plugin>3d</plugin>
-		</relation>
-	</deps>
-	<options>
-	<option name='rotate' type='action'/>
-	<option name='increment_rotate' type='action'/>
-	<option name='scale' type='action'/>
-	<group>
-		<_short>Free Transformation</_short>
-		<option type="button" name="initiate_rotation_button">
-			<_short>Initiate Rotation Button</_short>
-			<_long>Mouse button to start free rotation.</_long>
-			<default>&lt;Control&gt;&lt;Shift&gt;Button1</default>
-		</option>
-		<option type="button" name="initiate_scale_button">
-			<_short>Initiate Scaling Button</_short>
-			<_long>Mouse button to start free scaling.</_long>
-			<default>&lt;Control&gt;&lt;Shift&gt;Button3</default>
-		</option>
-		<option type="button" name="reset_button">
-			<_short>Reset Transformation Button</_short>
-			<_long>Mouse button to reset the transformation.</_long>
-			<default>&lt;Control&gt;&lt;Shift&gt;Button2</default>
-		</option>
-		<option type="key" name="reset_key">
-			<_short>Reset Transformation Key</_short>
-			<_long>Keyboard shortcut to reset the transformation.</_long>
-			<default>&lt;Control&gt;&lt;Shift&gt;r</default>
-		</option>
-		<option type="key" name="toggle_axis_key">
-			<_short>Axis Help Toggle</_short>
-			<_long>Keyboard shortcut to toggle the visibility of the axis selection helper.</_long>
-			<default>&lt;Control&gt;&lt;Shift&gt;h</default>
-		</option>
-		<subgroup>
-		<_short>Transformation Behaviour</_short>
-		<option name="snap_mods" type="list">
-		  <_short>Snap Modifier</_short>
-		  <_long>Use these bindings to enable/disable snapping.</_long>
-			  <type>int</type>
-			  <min>0</min>
-			  <max>3</max>
-			  <desc>
-				  <value>0</value>
-				  <_name>Shift</_name>
-			  </desc>
-			  <desc>
-				  <value>1</value>
-				  <_name>Alt</_name>
-			  </desc>
-			  <desc>
-				  <value>2</value>
-				  <_name>Control</_name>
-			  </desc>
-			  <desc>
-				  <value>3</value>
-				  <_name>Meta</_name>
-			  </desc>
-		</option>
-		</subgroup>
-		<subgroup>
-		<_short>Rotation</_short>
-		  <option name="invert_mods" type="list">
-		  <_short>Invert Modifier</_short>
-		  <_long>Use these bindings to invert the rotation mode.</_long>
-			  <type>int</type>
-			  <min>0</min>
-			  <max>3</max>
-			  <desc>
-				  <value>0</value>
-				  <_name>Shift</_name>
-			  </desc>
-			  <desc>
-				  <value>1</value>
-				  <_name>Alt</_name>
-			  </desc>
-			  <desc>
-				  <value>2</value>
-				  <_name>Control</_name>
-			  </desc>
-			  <desc>
-				  <value>3</value>
-				  <_name>Meta</_name>
-			  </desc>
-		</option>
-		</subgroup>
-    </group>
-	    <group>
-	    <_short>Manual Transformation</_short>
-		<subgroup>
-		    <_short>Scaling</_short>
-		<option type="button" name="scale_up_button">
-			    <_short>Scale Up Button</_short>
-			    <_long>Mouse button to scale the window up by one increment.</_long>
-				<default>&lt;Control&gt;&lt;Shift&gt;Button4</default>
-		</option>
-		<option type="button" name="scale_down_button">
-			    <_short>Scale Down Button</_short>
-			    <_long>Mouse button to scale the window down by one increment.</_long>
-				<default>&lt;Control&gt;&lt;Shift&gt;Button5</default>
-		</option>
-		    <_short>Scaling</_short>
-		<option type="key" name="scale_up_key">
-			    <_short>Scale Up Key</_short>
-			    <_long>Keyboard shortcut to scale the window up by one increment.</_long>
-				<default>&lt;Control&gt;&lt;Shift&gt;Page_Up</default>
-		</option>
-		<option type="key" name="scale_down_key">
-			    <_short>Scale Down Key</_short>
-			    <_long>Keyboard shortcut to scale the window down by one increment.</_long>
-				<default>&lt;Control&gt;&lt;Shift&gt;Page_Down</default>
-		</option>
-	    </subgroup>
-	    <subgroup>
-	    <_short>Rotation</_short>
-		    <option type="key" name="rotate_up_key">
-				<_short>Rotate Up Key</_short>
-				<_long>Keyboard shortcut to rotate the window up by one increment.</_long>
-		    		<default>&lt;Control&gt;&lt;Shift&gt;w</default>
-		    </option>
-		    <option type="key" name="rotate_down_key">
-				<_short>Rotate Down Key</_short>
-				<_long>Keyboard shortcut to rotate the window down by one increment.</_long>
-				<default>&lt;Control&gt;&lt;Shift&gt;s</default>
-		    </option>	
-		    <option type="key" name="rotate_left_key">
-				<_short>Rotate Left Key</_short>
-				<_long>Keyboard shortcut to rotate the window left by one increment.</_long>
-				<default>&lt;Control&gt;&lt;Shift&gt;d</default>
-		    </option>
-		    <option type="key" name="rotate_right_key">
-				<_short>Rotate Right Key</_short>
-				<_long>Keyboard shortcut to rotate the window right by one increment.</_long>
-				<default>&lt;Control&gt;&lt;Shift&gt;a</default>
-		    </option>
-		    <option type="key" name="rotate_c_key">
-				<_short>Rotate Clockwise Key</_short>
-				<_long>Keyboard shortcut to rotate the window clockwise by one increment.</_long>
-				<default>&lt;Control&gt;&lt;Shift&gt;e</default>
-		    </option>
-		    <option type="key" name="rotate_cc_key">
-				<_short>Rotate Counter-Clockwise Key</_short>
-				<_long>Keyboard shortcut to rotate the window counter-clockwise by one increment.</_long>
-				<default>&lt;Control&gt;&lt;Shift&gt;q</default>
-		    </option>
-		</subgroup>
-		</group>
-		<group>
-		<_short>Free Transformation</_short>
-	    <subgroup>
-	    <_short>Transformation Behaviour</_short>
-		    <option type="bool" name="snap">
-				    <_short>Snap By Default</_short>
-				    <_long>Snap to common points by default.</_long>
-				    <default>False</default>
-		    </option>
-		<option type="int" name="snap_threshold">
-				    <_short>Snap Threshold</_short>
-				    <_long>Snap to every one of these angles.</_long>
-				    <min>1</min>
-				    <max>100</max>
-		    </option>
-		    <option type="float" name="mouse_sensitivity">
-				<_short>Mouse Sensitivity</_short>
-				<_long>Adjust how sensitive the mouse movement should be.</_long>
-				<default>1.0</default>
-				<min>0.1</min>
-				<max>10.0</max>
-		    </option>
-	    </subgroup>
-		    <subgroup>
-		    <_short>Scaling</_short>
-			<option type="int" name="scale_mode">
-				    <_short>Scale Mode</_short>
-				    <_long>Select the method to scale windows.</_long>
-				    <desc>
-		            <value>0</value><name>To Centre</name>
-		        </desc>
-				    <desc>
-		            <value>1</value><name>To Opposite Corner</name>
-		        </desc>
-		        <min>0</min>
-		        <max>0</max>
-		        <default>0</default>
-			</option>
-			<option type="bool" name="allow_negative">
-				    <_short>Allow Negative</_short>
-				    <_long>Allow negative scaling</_long>
-				    <default>True</default>
-			</option>
-			<option type="bool" name="scale_uniform">
-				    <_short>Maintain Aspect Ratio</_short>
-				    <_long>Keep the aspect ratio of the window constant when scaling.</_long>
-				    <default>True</default>
-			</option>
-			<option type="float" name="min_scale">
-				    <_short>Minimum scale</_short>
-				    <_long>How small the scale is allowed to be when 'Allow Negative' is not activated.</_long>
-				    <default>0.1</default>
-				    <min>0.01</min>
-				    <max>1.0</max>
-			</option>
-		    </subgroup>
-		    <subgroup>
-		    <_short>Rotation</_short>
-			<option type="int" name="z_axis_rotation">
-				    <_short>Rotation Type</_short>
-				    <_long>Choose the type of the rotation.</_long>
-				    <desc>
-		            <value>0</value><name>Always 2D</name>
-		        </desc>
-				    <desc>
-		            <value>1</value><name>Always 3D</name>
-		        </desc>
-				    <desc>
-		            <value>2</value><name>Determine On Click</name>
-		        </desc>
-				    <desc>
-		            <value>3</value><name>Interchangeable</name>
-		        </desc>
-				    <desc>
-		            <value>4</value><name>Switch</name>
-		        </desc>
-				    <desc>
-		            <value>5</value><name>Trackball</name>
-		        </desc>
-		        <default>2</default>
-		        <min>0</min><max>3</max>
-			</option>
-			<option type="int" name="rotation_axis">
-				    <_short>Rotation Axis</_short>
-				    <_long>How Freely Transformable Windows should determine the rotation axis.</_long>
-				    <desc>
-		            <value>0</value><name>Always Centre</name>
-		        </desc>
-				    <desc>
-		            <value>1</value><name>Click Point</name>
-		        </desc>
-				    <desc>
-		            <value>2</value><name>Opposite to Click</name>
-		        </desc>
-				    <desc>
-		            <value>3</value><name>Nearest Corner</name>
-		        </desc>
-		        <min>0</min>
-		        <max>2</max>
-		        <default>0</default>
-			</option>
-		    <option type="float" name="TD_percent">
-		        <_short>3D Rotation Percentage</_short>
-		        <_long>The percentage of the window area used for 3D rotation.</_long>
-		        <default>35.0</default>
-		        <min>10.0</min>
-		        <max>90.0</max>
-		    </option>
-			<option type="bool" name="auto_zoom">
-				    <_short>Auto-Zoom</_short>
-				    <_long>Auto-Zoom when rotating so that windows do not get too large.</_long>
-				    <default>False</default>
-			</option>
-			<option type="bool" name="disable_on_transformed_screen">
-				    <_short>Disable On Transformed Screen</_short>
-				    <_long>Disable the rotation on a transformed screen. This prevents ugly looking clipped windows when the screen is transformed.</_long>
-				    <default>False</default>
-			</option>
-		</subgroup>
-		<subgroup>
-		    <_short>Transformation Behaviour</_short>
-		    <option type="float" name="speed">
-		        <_short>Window Rotation Speed</_short>
-		        <_long>How fast the window should rotate.</_long>
-		        <default>5.0</default>
-		        <min>0.1</min>
-		        <max>15.0</max>
-		    </option>
-		</subgroup>
-    </group>
-    <group>
-	    <_short>Manual Transformation</_short>
-	    <subgroup>
-		<_short>Rotation</_short>
-		    <option type="float" name="rotate_increment_amount">
-				    <_short>Rotate Increment Amount</_short>
-				    <_long>How far to rotate a window when rotating by an 'increment'.</_long>
-				    <default>10.0</default>
-				    <min>1.0</min>
-				    <max>100.0</max>
-			</option>
-	    </subgroup>
-	    <subgroup>
-	    <_short>Scaling</_short> 
-		<option type="float" name="scale_increment_amount">
-				<_short>Scale Increment Amount</_short>
-				<_long>How much to scale a window by when scaling by an 'increment'.</_long>
-				<default>0.3</default>
-				<min>0.01</min>
-				<max>0.5</max>
-		    </option>
-		</subgroup>
-		</group>
-	    <group>
-	    <_short>Misc</_short>
-		<subgroup>
-		<_short>Input Prevention</_short>
-		<option name="shape_window_types" type="match">
-		  <_short>Prevented Input Window Types</_short>
-		  <_long>Window types that should be shaped. Disable problematic windows here.</_long>
-		  <default>(Toolbar | Utility | Dialog | ModalDialog | Normal)</default>
-		</option>
-		<option type="bool" name="do_shape_input">
-			    <_short>Prevent Input</_short>
-			    <_long>Prevent input for transformed windows.</_long>
-			    <default>True</default>
-		    </option>
-		<option type="bool" name="immediate_moves">
-		    <_short>Immediate Moves</_short>
-		    <_long>Don't allow plugins like wobbly to manipulate the transformed window while it's being moved.</_long>
-		    <default>True</default>
-		</option>
-		</subgroup>
-	       <subgroup>
-		   <_short>Helper Options</_short>	    
-		    <option type="color" name="circle_color" >
-						<_short>Helper Circle Color</_short>
-						<_long>Color and opacity of the circle.</_long>
-						<default>
-							<red>0x5400</red>
-							<green>0xBE00</green>
-							<blue>0xFB00</blue>
-							<alpha>0x8000</alpha>
-						</default>
-			</option>
-			<option type="color" name="line_color" >
-						<_short>Helper Line Color</_short>
-						<_long>Color and opacity of the helper line around the circle.</_long>
-						<default>
-							<red>0x1800</red>
-							<green>0x0000</green>
-							<blue>0xFF00</blue>
-							<alpha>0xFFFF</alpha>
-						</default>
-			</option>
-			<option type="color" name="cross_line_color" >
-						<_short>Helper Cross Line Color</_short>
-						<_long>Color and opacity of the cross lines.</_long>
-						<default>
-							<red>0x1800</red>
-							<green>0x0000</green>
-							<blue>0xFF00</blue>
-							<alpha>0xFFFF</alpha>
-						</default>
-			</option>
-		<option type="bool" name="show_circle">
-			    <_short>Show 3D Rotation Circle</_short>
-			    <_long>Show the click area for 3D rotation.</_long>
-			    <default>True</default>
-		    </option>
-		<option type="bool" name="show_gizmo">
-			    <_short>Show Rotation Gizmo</_short>
-			    <_long>Show the rotation axis info.</_long>
-			    <default>True</default>
-		    </option>
-		<option type="bool" name="show_cross">
-			    <_short>Show Crosshair</_short>
-			    <_long>Show the crosshair for scaling click regions.</_long>
-			    <default>True</default>
-		    </option>
-		<option type="bool" name="show_region">
-			    <_short>Show Input Regions</_short>
-			    <_long>Show the input region rectangle.</_long>
-			    <default>True</default>
-		    </option>
-		</subgroup>
-		</group>
-	   </options>
-    </plugin>
-</compiz>

=== removed directory 'plugins/freewins/src'
=== removed file 'plugins/freewins/src/action.cpp'
--- plugins/freewins/src/action.cpp	2013-03-26 22:02:39 +0000
+++ plugins/freewins/src/action.cpp	1970-01-01 00:00:00 +0000
@@ -1,761 +0,0 @@
-/**
- * Compiz Fusion Freewins plugin
- *
- * action.cpp
- *
- * Copyright (C) 2007  Rodolfo Granata <[e-mail]>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * Author(s):
- * Rodolfo Granata <[e-mail]>
- * Sam Spilsbury <[e-mail]>
- *
- * Button binding support and Reset added by:
- * enigma_0Z <[e-mail]>
- *
- * Most of the input handling here is based on
- * the shelf plugin by
- *        : Kristian Lyngstøl <[e-mail]>
- *        : Danny Baumann <[e-mail]>
- *
- * Description:
- *
- * This plugin allows you to freely transform the texture of a window,
- * whether that be rotation or scaling to make better use of screen space
- * or just as a toy.
- *
- * Todo:
- *  - Fully implement an input redirection system by
- *    finding an inverse matrix, multiplying by it,
- *    translating to the actual window co-ords and
- *    XSendEvent() the co-ords to the actual window.
- *  - Code could be cleaner
- *  - Add timestep and speed options to animation
- *  - Add window hover-over info via paintOutput : i.e
- *    - Resize borders
- *    - 'Reset' Button
- *    - 'Scale' Button
- *    - 'Rotate' Button
- */
-
-/* TODO: Finish porting stuff to actions */
-
-#include "freewins.h"
-
-
-/* ------ Actions -------------------------------------------------------*/
-
-/* Initiate Mouse Rotation */
-bool
-FWScreen::initiateFWRotate (CompAction         *action,
-			    CompAction::State  state,
-			    CompOption::Vector options)
-{
-    CompWindow* w;
-    CompWindow *useW;
-    Window xid;
-
-    xid = CompOption::getIntOptionNamed (options, "window", 0);
-
-    w   = screen->findWindow (xid);
-    useW = screen->findWindow (xid);
-
-    if (w)
-    {
-
-	foreach (FWWindowInputInfo *info, mTransformedWindows)
-	{
-	    if (info->ipw)
-		if (w->id () == info->ipw)
-		/* The window we just grabbed was actually
-		 * an IPW, get the real window instead
-		 */
-		    useW = getRealWindow (w);
-	}
-
-	mRotateCursor = XCreateFontCursor (screen->dpy (), XC_fleur);
-
-	if (!screen->otherGrabExist ("freewins", 0))
-	    if (!mGrabIndex)
-	    {
-		mGrabIndex = screen->pushGrab (0, "freewins");
-	    }
-    }
-
-    if (useW)
-    {
-	if (true || optionGetShapeWindowTypes ().evaluate (useW))
-	{
-	    FREEWINS_WINDOW (useW);
-
-	    int x = CompOption::getIntOptionNamed (options, "x",
-					       useW->x () + (useW->width () / 2));
-	    int y = CompOption::getIntOptionNamed (options, "y",
-					       useW->y () + (useW->height () / 2));
-
-	    int mods = CompOption::getIntOptionNamed (options, "modifiers", 0);
-
-	    mGrabWindow = useW;
-
-	    fww->mGrab = grabRotate;
-
-	    /* Save current scales and angles */
-
-	    fww->mAnimate.oldAngX = fww->mTransform.angX;
-	    fww->mAnimate.oldAngY = fww->mTransform.angY;
-	    fww->mAnimate.oldAngZ = fww->mTransform.angZ;
-	    fww->mAnimate.oldScaleX = fww->mTransform.scaleX;
-	    fww->mAnimate.oldScaleY = fww->mTransform.scaleY;
-
-	    if (pointerY > fww->mIMidY)
-	    {
-		if (pointerX > fww->mIMidX)
-		    fww->mCorner = CornerBottomRight;
-		else if (pointerX < fww->mIMidX)
-		    fww->mCorner = CornerBottomLeft;
-	    }
-	    else if (pointerY < fww->mIMidY)
-	    {
-		if (pointerX > fww->mIMidX)
-		    fww->mCorner = CornerTopRight;
-		else if (pointerX < fww->mIMidX)
-		    fww->mCorner = CornerTopLeft;
-	    }
-
-	    switch (optionGetZAxisRotation ())
-	    {
-		case ZAxisRotationAlways3d:
-		    fww->mCan3D = TRUE;
-		    fww->mCan2D = FALSE;
-		    break;
-
-		case ZAxisRotationAlways2d:
-		    fww->mCan3D = FALSE;
-		    fww->mCan2D = TRUE;
-		    break;
-
-		case ZAxisRotationDetermineOnClick:
-		case ZAxisRotationSwitch:
-		    fww->determineZAxisClick (pointerX, pointerY, FALSE);
-		    break;
-
-		case ZAxisRotationInterchangeable:
-		    fww->mCan3D = TRUE;
-		    fww->mCan2D = TRUE;
-		    break;
-
-		default:
-		    break;
-	    }
-
-	    /* Set the rotation axis */
-
-	    switch (optionGetRotationAxis ())
-	    {
-		case RotationAxisAlwaysCentre:
-		default:
-		    fww->calculateInputOrigin (WIN_REAL_X (mGrabWindow) +
-					       WIN_REAL_W (mGrabWindow) / 2.0f,
-					       WIN_REAL_Y (mGrabWindow) +
-					       WIN_REAL_H (mGrabWindow) / 2.0f);
-		    fww->calculateOutputOrigin (WIN_OUTPUT_X (mGrabWindow) +
-						WIN_OUTPUT_W (mGrabWindow) / 2.0f,
-						WIN_OUTPUT_Y (mGrabWindow) +
-						WIN_OUTPUT_H (mGrabWindow) / 2.0f);
-		    break;
-
-		case RotationAxisClickPoint:
-		    fww->calculateInputOrigin (mClick_root_x, mClick_root_y);
-		    fww->calculateOutputOrigin (mClick_root_x, mClick_root_y);
-		    break;
-
-		case RotationAxisOppositeToClick:
-		    fww->calculateInputOrigin (useW->x () + useW->width () - mClick_root_x,
-					       useW->y () + useW->height () - mClick_root_y);
-		    fww->calculateOutputOrigin (useW->x () + useW->width () - mClick_root_x,
-						useW->y () + useW->height () - mClick_root_y);
-		    break;
-	    }
-
-	    /* Announce that we grabbed the window */
-	    useW->grabNotify (x, y, mods,  CompWindowGrabMoveMask |
-			      CompWindowGrabButtonMask);
-
-	    /* Shape the window beforehand and avoid a stale grab */
-	    if (fww->canShape ())
-		if (fww->handleWindowInputInfo ())
-		    fww->adjustIPW ();
-
-	    cScreen->damageScreen ();
-
-	    if (state & CompAction::StateInitButton)
-		action->setState (action->state () | CompAction::StateTermButton);
-
-	}
-    }
-    return true;
-}
-
-bool
-FWScreen::terminateFWRotate (CompAction          *action,
-			     CompAction::State   state,
-			     CompOption::Vector  options)
-{
-    if (mGrabWindow && mGrabIndex)
-    {
-	FREEWINS_WINDOW (mGrabWindow);
-	if (fww->mGrab == grabRotate)
-	{
-	    int distX, distY;
-
-	    fww->window->ungrabNotify ();
-
-	    switch (optionGetRotationAxis ())
-	    {
-		case RotationAxisClickPoint:
-		case RotationAxisOppositeToClick:
-
-		    distX =  (fww->mOutputRect.x1 () +
-			      (fww->mOutputRect.width ()) / 2.0f) -
-			     (WIN_REAL_X (mGrabWindow) +
-			      WIN_REAL_W (mGrabWindow) / 2.0f);
-		    distY = (fww->mOutputRect.y1 () +
-			     (fww->mOutputRect.height ()) / 2.0f) -
-			    (WIN_REAL_Y (mGrabWindow) +
-			     WIN_REAL_H (mGrabWindow) / 2.0f);
-
-		    mGrabWindow->move (distX, distY, true);
-
-		    fww->calculateInputOrigin (WIN_REAL_X (mGrabWindow) +
-					       WIN_REAL_W (mGrabWindow) / 2.0f,
-					       WIN_REAL_Y (mGrabWindow) +
-					       WIN_REAL_H (mGrabWindow) / 2.0f);
-		    fww->calculateOutputOrigin (WIN_OUTPUT_X (mGrabWindow) +
-						WIN_OUTPUT_W (mGrabWindow) / 2.0f,
-						WIN_OUTPUT_Y (mGrabWindow) +
-						WIN_OUTPUT_H (mGrabWindow) / 2.0f);
-
-		    break;
-		default:
-		    break;
-	    }
-
-	    if (fww->canShape ())
-		if (fww->handleWindowInputInfo ())
-		    fww->adjustIPW ();
-
-	    screen->removeGrab (mGrabIndex, 0);
-	    mGrabIndex = 0;
-	    mGrabWindow = NULL;
-	    fww->mGrab = grabNone;
-	}
-    }
-
-    action->setState (action->state () & ~(CompAction::StateTermKey |
-					   CompAction::StateTermButton));
-
-    return false;
-}
-
-/*static void FWMoveWindowToCorrectPosition (CompWindow *w, float distX, float distY)
-{
-
-	FREEWINS_WINDOW (w);    action->setState (action->state () & ~(CompAction::StateTermKey |
-					   CompAction::StateTermButton));
-
-	fprintf(stderr, "distX is %f distY is %f midX and midY are %f %f\n", distX, distY, fww->mIMidX, fww->mIMidY);
-	
-	moveWindow (w, distX * (1 + (1 - fww->mTransform.scaleX)), distY * (1 + (1 - fww->mTransform.scaleY)), TRUE, FALSE);
-	
-	syncWindowPosition (w);
-}*/
-
-/* Initiate Scaling */
-bool
-FWScreen::initiateFWScale (CompAction         *action,
-			   CompAction::State  state,
-			   CompOption::Vector options)
-{
-    CompWindow* w;
-    CompWindow *useW;
-    Window xid;
-
-    xid = CompOption::getIntOptionNamed (options, "window", 0);
-    w = screen->findWindow (xid);
-    useW = screen->findWindow (xid);
-
-    if (w)
-    {
-	foreach (FWWindowInputInfo *info, mTransformedWindows)
-	{
-	    if (info->ipw)
-		if (w->id () == info->ipw)
-		/* The window we just grabbed was actually
-		 * an IPW, get the real window instead
-		 */
-		    useW = getRealWindow (w);
-	}
-
-	mRotateCursor = XCreateFontCursor (screen->dpy (), XC_fleur);
-
-	if (!screen->otherGrabExist ("freewins", 0))
-	    if (!mGrabIndex)
-		mGrabIndex = screen->pushGrab (mRotateCursor, "freewins");
-    }
-
-    if (useW)
-    {
-	if (optionGetShapeWindowTypes ().evaluate (useW))
-	{
-	    FREEWINS_WINDOW (useW);
-
-	    int x = CompOption::getIntOptionNamed (options, "x",
-					       useW->x () + (useW->width () / 2));
-	    int y = CompOption::getIntOptionNamed (options, "y",
-					       useW->y () + (useW->height () / 2));
-
-	    int mods = CompOption::getIntOptionNamed (options, "modifiers", 0);
-
-	    mGrabWindow = useW;
-
-	    /* Find out the corner we clicked in */
-
-	    float MidX = fww->mInputRect.centerX ();
-	    float MidY = fww->mInputRect.centerY ();
-
-	    /* Check for Y axis clicking (Top / Bottom) */
-	    if (pointerY > MidY)
-	    {
-		/* Check for X axis clicking (Left / Right) */
-		if (pointerX > MidX)
-		    fww->mCorner = CornerBottomRight;
-		else if (pointerX < MidX)
-		    fww->mCorner = CornerBottomLeft;
-	    }
-	    else if (pointerY < MidY)
-	    {
-		/* Check for X axis clicking (Left / Right) */
-		if (pointerX > MidX)
-		    fww->mCorner = CornerTopRight;
-		else if (pointerX < MidX)
-		    fww->mCorner = CornerTopLeft;
-	    }
-
-	    switch (optionGetScaleMode ())
-	    {
-		case ScaleModeToCentre:
-		    fww->calculateInputOrigin(WIN_REAL_X (useW) + WIN_REAL_W (useW) / 2.0f,
-					      WIN_REAL_Y (useW) + WIN_REAL_H (useW) / 2.0f);
-		    fww->calculateOutputOrigin(WIN_OUTPUT_X (useW) + WIN_OUTPUT_W (useW) / 2.0f,
-					       WIN_OUTPUT_Y (useW) + WIN_OUTPUT_H (useW) / 2.0f);
-		    break;
-		/*
-		 *Experimental scale to corners mode
-		 */
-		case ScaleModeToOppositeCorner:
-		    switch (fww->mCorner)
-		    {
-			case CornerBottomRight:
-			    /* Translate origin to the top left of the window */
-			    //FWMoveWindowToCorrectPosition (w, fww->inputRect.x1 - WIN_REAL_X (useW), fww->inputRect.y1 - WIN_REAL_Y (useW));
-			    fww->calculateInputOrigin (WIN_REAL_X (useW), WIN_REAL_Y (useW));
-			    break;
-
-			case CornerBottomLeft:
-			    /* Translate origin to the top right of the window */
-			    //FWMoveWindowToCorrectPosition (w, fww->inputRect.x2 - (WIN_REAL_X (useW) + WIN_REAL_W (useW)), fww->inputRect.y1 - WIN_REAL_Y (useW));
-			    fww->calculateInputOrigin (WIN_REAL_X (useW) + (WIN_REAL_W (useW)), WIN_REAL_Y (useW));
-			    break;
-
-			case CornerTopRight:
-			    /* Translate origin to the bottom left of the window */
-			    //FWMoveWindowToCorrectPosition (w, fww->inputRect.x1 - WIN_REAL_X (useW) , fww->inputRect.y1 - (WIN_REAL_Y (useW) + WIN_REAL_H (useW)));
-			    fww->calculateInputOrigin (WIN_REAL_X (useW), WIN_REAL_Y (useW) + (WIN_REAL_H (useW)));
-			    break;
-
-			case CornerTopLeft:
-			    /* Translate origin to the bottom right of the window */
-			    //FWMoveWindowToCorrectPosition (w, fww->inputRect.x1 -(WIN_REAL_X (useW) + WIN_REAL_W (useW)) , fww->inputRect.y1 - (WIN_REAL_Y (useW) + WIN_REAL_H (useW)));
-			    fww->calculateInputOrigin (WIN_REAL_X (useW) + (WIN_REAL_W (useW)), WIN_REAL_Y (useW) + (WIN_REAL_H (useW)));
-			    break;
-		    }
-		    break;
-	    }
-
-	    fww->mGrab = grabScale;
-
-	    /* Announce that we grabbed the window */
-	    useW->grabNotify (x, y, mods,  CompWindowGrabMoveMask |
-			      CompWindowGrabButtonMask);
-
-	    cScreen->damageScreen ();
-
-	    /* Shape the window beforehand and avoid a stale grab */
-	    if (fww->canShape ())
-		if (fww->handleWindowInputInfo ())
-		    fww->adjustIPW ();
-
-
-	    if (state & CompAction::StateInitButton)
-		action->setState (action->state () | CompAction::StateTermButton);
-	}
-    }
-
-    return TRUE;
-}
-
-bool
-FWScreen::terminateFWScale (CompAction         *action,
-			    CompAction::State  state,
-			    CompOption::Vector options)
-{
-    if (mGrabWindow && mGrabIndex)
-    {
-	FREEWINS_WINDOW (mGrabWindow);
-	if (fww->mGrab == grabScale)
-	{
-	    fww->window->ungrabNotify ();
-
-	    switch (optionGetScaleMode ())
-	    {
-		int distX, distY;
-
-		case ScaleModeToOppositeCorner:
-		    distX =  (fww->mOutputRect.x1 () + (fww->mOutputRect.width () / 2.0f) - (WIN_REAL_X (mGrabWindow) + WIN_REAL_W (mGrabWindow) / 2.0f));
-		    distY = (fww->mOutputRect.y1 () + (fww->mOutputRect.width () / 2.0f) - (WIN_REAL_Y (mGrabWindow) + WIN_REAL_H (mGrabWindow) / 2.0f));
-
-		    mGrabWindow->move (distX, distY, true);
-
-		    fww->calculateInputOrigin (WIN_REAL_X (mGrabWindow) +
-					       WIN_REAL_W (mGrabWindow) / 2.0f,
-					       WIN_REAL_Y (mGrabWindow) +
-					       WIN_REAL_H (mGrabWindow) / 2.0f);
-		    fww->calculateOutputOrigin (WIN_OUTPUT_X (mGrabWindow) +
-						WIN_OUTPUT_W (mGrabWindow) / 2.0f,
-						WIN_OUTPUT_Y (mGrabWindow) +
-						WIN_OUTPUT_H (mGrabWindow) / 2.0f);
-
-		    break;
-
-		default:
-		    break;
-
-	    }
-
-	    screen->removeGrab (mGrabIndex, 0);
-	    mGrabIndex = 0;
-	    mGrabWindow = NULL;
-	    fww->mGrab = grabNone;
-	}
-    }
-
-    action->setState (action->state () & ~(CompAction::StateTermKey |
-					   CompAction::StateTermButton));
-
-    return FALSE;
-}
-
-/* Repetitive Stuff */
-
-void
-FWWindow::setPrepareRotation (float dx,
-			      float dy,
-			      float dz,
-			      float dsu,
-			      float dsd)
-{    
-    if (FWScreen::get (screen)->optionGetShapeWindowTypes ().evaluate (window))
-    {
-	calculateInputOrigin (WIN_REAL_X (window) +
-			      WIN_REAL_W (window) / 2.0f,
-			      WIN_REAL_Y (window) +
-			      WIN_REAL_H (window) / 2.0f);
-	calculateOutputOrigin (WIN_OUTPUT_X (window) +
-			       WIN_OUTPUT_W (window) / 2.0f,
-			       WIN_OUTPUT_Y (window) +
-			       WIN_OUTPUT_H (window) / 2.0f);
-
-	mTransform.unsnapAngX += dy;
-	mTransform.unsnapAngY -= dx;
-	mTransform.unsnapAngZ += dz;
-
-	mTransform.unsnapScaleX += dsu;
-	mTransform.unsnapScaleY += dsd;
-
-	mAnimate.oldAngX = mTransform.angX;
-	mAnimate.oldAngY = mTransform.angY;
-	mAnimate.oldAngZ = mTransform.angZ;
-
-	mAnimate.oldScaleX = mTransform.scaleX;
-	mAnimate.oldScaleY = mTransform.scaleY;
-
-	mAnimate.destAngX = mTransform.angX + dy;
-	mAnimate.destAngY = mTransform.angY - dx;
-	mAnimate.destAngZ = mTransform.angZ + dz;
-
-	mAnimate.destScaleX = mTransform.scaleX + dsu;
-	mAnimate.destScaleY = mTransform.scaleY + dsd;
-
-    }
-}
-
-#define ROTATE_INC freewinsGetRotateIncrementAmount (w->screen)
-#define NEG_ROTATE_INC freewinsGetRotateIncrementAmount (w->screen) *-1
-
-#define SCALE_INC freewinsGetScaleIncrementAmount (w->screen)
-#define NEG_SCALE_INC freewinsGetScaleIncrementAmount (w->screen) *-1
-
-bool
-FWScreen::rotate (CompAction         *action,
-		  CompAction::State  state,
-		  CompOption::Vector options, int dx, int dy, int dz)
-{
-    CompWindow *w = screen->findWindow (CompOption::getIntOptionNamed (options,
-								       "window",
-								       0));
-    foreach (FWWindowInputInfo *info, mTransformedWindows)
-    {
-	if (info->ipw == w->id ())
-	{
-	    w = getRealWindow (w);
-	}
-    }
-
-    FREEWINS_WINDOW (w);
-
-    fww->setPrepareRotation (dx, dy, dz, 0, 0);
-
-    if (fww->canShape ())
-	if (fww->handleWindowInputInfo ())
-	    fww->adjustIPW ();
-
-    return true;
-}
-
-bool
-FWScreen::scale (CompAction          *action,
-		 CompAction::State   state,
-		 CompOption::Vector  options,
-		 int		     scale)
-{
-    CompWindow *w = screen->findWindow (CompOption::getIntOptionNamed (options,
-								       "window",
-								       0));
-    foreach (FWWindowInputInfo *info, mTransformedWindows)
-    {
-	if (info->ipw == w->id ())
-	{
-	    w = getRealWindow (w);
-	}
-    }
-
-    FREEWINS_WINDOW (w);
-
-    fww->setPrepareRotation (0, 0, 0, scale, scale);
-    fww->cWindow->addDamage ();
-
-    if (fww->canShape ())
-	if (fww->handleWindowInputInfo ())
-	    fww->adjustIPW ();
-
-    if (!optionGetAllowNegative ())
-    {
-	float minScale = optionGetMinScale ();
-
-	if (fww->mAnimate.destScaleX < minScale)
-	    fww->mAnimate.destScaleX = minScale;
-
-	if (fww->mAnimate.destScaleY < minScale)
-	    fww->mAnimate.destScaleY = minScale;
-    }
-
-    return true;
-}
-
-/* Reset the Rotation and Scale to 0 and 1 */
-bool
-FWScreen::resetFWTransform (CompAction         *action,
-			    CompAction::State  state,
-			    CompOption::Vector options)
-{
-    CompWindow *w = screen->findWindow (CompOption::getIntOptionNamed (options,
-								       "window",
-								       0));
-    foreach (FWWindowInputInfo *info, mTransformedWindows)
-    {
-	if (info->ipw == w->id ())
-	{
-	    w = getRealWindow (w);
-	}
-    }
-
-    if (w)
-    {
-	FREEWINS_WINDOW (w);
-	fww->setPrepareRotation (fww->mTransform.angY,
-				 -fww->mTransform.angX,
-				 -fww->mTransform.angZ,
-				 (1 - fww->mTransform.scaleX),
-				 (1 - fww->mTransform.scaleY));
-	fww->cWindow->addDamage ();
-
-	fww->mTransformed = FALSE;
-
-	if (fww->canShape ())
-	    if (fww->handleWindowInputInfo ())
-		fww->adjustIPW ();
-
-	fww->mResetting = TRUE;
-    }
-
-    return TRUE;
-}
-
-/* Callable action to rotate a window to the angle provided
- * x: Set angle to x degrees
- * y: Set angle to y degrees
- * z: Set angle to z degrees
- * window: The window to apply the transformation to
- */
-bool
-FWScreen::rotateAction (CompAction         *action,
-			CompAction::State  state,
-			CompOption::Vector options)
-{
-    CompWindow *w;
-
-    w = screen->findWindow (CompOption::getIntOptionNamed (options, "window", 0));
-
-    if (w)
-    {
-	FREEWINS_WINDOW (w);
-
-	float x = CompOption::getFloatOptionNamed(options, "x", 0.0f);
-	float y = CompOption::getFloatOptionNamed(options, "y", 0.0f);
-	float z = CompOption::getFloatOptionNamed(options, "z", 0.0f);
-
-	fww->setPrepareRotation (x - fww->mAnimate.destAngX,
-				 y - fww->mAnimate.destAngY,
-				 z - fww->mAnimate.destAngZ, 0, 0);
-	fww->cWindow->addDamage ();
-
-    }
-    else
-    {
-	return false;
-    }
-
-    return true;
-}
-
-/* Callable action to increment window rotation by the angles provided
- * x: Increment angle by x degrees
- * y: Increment angle by y degrees
- * z: Increment angle by z degrees
- * window: The window to apply the transformation to
- */
-bool
-FWScreen::incrementRotateAction (CompAction         *action,
-				 CompAction::State  state,
-				 CompOption::Vector options)
-{
-    CompWindow *w;
-
-    w = screen->findWindow (CompOption::getIntOptionNamed (options, "window", 0));
-
-    if (w)
-    {
-	FREEWINS_WINDOW (w);
-
-	float x = CompOption::getFloatOptionNamed(options, "x", 0.0f);
-	float y = CompOption::getFloatOptionNamed(options, "y", 0.0f);
-	float z = CompOption::getFloatOptionNamed(options, "z", 0.0f);
-
-	fww->setPrepareRotation (x,
-				 y,
-				 z, 0, 0);
-	fww->cWindow->addDamage ();
-
-    }
-    else
-    {
-	return false;
-    }
-
-    return true;
-}
-
-/* Callable action to scale a window to the scale provided
- * x: Set scale to x factor
- * y: Set scale to y factor
- * window: The window to apply the transformation to
- */
-bool
-FWScreen::scaleAction (CompAction         *action,
-		       CompAction::State  state,
-		       CompOption::Vector options)
-{
-    CompWindow *w;
-
-    w = screen->findWindow (CompOption::getIntOptionNamed (options, "window", 0));
-
-    if (w)
-    {
-	FREEWINS_WINDOW (w);
-
-	float x = CompOption::getFloatOptionNamed (options, "x", 0.0f);
-	float y = CompOption::getFloatOptionNamed (options, "y", 0.0f);
-
-	fww->setPrepareRotation (0, 0, 0,
-				 x - fww->mAnimate.destScaleX,
-				 y - fww->mAnimate.destScaleY);
-	if (fww->canShape ())
-	    if (fww->handleWindowInputInfo ())
-		fww->adjustIPW ();
-
-	/* Stop scale at threshold specified */
-	if (!optionGetAllowNegative ())
-	{
-	    float minScale = optionGetMinScale ();
-	    if (fww->mAnimate.destScaleX < minScale)
-		fww->mAnimate.destScaleX = minScale;
-
-	    if (fww->mAnimate.destScaleY < minScale)
-		fww->mAnimate.destScaleY = minScale;
-	}
-
-	fww->cWindow->addDamage ();
-
-	if (fww->canShape ())
-	    fww->handleWindowInputInfo ();
-
-    }
-    else
-    {
-	return false;
-    }
-
-    return true;
-}
-
-/* Toggle Axis-Help Display */
-bool
-FWScreen::toggleFWAxis (CompAction         *action,
-			CompAction::State  state,
-			CompOption::Vector options)
-{
-    mAxisHelp = !mAxisHelp;
-
-    cScreen->damageScreen ();
-
-    return TRUE;
-}

=== removed file 'plugins/freewins/src/events.cpp'
--- plugins/freewins/src/events.cpp	2013-03-26 22:02:39 +0000
+++ plugins/freewins/src/events.cpp	1970-01-01 00:00:00 +0000
@@ -1,853 +0,0 @@
-/**
- * Compiz Fusion Freewins plugin
- *
- * events.cpp
- *
- * Copyright (C) 2007  Rodolfo Granata <[e-mail]>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * Author(s):
- * Rodolfo Granata <[e-mail]>
- * Sam Spilsbury <[e-mail]>
- *
- * Button binding support and Reset added by:
- * enigma_0Z <[e-mail]>
- *
- * Most of the input handling here is based on
- * the shelf plugin by
- *        : Kristian Lyngstøl <[e-mail]>
- *        : Danny Baumann <[e-mail]>
- *
- * Description:
- *
- * This plugin allows you to freely transform the texture of a window,
- * whether that be rotation or scaling to make better use of screen space
- * or just as a toy.
- *
- * Todo:
- *  - Fully implement an input redirection system by
- *    finding an inverse matrix, multiplying by it,
- *    translating to the actual window co-ords and
- *    XSendEvent() the co-ords to the actual window.
- * -  X Input Redirection
- *  - Code could be cleaner
- *  - Add timestep and speed options to animation
- *  - Add window hover-over info via paintOutput : i.e
- *    - Resize borders
- *    - 'Reset' Button
- *    - 'Scale' Button
- *    - 'Rotate' Button
- */
-
-#include "freewins.h"
-
-
-/* ------ Event Handlers ------------------------------------------------*/
-
-void
-FWWindow::handleIPWResizeInitiate ()
-{
-    FREEWINS_SCREEN (screen);
-
-    window->activate ();
-    mGrab = grabResize;
-    fws->mRotateCursor = XCreateFontCursor (screen->dpy (), XC_plus);
-    if(!screen->otherGrabExist ("freewins", "resize", 0))
-	if(!fws->mGrabIndex)
-	{
-	    unsigned int mods = 0;
-	    mods &= CompNoMask;
-	    fws->mGrabIndex = screen->pushGrab (fws->mRotateCursor, "resize");
-	    window->grabNotify (window->x () + (window->width () / 2),
-				window->y () + (window->height () / 2), mods,
-				CompWindowGrabMoveMask | CompWindowGrabButtonMask);
-	    fws->mGrabWindow = window;
-	}
-}
-
-void
-FWWindow::handleIPWMoveInitiate ()
-{
-    FREEWINS_SCREEN (screen);
-
-    window->activate ();
-    mGrab = grabMove;
-    fws->mRotateCursor = XCreateFontCursor (screen->dpy (), XC_fleur);
-    if(!screen->otherGrabExist ("freewins", "resize", 0))
-	if(!fws->mGrabIndex)
-	{
-	    unsigned int mods = 0;
-	    mods &= CompNoMask;
-	    fws->mGrabIndex = screen->pushGrab (fws->mRotateCursor, "resize");
-	    window->grabNotify (window->x () + (window->width () / 2),
-				window->y () + (window->height () / 2), mods,
-				CompWindowGrabResizeMask | CompWindowGrabButtonMask);
-	    fws->mGrabWindow = window;
-	}
-}
-
-void
-FWWindow::handleIPWMoveMotionEvent (unsigned int x,
-				    unsigned int y)
-{
-    FREEWINS_SCREEN (screen);
-
-    int dx = x - lastPointerX;
-    int dy = y - lastPointerY;
-
-    if (!fws->mGrabIndex)
-	return;
-
-    window->move (dx, dy, fws->optionGetImmediateMoves ());
-
-}
-
-void
-FWWindow::handleIPWResizeMotionEvent (unsigned int x,
-				      unsigned int y)
-{
-    int dx = (x - lastPointerX) * 10;
-    int dy = (y - lastPointerY) * 10;
-
-    mWinH += dy;
-    mWinW += dx;
-
-    /* In order to prevent a window redraw on resize
-     * on every motion event we have a threshold
-     */
-
-    /* FIXME: cf-love: Instead of actually resizing the window, scale it up, then resize it */
-
-    if (mWinH - 10 > window->height () || mWinW - 10 > window->width ())
-    {
-	XWindowChanges xwc;
-	unsigned int   mask = CWX | CWY | CWWidth | CWHeight;
-
-	xwc.x = window->serverX ();
-	xwc.y = window->serverY ();
-	xwc.width = mWinW;
-	xwc.height = mWinH;
-
-	if (xwc.width == window->serverWidth ())
-	    mask &= ~CWWidth;
-
-	if (xwc.height == window->serverHeight ())
-	    mask &= ~CWHeight;
-
-	if (window->mapNum () && (mask & (CWWidth | CWHeight)))
-	    window->sendSyncRequest ();
-
-	window->configureXWindow (mask, &xwc);
-    }
-}
-
-/* Handle Rotation */
-void
-FWWindow::handleRotateMotionEvent (float dx,
-				   float dy,
-				   int x,
-				   int y)
-{
-    FREEWINS_SCREEN (screen);
-
-    x -= 100;
-    y -= 100;
-
-    int oldX = lastPointerX - 100;
-    int oldY = lastPointerY - 100;
-
-    float midX = WIN_REAL_X (window) + WIN_REAL_W (window)/2.0;
-    float midY = WIN_REAL_Y (window) + WIN_REAL_H (window)/2.0;
-
-    float angX;
-    float angY;
-    float angZ;
-
-    /* Save the current angles so we can work with them */
-    if (fws->optionGetSnap () || fws->mSnap)
-    {
-	angX = mTransform.unsnapAngX;
-	angY = mTransform.unsnapAngY;
-	angZ = mTransform.unsnapAngZ;
-    }
-    else
-    {
-	angX = mAnimate.destAngX;
-	angY = mAnimate.destAngY;
-	angZ = mAnimate.destAngZ;
-    }
-
-    /* Check for Y axis clicking (Top / Bottom) */
-    if (pointerY > midY)
-    {
-	/* Check for X axis clicking (Left / Right) */
-	if (pointerX > midX)
-	    mCorner = CornerBottomRight;
-	else if (pointerX < midX)
-	    mCorner = CornerBottomLeft;
-    }
-    else if (pointerY < midY)
-    {
-	/* Check for X axis clicking (Left / Right) */
-	if (pointerX > midX)
-	    mCorner = CornerTopRight;
-	else if (pointerX < midX)
-	    mCorner = CornerTopLeft;
-    }
-
-    float percentFromXAxis = 0.0, percentFromYAxis = 0.0;
-
-    if (fws->optionGetZAxisRotation () == FreewinsOptions::ZAxisRotationInterchangeable)
-    {
-
-	/* Trackball rotation was too hard to implement. If anyone can implement it,
-	 * please come forward so I can replace this hacky solution to the problem.
-	 * Anyways, what happens here, is that we determine how far away we are from
-	 * each axis (y and x). The further we are away from the y axis, the more
-	 * up / down movements become Z axis movements and the further we are away from
-	 * the x-axis, the more left / right movements become z rotations. */
-
-	/* We determine this by taking a percentage of how far away the cursor is from
-	 * each axis. We divide the 3D rotation by this percentage ( and divide by the
-	 * percentage squared in order to ensure that rotation is not too violent when we
-	 * are quite close to the origin. We multiply the 2D rotation by this percentage also
-	 * so we are essentially rotating in 3D and 2D all the time, but this is only really
-	 * noticeable when you move the cursor over to the extremes of a window. In every case
-	 * percentage can be defined as decimal-percentage (i.e 0.036 == 3.6%). Like I mentioned
-	 * earlier, if you can replace this with trackball rotation, please come forward! */
-
-	float halfWidth = WIN_REAL_W (window) / 2.0f;
-	float halfHeight = WIN_REAL_H (window) / 2.0f;
-
-	float distFromXAxis = fabs (mIMidX - pointerX);
-	float distFromYAxis = fabs (mIMidY - pointerY);
-
-	percentFromXAxis = distFromXAxis / halfWidth;
-	percentFromYAxis = distFromYAxis / halfHeight;
-
-    }
-    else if (fws->optionGetZAxisRotation () == FreewinsOptions::ZAxisRotationSwitch)
-	determineZAxisClick (pointerX, pointerY, TRUE);
-
-    dx *= 360;
-    dy *= 360;
-
-    /* Handle inversion */
-
-    bool can2D = mCan2D, can3D = mCan3D;
-
-    if (fws->mInvert && fws->optionGetZAxisRotation () != FreewinsOptions::ZAxisRotationInterchangeable)
-    {
-	can2D = !mCan2D;
-	can3D = !mCan3D;
-    }
-
-    if(can2D)
-    {
-
-	float zX = 1.0f;
-	float zY = 1.0f;
-
-	if (fws->optionGetZAxisRotation () == FreewinsOptions::ZAxisRotationInterchangeable)
-	{
-	    zX = percentFromXAxis;
-	    zY = percentFromYAxis;
-	}
-
-	zX = zX > 1.0f ? 1.0f : zX;
-	zY = zY > 1.0f ? 1.0f : zY;
-
-	switch (mCorner)
-	{
-	    case CornerTopRight:
-
-		if (x < oldX)
-		    angZ -= dx * zX;
-		else if (x > oldX)
-		    angZ += dx * zX;
-
-		if (y < oldY)
-		    angZ -= dy * zY;
-		else if (y > oldY)
-		    angZ += dy * zY;
-
-		break;
-
-	    case CornerTopLeft:
-
-		if (x < oldX)
-		    angZ -= dx * zX;
-		else if (x > oldX)
-		    angZ += dx * zX;
-
-		if (y < oldY)
-		    angZ += dy * zY;
-		else if (y > oldY)
-		    angZ -= dy * zY;
-
-		break;
-
-	    case CornerBottomLeft:
-
-		if (x < oldX)
-		    angZ += dx * zX;
-		else if (x > oldX)
-		    angZ -= dx * zX;
-
-		if (y < oldY)
-		    angZ += dy * zY;
-		else if (y > oldY)
-		    angZ -= dy * zY;
-
-		break;
-
-	    case CornerBottomRight:
-
-		if (x < oldX)
-		    angZ += dx * zX;
-		else if (x > oldX)
-		    angZ -= dx * zX;
-
-		if (y < oldY)
-		    angZ -= dy * zY;
-		else if (y > oldY)
-		    angZ += dy * zY;
-
-		break;
-	}
-    }
-
-    if (can3D)
-    {
-	if (fws->optionGetZAxisRotation () != FreewinsOptions::ZAxisRotationInterchangeable)
-	{
-	    percentFromXAxis = 0.0f;
-	    percentFromYAxis = 0.0f;
-	}
-
-	angX -= dy * (1 - percentFromXAxis);
-	angY += dx * (1 - percentFromYAxis);
-    }
-
-    /* Restore angles */
-
-    if (fws->optionGetSnap () || fws->mSnap)
-    {
-	mTransform.unsnapAngX = angX;
-	mTransform.unsnapAngY = angY;
-	mTransform.unsnapAngZ = angZ;
-    }
-    else
-    {
-	mAnimate.destAngX = angX;
-	mAnimate.destAngY = angY;
-	mAnimate.destAngZ = angZ;
-    }
-
-    handleSnap ();
-}
-
-/* Handle Scaling */
-void
-FWWindow::handleScaleMotionEvent (float dx,
-				  float dy,
-				  int x,
-				  int y)
-{
-    FREEWINS_SCREEN (screen);
-
-    x -= 100.0;
-    y -= 100.0;
-    
-    int oldX = lastPointerX - 100;
-    int oldY = lastPointerY - 100;
-    
-    float scaleX, scaleY;
-    
-    if (fws->optionGetSnap () || fws->mSnap)
-    {
-	scaleX = mTransform.unsnapScaleX;
-	scaleY = mTransform.unsnapScaleY;
-    }
-    else
-    {
-	scaleX = mAnimate.destScaleX;
-	scaleY = mAnimate.destScaleY;
-    }
-
-    calculateInputRect ();
-
-    switch (mCorner)
-    {
-	case CornerTopLeft:
-
-	    // Check X Direction
-	    if (x < oldX)
-		scaleX -= dx;
-	    else if (x > oldX)
-		scaleX -= dx;
-
-	    // Check Y Direction
-	    if (y < oldY)
-		scaleY -= dy;
-	    else if (y > oldY)
-		scaleY -= dy;
-
-	    break;
-
-	case CornerTopRight:
-
-	    // Check X Direction
-	    if (x < oldX)
-		scaleX += dx;
-	    else if (x > oldX)
-		scaleX += dx;
-
-	    // Check Y Direction
-	    if (y < oldY)
-		scaleY -= dy;
-	    else if (y > oldY)
-		scaleY -= dy;
-
-	    break;
-
-	case CornerBottomLeft:
-
-	    // Check X Direction
-	    if (x < oldX)
-		scaleX -= dx;
-	    else if (y > oldX)
-		scaleX -= dx;
-
-	    // Check Y Direction
-	    if (y < oldY)
-		scaleY += dy;
-	    else if (y > oldY)
-		scaleY += dy;
-
-	    break;
-
-	case CornerBottomRight:
-
-	    // Check X Direction
-	    if (x < oldX)
-		scaleX += dx;
-	    else if (x > oldX)
-		scaleX += dx;
-
-	    // Check Y Direction
-	    if (y < oldY)
-		scaleY += dy;
-	    else if (y > oldY)
-		scaleY += dy;
-
-	    break;
-    }
-    
-    if (fws->optionGetSnap () || fws->mSnap)
-    {
-	mTransform.unsnapScaleX = scaleX;
-	mTransform.unsnapScaleY = scaleY;
-    }
-    else
-    {
-	mAnimate.destScaleX = scaleX;
-	mAnimate.destScaleY = scaleY;
-    }
-
-    /* Stop scale at threshold specified */
-    if (!fws->optionGetAllowNegative ())
-    {
-	float minScale = fws->optionGetMinScale ();
-	if (mAnimate.destScaleX < minScale)
-	    mAnimate.destScaleX = minScale;
-
-	if (mAnimate.destScaleY < minScale)
-	    mAnimate.destScaleY = minScale;
-    }
-
-    /* Change scales for maintaining aspect ratio */
-    if (fws->optionGetScaleUniform ())
-    {
-	float tempscaleX = mAnimate.destScaleX;
-	float tempscaleY = mAnimate.destScaleY;
-	mAnimate.destScaleX = (tempscaleX + tempscaleY) / 2;
-	mAnimate.destScaleY = (tempscaleX + tempscaleY) / 2;
-	mTransform.unsnapScaleX = (tempscaleX + tempscaleY) / 2;
-	mTransform.unsnapScaleY = (tempscaleX + tempscaleY) / 2;
-    }
-
-    handleSnap ();
-}
-
-void
-FWWindow::handleButtonReleaseEvent ()
-{
-    FREEWINS_SCREEN (screen);
-
-    if (mGrab == grabMove || mGrab == grabResize)
-    {
-	screen->removeGrab (fws->mGrabIndex, NULL);
-	window->ungrabNotify ();
-	window->moveInputFocusTo ();
-	adjustIPW ();
-	fws->mGrabIndex = 0;
-	fws->mGrabWindow = NULL;
-	mGrab = grabNone;
-    }
-}
-
-void
-FWWindow::handleEnterNotify (XEvent *xev)
-{
-    XEvent EnterNotifyEvent;
-
-    memcpy (&EnterNotifyEvent.xcrossing, &xev->xcrossing,
-	    sizeof (XCrossingEvent));
-/*
-    if (window)
-    {
-	EnterNotifyEvent.xcrossing.window = window->id ();
-	XSendEvent (screen->dpy (), window->id (),
-		    FALSE, EnterWindowMask, &EnterNotifyEvent);
-    }
-*/
-}
-
-void
-FWWindow::handleLeaveNotify (XEvent *xev)
-{
-    XEvent LeaveNotifyEvent;
-
-    memcpy (&LeaveNotifyEvent.xcrossing, &xev->xcrossing,
-	    sizeof (XCrossingEvent));
-    LeaveNotifyEvent.xcrossing.window = window->id ();
-
-    //XSendEvent (screen->dpy (), window->id (), FALSE,
-    //            LeaveWindowMask, &LeaveNotifyEvent);
-}
-
-/* X Event Handler */
-void
-FWScreen::handleEvent (XEvent *ev)
-{
-    float dx, dy;
-    CompWindow *oldPrev, *oldNext, *w;
-
-    /* Check our modifiers first */
-
-    if (ev->type == screen->xkbEvent ())
-    {
-	XkbAnyEvent *xkbEvent = (XkbAnyEvent *) ev;
-
-	if (xkbEvent->xkb_type == XkbStateNotify)
-	{
-	    XkbStateNotifyEvent *stateEvent = (XkbStateNotifyEvent *) ev;
-	    unsigned int snapMods = 0xffffffff;
-	    unsigned int invertMods = 0xffffffff;
-
-	    if (mSnapMask)
-		snapMods = mSnapMask;
-
-	    if ((stateEvent->mods & snapMods) == snapMods)
-		mSnap = TRUE;
-	    else
-		mSnap = FALSE;
-
-	    if (mInvertMask)
-		invertMods = mInvertMask;
-
-	    if ((stateEvent->mods & invertMods) == invertMods)
-		mInvert = TRUE;
-	    else
-		mInvert = FALSE;
-
-	}
-    }
-
-    switch(ev->type)
-    {
-	case EnterNotify:
-	{
-	    CompWindow *btnW;
-	    btnW = screen->findWindow (ev->xbutton.subwindow);
-
-	    /* It wasn't the subwindow, try the window */
-	    if (!btnW)
-		btnW = screen->findWindow (ev->xbutton.window);
-
-	    /* We have established the CompWindow we clicked
-	     * on. Get the real window */
-	    if (btnW)
-	    {
-		FREEWINS_WINDOW (btnW);
-		if (fww->canShape () && !mGrabWindow && !screen->otherGrabExist (0))
-		    mHoverWindow = btnW;
-		btnW = getRealWindow (btnW);
-	    }
-	    
-	    if (btnW)
-	    {
-		FREEWINS_WINDOW (btnW);
-		if (fww->canShape () && !mGrabWindow && !screen->otherGrabExist (0))
-		    mHoverWindow = btnW;
-		fww->handleEnterNotify (ev);
-	    }
-	}
-	    break;
-
-	case LeaveNotify:
-	{
-	    CompWindow *btnW;
-	    btnW = screen->findWindow (ev->xbutton.subwindow);
-
-	    /* It wasn't the subwindow, try the window */
-	    if (!btnW)
-		btnW = screen->findWindow (ev->xbutton.window);
-
-	    /* We have established the CompWindow we clicked
-	     * on. Get the real window */
-	    if (btnW)
-		btnW = getRealWindow (btnW);
-
-	    if (btnW)
-		FWWindow::get (btnW)->handleLeaveNotify (ev);
-	}
-	    break;
-
-	case MotionNotify:
-	{
-	    if (mGrabWindow)
-	    {
-		FREEWINS_WINDOW (mGrabWindow);
-
-		dx = ((float)(pointerX - lastPointerX) / screen->width ()) * \
-		     optionGetMouseSensitivity ();
-		dy = ((float)(pointerY - lastPointerY) / screen->height ()) * \
-		     optionGetMouseSensitivity ();
-
-		if (optionGetShapeWindowTypes ().evaluate (mGrabWindow))
-		{
-		    if (fww->mGrab == grabMove || fww->mGrab == grabResize)
-		    {
-			FWWindowInputInfo *info;
-//			CompWindow *w = mGrabWindow;
-			foreach (info, mTransformedWindows)
-			{
-			    if (mGrabWindow->id () == info->ipw)
-				/* The window we just grabbed was actually
-				 * an IPW, get the real window instead
-				 */
-				w = getRealWindow (mGrabWindow);
-			}
-		    }
-		    switch (fww->mGrab)
-		    {
-			case grabMove:
-			    fww->handleIPWMoveMotionEvent (pointerX, pointerY); break;
-			case grabResize:
-			    fww->handleIPWResizeMotionEvent (pointerX, pointerY); break;
-			default:
-			    break;
-		    }
-		}
-
-		if (fww->mGrab == grabRotate)
-		{
-		    fww->handleRotateMotionEvent(dx, dy, ev->xmotion.x, ev->xmotion.y);
-		}
-
-		if (fww->mGrab == grabScale)
-		{
-		    fww->handleScaleMotionEvent(dx * 3, dy * 3, ev->xmotion.x, ev->xmotion.y);
-		}
-
-		//if(dx != 0.0 || dy != 0.0)
-		//    fww->damageArea ();
-	    }
-	}
-	    break;
-
-	/* Button Press and Release */
-	case ButtonPress:
-	{
-	    CompWindow *btnW;
-	    btnW = screen->findWindow (ev->xbutton.subwindow);
-
-	    /* It wasn't the subwindow, try the window */
-	    if (!btnW)
-		btnW = screen->findWindow (ev->xbutton.window);
-
-	    /* We have established the CompWindow we clicked
-	     * on. Get the real window
-	     * FIXME: Free btnW and use another CompWindow * such as realW
-	     */
-	    if (btnW)
-		btnW = getRealWindow (btnW);
-
-	    if (btnW)
-	    {
-		FREEWINS_WINDOW (btnW);
-
-		if (optionGetShapeWindowTypes ().evaluate (btnW))
-		    switch (ev->xbutton.button)
-		    {
-			case Button1:
-			    fww->handleIPWMoveInitiate ();
-			    break;
-
-			case Button3:
-			    fww->handleIPWResizeInitiate ();
-			    break;
-
-			default:
-			    break;
-		    }
-	    }
-
-	    mClick_root_x = ev->xbutton.x_root;
-	    mClick_root_y = ev->xbutton.y_root;
-	}
-	    break;
-
-	case ButtonRelease:
-	{
-	    if (mGrabWindow)
-	    {
-		FREEWINS_WINDOW (mGrabWindow);
-
-		if (optionGetShapeWindowTypes ().evaluate (mGrabWindow))
-		    if (fww->mGrab == grabMove || fww->mGrab == grabResize)
-		    {
-			fww->handleButtonReleaseEvent ();
-			mGrabWindow = 0;
-		    }
-	    }
-	}
-	    break;
-
-	case ConfigureNotify:
-	{
-	    w = screen->findWindow (ev->xconfigure.window);
-	    if (w)
-	    {
-		oldPrev = w->prev;
-		oldNext = w->next;
-
-		FREEWINS_WINDOW (w);
-
-		fww->mWinH = WIN_REAL_H (w);
-		fww->mWinW = WIN_REAL_W (w);
-	    }
-	}
-	    break;
-
-#if 0
-	case ClientMessage:
-	{
-	    if (ev->xclient.message_type == Atoms::desktopViewport)
-	    {
-		/* Viewport change occurred, or something like that - adjust the IPW's */
-		CompWindow *adjW, *actualW;
-
-		foreach (adjW, screen->windows ())
-		{
-		    int vX = 0, vY = 0, dX, dY;
-
-		    actualW = getRealWindow (adjW);
-
-		    if (!actualW)
-			actualW = adjW;
-
-		    if (actualW)
-		    {
-			CompWindow *ipw;
-
-			FREEWINS_WINDOW (actualW);
-
-			if (!fww->mInput || fww->mInput->ipw)
-			    break;
-
-			ipw = screen->findWindow (fww->mInput->ipw);
-
-			if (ipw)
-			{
-			    dX = screen->vp ().x () - vX;
-			    dY = screen->vp ().y () - vY;
-
-			    CompPoint p = actualW->defaultViewport ();
-
-			    vX = p.x ();
-			    vY = p.y ();
-
-			    ipw->moveToViewportPosition (ipw->x () - dX * screen->width (),
-							 ipw->y () - dY * screen->height (),
-							 true); // ???
-			}
-		    }
-		}
-	    }
-	}
-	    break;
-#endif
-	default:
-	    break;
-#if 0
-	    if (ev->type == screen->shapeEvent () + ShapeNotify)
-	    {
-		XShapeEvent *se = (XShapeEvent *) ev;
-		if (se->kind == ShapeInput)
-		{
-		    CompWindow *w;
-		    w = screen->findWindow (se->window);
-		    if (w)
-		    {
-			FREEWINS_WINDOW (w);
-
-			if (fww->canShape () && (fww->mTransform.scaleX != 1.0f || fww->mTransform.scaleY != 1.0f))
-			{
-			    // Reset the window back to normal
-			    fww->mTransform.scaleX = 1.0f;
-			    fww->mTransform.scaleY = 1.0f;
-			    fww->mTransform.angX = 0.0f;
-			    fww->mTransform.angY = 0.0f;
-			    fww->mTransform.angZ = 0.0f;
-			    /*FWShapeInput (w); - Disabled due to problems it causes*/
-			}
-		    }
-		}
-	    }
-#endif
-    }
-    
-    screen->handleEvent (ev);
-
-    /* Now we can find out if a restacking occurred while we were handing events */
-    switch (ev->type)
-    {
-	case ConfigureNotify:
-	{
-	    w = screen->findWindow (ev->xconfigure.window);
-	    if (w)
-	    {
-		oldPrev = w->prev;
-		oldNext = w->next;
-		if (w->prev != oldPrev || w->next != oldNext)
-		{
-		    /* restacking occured, ensure ipw stacking */
-		    adjustIPWStacking ();
-		}
-	    }
-	}
-	    break;
-    }
-}

=== removed file 'plugins/freewins/src/freewins.cpp'
--- plugins/freewins/src/freewins.cpp	2013-02-19 16:21:42 +0000
+++ plugins/freewins/src/freewins.cpp	1970-01-01 00:00:00 +0000
@@ -1,271 +0,0 @@
-/**
- * Compiz Fusion Freewins plugin
- *
- * freewins.cpp
- *
- * Copyright (C) 2007  Rodolfo Granata <[e-mail]>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * Author(s):
- * Rodolfo Granata <[e-mail]>
- * Sam Spilsbury <[e-mail]>
- *
- * Button binding support and Reset added by:
- * enigma_0Z <[e-mail]>
- *
- * Most of the input handling here is based on
- * the shelf plugin by
- *        : Kristian Lyngstøl <[e-mail]>
- *        : Danny Baumann <[e-mail]>
- *
- * Description:
- *
- * This plugin allows you to freely transform the texture of a window,
- * whether that be rotation or scaling to make better use of screen space
- * or just as a toy.
- *
- * Todo:
- *  - Modifier key to rotate on the Z Axis
- *  - Fully implement an input redirection system by
- *    finding an inverse matrix, multiplying by it,
- *    translating to the actual window co-ords and
- *    XSendEvent() the co-ords to the actual window.
- *  - Code could be cleaner
- *  - Add timestep and speed options to animation
- *  - Add window hover-over info via paintOutput : i.e
- *    - Resize borders
- *    - 'Reset' Button
- *    - 'Scale' Button
- *    - 'Rotate' Button
- */
-
-#include "freewins.h"
-
-COMPIZ_PLUGIN_20090315 (freewins, FWPluginVTable);
-
-/* Information on window resize */
-void
-FWWindow::resizeNotify (int dx,
-			int dy,
-			int dw,
-			int dh)
-{
-    calculateInputRect ();
-
-    int x = WIN_REAL_X(window) + WIN_REAL_W(window)/2.0;
-    int y = WIN_REAL_Y(window) + WIN_REAL_H(window)/2.0;
-
-    mRadius = sqrt(pow((x - WIN_REAL_X (window)), 2) + pow((y - WIN_REAL_Y (window)), 2));
-
-    window->resizeNotify (dx, dy, dw, dh);
-}
-
-void
-FWWindow::moveNotify (int dx,
-		      int dy,
-		      bool immediate)
-{
-    FREEWINS_SCREEN (screen);
-
-    /* Did we move and IPW and not the actual window? */
-    CompWindow *useWindow = fws->getRealWindow (window);
-
-    if (useWindow)
-	useWindow->move (dx, dy, fws->optionGetImmediateMoves ());
-    else if (window != fws->mGrabWindow)
-	adjustIPW ();
-
-    if (!useWindow)
-	useWindow = window;
-
-    int x = WIN_REAL_X (useWindow) + WIN_REAL_W (useWindow) /2.0;
-    int y = WIN_REAL_Y (useWindow) + WIN_REAL_H (useWindow) /2.0;
-
-
-    mRadius = sqrt (pow((x - WIN_REAL_X (useWindow)), 2) + pow ((y - WIN_REAL_Y (useWindow)), 2));
-
-    useWindow->moveNotify (dx, dy, immediate);
-}
-
-void
-FWScreen::reloadSnapKeys ()
-{
-    unsigned int imask = optionGetInvertModsMask ();
-    mInvertMask = 0;
-
-    if (imask & InvertModsShiftMask)
-	mInvertMask |= ShiftMask;
-    if (imask & InvertModsAltMask)
-	mInvertMask |= CompAltMask;
-    if (imask & InvertModsControlMask)
-	mInvertMask |= ControlMask;
-    if (imask & InvertModsMetaMask)
-	mInvertMask |= CompMetaMask;
-
-    unsigned int smask = optionGetSnapModsMask ();
-    mSnapMask = 0;
-    if (smask & SnapModsShiftMask)
-	mSnapMask |= ShiftMask;
-    if (smask & SnapModsAltMask)
-	mSnapMask |= CompAltMask;
-    if (smask & SnapModsControlMask)
-	mSnapMask |= ControlMask;
-    if (smask & SnapModsMetaMask)
-	mSnapMask |= CompMetaMask;
-}
-
-void
-FWScreen::optionChanged (CompOption *option,
-			 FreewinsOptions::Options num)
-{
-    switch (num)
-    {
-	case FreewinsOptions::SnapMods:
-	case FreewinsOptions::InvertMods:
-	    reloadSnapKeys ();
-	    break;
-	default:
-	    break;
-    }
-}
-
-/* ------ Plugin Initialisation ---------------------------------------*/
-
-/* Window initialisation / cleaning */
-
-FWWindow::FWWindow (CompWindow *w) :
-    PluginClassHandler <FWWindow, CompWindow> (w),
-    window (w),
-    cWindow (CompositeWindow::get (w)),
-    gWindow (GLWindow::get (w)),
-    mIMidX (WIN_REAL_W (w) / 2.0),
-    mIMidY (WIN_REAL_H (w) / 2.0),
-    mOMidX (0.0f),
-    mOMidY (0.0f),
-    mAdjustX (0.0f),
-    mAdjustY (0.0f),
-    mOldWinX (0),
-    mOldWinY (0),
-    mWinH (0),
-    mWinW (0),
-    mDirection (UpDown),
-    mCorner (CornerTopLeft),
-    mInput (NULL),
-    mOutputRect (w->outputRect ()),
-    mInputRect (w->borderRect ()),
-    mResetting (false),
-    mIsAnimating (false),
-    mCan2D (false),
-    mCan3D (false),
-    mTransformed (false),
-    mGrab (grabNone)
-{
-    WindowInterface::setHandler (window);
-    CompositeWindowInterface::setHandler (cWindow);
-    GLWindowInterface::setHandler (gWindow);
-
-    int x = WIN_REAL_X (w) + WIN_REAL_W (w) /2.0;
-    int y = WIN_REAL_Y (w) + WIN_REAL_H (w) /2.0;
-
-    mRadius = sqrt (pow ((x - WIN_REAL_X (w)), 2) + pow ((y - WIN_REAL_Y (w)), 2));
-}
-
-FWWindow::~FWWindow ()
-{
-    if (canShape ())
-	handleWindowInputInfo ();
-
-    FREEWINS_SCREEN (screen);
-
-    if (fws->mGrabWindow == window)
-	fws->mGrabWindow = NULL;
-}
-
-#define ROTATE_INC optionGetRotateIncrementAmount ()
-#define NEG_ROTATE_INC optionGetRotateIncrementAmount () *-1
-
-#define SCALE_INC optionGetScaleIncrementAmount ()
-#define NEG_SCALE_INC optionGetScaleIncrementAmount () *-1
-
-FWScreen::FWScreen (CompScreen *screen) :
-    PluginClassHandler <FWScreen, CompScreen> (screen),
-    cScreen (CompositeScreen::get (screen)),
-    gScreen (GLScreen::get (screen)),
-    mClick_root_x (0),
-    mClick_root_y (0),
-    mGrabWindow (NULL),
-    mHoverWindow (NULL),
-    mLastGrabWindow (NULL),
-    mAxisHelp (false),
-    mSnap (false),
-    mInvert (false),
-    mSnapMask (0),
-    mInvertMask (0),
-    mGrabIndex (0)
-{
-    ScreenInterface::setHandler (screen);
-    CompositeScreenInterface::setHandler (cScreen);
-    GLScreenInterface::setHandler (gScreen);
-
-    /* TODO: warning about shape! */
-
-    /* BCOP Action initiation */
-    optionSetInitiateRotationButtonInitiate (boost::bind (&FWScreen::initiateFWRotate, this, _1, _2, _3));
-    optionSetInitiateRotationButtonTerminate (boost::bind (&FWScreen::terminateFWRotate, this, _1, _2, _3));
-    optionSetInitiateScaleButtonInitiate (boost::bind (&FWScreen::initiateFWScale, this, _1, _2, _3));
-    optionSetInitiateScaleButtonTerminate (boost::bind (&FWScreen::terminateFWScale, this, _1, _2, _3));
-    optionSetResetButtonInitiate (boost::bind (&FWScreen::resetFWTransform, this, _1, _2, _3));
-    optionSetResetKeyInitiate (boost::bind (&FWScreen::resetFWTransform, this, _1, _2, _3));
-    optionSetToggleAxisKeyInitiate (boost::bind (&FWScreen::toggleFWAxis, this, _1, _2, _3));
-    
-    // Rotate / Scale Up Down Left Right TODO: rebind these actions on option change
-
-    optionSetScaleUpButtonInitiate (boost::bind (&FWScreen::scale, this, _1, _2, _3, SCALE_INC));
-    optionSetScaleDownButtonInitiate (boost::bind (&FWScreen::scale, this, _1, _2, _3, NEG_SCALE_INC));
-    optionSetScaleUpKeyInitiate (boost::bind (&FWScreen::scale, this, _1, _2, _3, SCALE_INC));
-    optionSetScaleDownKeyInitiate (boost::bind (&FWScreen::scale, this, _1, _2, _3, NEG_SCALE_INC));
-
-    optionSetRotateUpKeyInitiate (boost::bind (&FWScreen::rotate, this, _1, _2, _3, 0, ROTATE_INC, 0));
-    optionSetRotateDownKeyInitiate (boost::bind (&FWScreen::rotate, this, _1, _2, _3, 0, NEG_ROTATE_INC, 0));
-    optionSetRotateLeftKeyInitiate (boost::bind (&FWScreen::rotate, this, _1, _2, _3, ROTATE_INC, 0, 0));
-    optionSetRotateRightKeyInitiate (boost::bind (&FWScreen::rotate, this, _1, _2, _3, NEG_ROTATE_INC, 0, 0));
-    optionSetRotateCKeyInitiate (boost::bind (&FWScreen::rotate, this, _1, _2, _3, 0, 0, ROTATE_INC));
-    optionSetRotateCcKeyInitiate (boost::bind (&FWScreen::rotate, this, _1, _2, _3, 0, 0, NEG_ROTATE_INC));
-
-    optionSetRotateInitiate (boost::bind (&FWScreen::rotateAction, this, _1, _2, _3));
-    optionSetIncrementRotateInitiate (boost::bind (&FWScreen::incrementRotateAction, this, _1, _2, _3));
-    optionSetScaleInitiate (boost::bind (&FWScreen::scaleAction, this, _1, _2, _3));
-
-    optionSetSnapModsNotify (boost::bind (&FWScreen::optionChanged, this, _1, _2));
-    optionSetInvertModsNotify (boost::bind (&FWScreen::optionChanged, this, _1, _2));
-
-    reloadSnapKeys ();
-}
-
-bool
-FWPluginVTable::init ()
-{
-    if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION))
-	return false;
-    if (!CompPlugin::checkPluginABI ("composite", COMPIZ_COMPOSITE_ABI))
-	return false;
-    if (!CompPlugin::checkPluginABI ("opengl", COMPIZ_OPENGL_ABI))
-	return false;
-
-    if (!screen->XShape ())
-    {
-	compLogMessage ("shelf", CompLogLevelError,
-			"No Shape extension found. IPW Usage not enabled \n");
-    }
-
-    return true;
-}

=== removed file 'plugins/freewins/src/freewins.h'
--- plugins/freewins/src/freewins.h	2013-02-20 14:24:30 +0000
+++ plugins/freewins/src/freewins.h	1970-01-01 00:00:00 +0000
@@ -1,589 +0,0 @@
-/**
- * Compiz Fusion Freewins plugin
- *
- * freewins.h
- *
- * Copyright (C) 2007  Rodolfo Granata <[e-mail]>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * Author(s):
- * Rodolfo Granata <[e-mail]>
- *
- * Button binding support and Reset added by:
- * enigma_0Z <[e-mail]>
- *
- * Scaling, Animation, Input-Shaping, Snapping
- * and Key-Based Transformation added by:
- * Sam Spilsbury <[e-mail]>
- *
- * Most of the input handling here is based on
- * the shelf plugin by
- *        : Kristian Lyngstøl <[e-mail]>
- *        : Danny Baumann <[e-mail]>
- *
- * Description:
- *
- * This plugin allows you to freely transform the texture of a window,
- * whether that be rotation or scaling to make better use of screen space
- * or just as a toy.
- *
- * Todo:
- *  - Fully implement an input redirection system by
- *    finding an inverse matrix, multiplying by it,
- *    translating to the actual window co-ords and
- *    XSendEvent() the co-ords to the actual window.
- *  - Code could be cleaner
- *  - Add timestep and speed options to animation
- *  - Add window hover-over info via paintOutput : i.e
- *    - Resize borders
- *    - 'Reset' Button
- *    - 'Scale' Button
- *    - 'Rotate' Button
- */
-
-#include <core/core.h>
-#include <core/pluginclasshandler.h>
-#include <composite/composite.h>
-#include <opengl/opengl.h>
-#include <core/atoms.h>
-
-#include <cmath>
-#include <cstdio>
-#include <cstring>
-
-#include <X11/cursorfont.h>
-#include <X11/extensions/shape.h>
-
-#include <GL/glu.h>
-#include <GL/gl.h>
-
-#include "freewins_options.h"
-
-/* #define ABS(x) ((x)>0?(x):-(x)) */
-#define D2R(x) ((x) * (M_PI / 180.0))
-#define R2D(x) ((x) * (180 / M_PI))
-
-/* ------ Macros ---------------------------------------------------------*/
-
-#define WIN_OUTPUT_X(w) (w->x () - w->output ().left)
-#define WIN_OUTPUT_Y(w) (w->y () - w->output ().top)
-
-#define WIN_OUTPUT_W(w) (w->width () + w->output ().left + w->output ().right)
-#define WIN_OUTPUT_H(w) (w->height () + w->output ().top + w->output ().bottom)
-
-#define WIN_REAL_X(w) (w->x () - w->border ().left)
-#define WIN_REAL_Y(w) (w->y () - w->border ().top)
-
-#define WIN_REAL_W(w) (w->width () + w->border ().left + w->border ().right)
-#define WIN_REAL_H(w) (w->height () + w->border ().top + w->border ().bottom)
-
-#define WIN_CORNER1(w) GLVector ic1 = GLVector (WIN_REAL_X (w), WIN_REAL_Y (w), 0.0f, 1.0f);
-#define WIN_CORNER2(w) GLVector ic2 = GLVector (WIN_REAL_X (w) + WIN_REAL_W (w), WIN_REAL_Y (w), 0.0f, 1.0f);
-#define WIN_CORNER3(w) GLVector ic3 = GLVector (WIN_REAL_X (w), WIN_REAL_Y (w) + WIN_REAL_H (w), 0.0f, 1.0f);
-#define WIN_CORNER4(w) GLVector ic4 = GLVector (WIN_REAL_X (w) + WIN_REAL_W (w), WIN_REAL_Y (w) + WIN_REAL_H (w), 0.0f, 1.0f);
-
-#define WIN_OCORNER1(w) GLVector oc1 = GLVector (WIN_OUTPUT_X (w), WIN_OUTPUT_Y (w), 0.0f, 1.0f);
-#define WIN_OCORNER2(w) GLVector oc2 = GLVector (WIN_OUTPUT_X (w) + WIN_OUTPUT_W (w), WIN_OUTPUT_Y (w), 0.0f, 1.0f);
-#define WIN_OCORNER3(w) GLVector oc3 = GLVector (WIN_OUTPUT_X (w), WIN_OUTPUT_Y (w) + WIN_OUTPUT_H (w), 0.0f, 1.0f);
-#define WIN_OCORNER4(w) GLVector oc4 = GLVector ( WIN_OUTPUT_X (w) + WIN_OUTPUT_W (w), WIN_OUTPUT_Y (w) + WIN_OUTPUT_H (w), 0.0f, 1.0f);
-
-/* ------ Structures and Enums ------------------------------------------*/
-
-/* Enums */
-typedef enum _StartCorner
-{
-    CornerTopLeft = 0,
-    CornerTopRight = 1,
-    CornerBottomLeft = 2,
-    CornerBottomRight = 3
-} StartCorner;
-
-typedef enum _FWGrabType
-{
-    grabNone = 0,
-    grabRotate,
-    grabScale,
-    grabMove,
-    grabResize
-} FWGrabType;
-
-typedef enum _Direction
-{
-    UpDown = 0,
-    LeftRight = 1
-} Direction;
-
-typedef enum _FWAxisType
-{
-    axisX = 0,
-    axisY,
-    axisZ,
-    axisXY,
-    axisXZ,
-} FWAxisType;
-
-/* Shape info / restoration */
-class FWWindowInputInfo
-{
-    public:
-
-	FWWindowInputInfo (CompWindow *);
-	~FWWindowInputInfo ();
-
-    public:
-	CompWindow                *w;
-
-	Window     ipw;
-
-	XRectangle *inputRects;
-	int        nInputRects;
-	int        inputRectOrdering;
-
-	XRectangle *frameInputRects;
-	int        frameNInputRects;
-	int        frameInputRectOrdering;
-};
-
-class FWWindowOutputInfo
-{
-    public:
-	float shapex1;
-	float shapex2;
-	float shapex3;
-	float shapex4;
-	float shapey1;
-	float shapey2;
-	float shapey3;
-	float shapey4;
-}; 
-
-/* Trackball */
-
-/*typedef struct _FWTrackball
-{
-    CompVector mouseX;
-    CompVector mouse0;
-    CompVector tr_axis;
-    float tr_ang;
-    float tr_radius;
-
-} FWTrackball;*/
-
-/* Transformation info */
-class FWTransformedWindowInfo
-{
-    public:
-	FWTransformedWindowInfo () :
-	    angX (0),
-	    angY (0),
-	    angZ (0),
-	    scaleX (1.0f),
-	    scaleY (1.0f),
-	    unsnapAngX (0),
-	    unsnapAngY (0),
-	    unsnapAngZ (0),
-	    unsnapScaleX (0),
-	    unsnapScaleY (0) {}
-
-	//FWTrackball trackball;
-
-	float angX;
-	float angY;
-	float angZ;
-
-	float scaleX;
-	float scaleY;
-
-	// Window transformation
-
-	/* Used for snapping */
-
-	float unsnapAngX;
-	float unsnapAngY;
-	float unsnapAngZ;
-
-	float unsnapScaleX;
-	float unsnapScaleY;
-};
-
-class FWAnimationInfo
-{
-    public:
-
-	FWAnimationInfo () :
-	    oldAngX (0),
-	    oldAngY (0),
-	    oldAngZ (0),
-	    oldScaleX (1.0f),
-	    oldScaleY (1.0f),
-	    destAngX (0),
-	    destAngY (0),
-	    destAngZ (0),
-	    destScaleX (1.0f),
-	    destScaleY (1.0f),
-	    steps (0) {}
-
-	// Old values to animate from
-	float oldAngX;
-	float oldAngY;
-	float oldAngZ;
-
-	float oldScaleX;
-	float oldScaleY;
-
-	// New values to animate to
-	float destAngX;
-	float destAngY;
-	float destAngZ;
-
-	float destScaleX;
-	float destScaleY;
-
-	// For animation
-	float steps;
-};
-
-class FWScreen :
-	public PluginClassHandler <FWScreen, CompScreen>,
-	public ScreenInterface,
-	public CompositeScreenInterface,
-	public GLScreenInterface,
-	public FreewinsOptions
-{
-    public:
-
-	FWScreen (CompScreen *screen);
-
-	CompositeScreen *cScreen;
-	GLScreen	*gScreen;
-
-	std::list <FWWindowInputInfo *> mTransformedWindows;
-
-	int mClick_root_x;
-	int mClick_root_y;
-
-	CompWindow *mGrabWindow;
-	CompWindow *mHoverWindow;
-	CompWindow *mLastGrabWindow;
-
-	bool mAxisHelp;
-	bool mSnap;
-	bool mInvert;
-	int  mSnapMask;
-	int  mInvertMask;
-
-	Cursor mRotateCursor;
-
-	CompScreen::GrabHandle mGrabIndex;
-
-	void preparePaint (int);
-	bool glPaintOutput (const GLScreenPaintAttrib &,
-			    const GLMatrix	      &,
-			    const CompRegion	      &,
-			    CompOutput		      *,
-			    unsigned int		);
-	void donePaint ();
-
-	void handleEvent (XEvent *);
-
-	void
-	optionChanged (CompOption *option,
-		       FreewinsOptions::Options num);
-
-	void
-	reloadSnapKeys ();
-
-	bool
-	initiateFWRotate (CompAction         *action,
-			  CompAction::State  state,
-			  CompOption::Vector options);
-
-	bool
-	terminateFWRotate (CompAction          *action,
-			   CompAction::State   state,
-			   CompOption::Vector  options);
-
-	bool
-	initiateFWScale (CompAction         *action,
-			 CompAction::State  state,
-			 CompOption::Vector options);
-
-	bool
-	terminateFWScale (CompAction         *action,
-			  CompAction::State  state,
-			  CompOption::Vector options);
-
-	bool
-	rotate (CompAction         *action,
-		CompAction::State  state,
-		CompOption::Vector options, int dx, int dy, int dz);
-
-	bool
-	scale (CompAction          *action,
-	       CompAction::State   state,
-	       CompOption::Vector  options,
-	       int		     scale);
-	bool
-	resetFWTransform (CompAction         *action,
-			  CompAction::State  state,
-			  CompOption::Vector options);
-
-	bool
-	rotateAction (CompAction         *action,
-		      CompAction::State  state,
-		      CompOption::Vector options);
-
-	bool
-	incrementRotateAction (CompAction         *action,
-			       CompAction::State  state,
-			       CompOption::Vector options);
-
-	bool
-	scaleAction (CompAction         *action,
-		     CompAction::State  state,
-		     CompOption::Vector options);
-
-	bool
-	toggleFWAxis (CompAction         *action,
-		      CompAction::State  state,
-		      CompOption::Vector options);
-
-	void
-	addWindowToList (FWWindowInputInfo *info);
-
-	void
-	removeWindowFromList (FWWindowInputInfo *info);
-
-	void
-	adjustIPWStacking ();
-
-	void
-	rotateProjectVector (GLVector &vector,
-			     GLMatrix &transform,
-			     GLdouble *resultX,
-			     GLdouble *resultY,
-			     GLdouble *resultZ);
-
-	void
-	perspectiveDistortAndResetZ (GLMatrix &transform);
-
-	void
-	modifyMatrix  (GLMatrix &transform,
-		       float angX, float angY, float angZ,
-		       float tX, float tY, float tZ,
-		       float scX, float scY, float scZ,
-		       float adjustX, float adjustY, bool paint);
-
-	CompRect
-	createSizedRect (float xScreen1,
-			 float xScreen2,
-			 float xScreen3,
-			 float xScreen4,
-			 float yScreen1,
-			 float yScreen2,
-			 float yScreen3,
-			 float yScreen4);
-
-	CompWindow *
-	getRealWindow (CompWindow *w);
-};
-
-/* Freewins Window Structure */
-class FWWindow :
-	public PluginClassHandler <FWWindow, CompWindow>,
-	public WindowInterface,
-	public CompositeWindowInterface,
-	public GLWindowInterface
-{
-    public:
-
-	FWWindow (CompWindow *w);
-	~FWWindow ();
-
-	CompWindow *window;
-	CompositeWindow *cWindow;
-	GLWindow	*gWindow;
-
-	bool glPaint (const GLWindowPaintAttrib &,
-		      const GLMatrix		&,
-		      const CompRegion		&,
-		      unsigned int		  );
-
-	bool damageRect (bool initial,
-			 const CompRect &);
-
-	void moveNotify (int, int, bool);
-	void resizeNotify (int, int, int, int);
-
-	float mIMidX;
-	float mIMidY;
-
-	float mOMidX; /* These will be removed */
-	float mOMidY;
-
-	float mAdjustX;
-	float mAdjustY;
-
-	float mRadius;
-
-	// Used for determining window movement
-
-	int mOldWinX;
-	int mOldWinY;
-
-	// Used for resize
-
-	int mWinH;
-	int mWinW;
-
-	Direction mDirection;
-
-	// Used to determine starting point
-	StartCorner mCorner;
-
-	// Transformation info
-	FWTransformedWindowInfo mTransform;
-
-	// Animation Info
-	FWAnimationInfo mAnimate;
-
-	// Input Info
-	FWWindowInputInfo *mInput;
-
-	//Output Info
-	FWWindowOutputInfo mOutput;
-
-	CompRect mOutputRect;
-	CompRect mInputRect;
-
-	// Used to determine whether to animate the window
-	bool mResetting;
-	bool mIsAnimating;
-
-	// Used to determine whether rotating on X and Y axis, or just on Z
-	bool mCan2D; // These need to be removed
-	bool mCan3D;
-
-	bool mTransformed; // So does this in favor of FWWindowInputInfo
-
-	FWGrabType mGrab;
-
-	void
-	shapeIPW ();
-
-	void
-	saveInputShape (XRectangle **retRects,
-			int       *retCount,
-			int       *retOrdering);
-
-	void
-	adjustIPW ();
-
-	void
-	createIPW ();
-
-	bool
-	handleWindowInputInfo ();
-
-	void
-	shapeInput ();
-
-	void
-	unshapeInput ();
-
-	void
-	handleIPWResizeInitiate ();
-
-	void
-	handleIPWMoveInitiate ();
-
-	void
-	handleIPWMoveMotionEvent (unsigned int x,
-				  unsigned int y);
-
-	void
-	handleIPWResizeMotionEvent (unsigned int x,
-				    unsigned int y);
-
-	void
-	handleRotateMotionEvent (float dx,
-				 float dy,
-				 int x,
-				 int y);
-
-	void
-	handleScaleMotionEvent (float dx,
-				float dy,
-				int x,
-				int y);
-
-	void
-	handleButtonReleaseEvent ();
-
-	void
-	handleEnterNotify (XEvent *xev);
-
-	void
-	handleLeaveNotify (XEvent *xev);
-
-	void
-	damageArea ();
-
-	void
-	setPrepareRotation (float dx,
-			    float dy,
-			    float dz,
-			    float dsu,
-			    float dsd);
-
-	void
-	calculateInputOrigin (float x, float y);
-
-	void
-	calculateOutputOrigin (float x, float y);
-
-	void
-	calculateOutputRect ();
-
-	void
-	calculateInputRect ();
-
-	CompRect
-	calculateWindowRect (GLVector c1,
-			     GLVector c2,
-			     GLVector c3,
-			     GLVector c4);
-
-	void
-	determineZAxisClick (int px,
-			     int py,
-			     bool motion);
-	bool
-	canShape ();
-
-	void
-	handleSnap ();
-};
-
-#define FREEWINS_SCREEN(screen)						       \
-    FWScreen *fws = FWScreen::get (screen);
-
-#define FREEWINS_WINDOW(window)						       \
-    FWWindow *fww = FWWindow::get (window);
-
-class FWPluginVTable :
-	public CompPlugin::VTableForScreenAndWindow <FWScreen, FWWindow>
-{
-    public:
-
-	bool init ();
-};

=== removed file 'plugins/freewins/src/input.cpp'
--- plugins/freewins/src/input.cpp	2013-02-20 14:24:30 +0000
+++ plugins/freewins/src/input.cpp	1970-01-01 00:00:00 +0000
@@ -1,397 +0,0 @@
-/**
- * Compiz Fusion Freewins plugin
- *
- * input.cpp
- *
- * Copyright (C) 2007  Rodolfo Granata <[e-mail]>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * Author(s):
- * Rodolfo Granata <[e-mail]>
- * Sam Spilsbury <[e-mail]>
- *
- * Button binding support and Reset added by:
- * enigma_0Z <[e-mail]>
- *
- * Most of the input handling here is based on
- * the shelf plugin by
- *        : Kristian Lyngstøl <[e-mail]>
- *        : Danny Baumann <[e-mail]>
- *
- * Description:
- *
- * This plugin allows you to freely transform the texture of a window,
- * whether that be rotation or scaling to make better use of screen space
- * or just as a toy.
- *
- * Todo:
- *  - Fully implement an input redirection system by
- *    finding an inverse matrix, multiplying by it,
- *    translating to the actual window co-ords and
- *    XSendEvent() the co-ords to the actual window.
- *  - Code could be cleaner
- *  - Add timestep and speed options to animation
- *  - Add window hover-over info via paintOutput : i.e
- *    - Resize borders
- *    - 'Reset' Button
- *    - 'Scale' Button
- *    - 'Rotate' Button
- */
-
-#include "freewins.h"
-#include <cairo/cairo-xlib.h>
-
-
-/* ------ Input Prevention -------------------------------------------*/
-
-/* Shape the IPW
- * Thanks to Joel Bosveld (b0le)
- * for helping me with this section
- */
-void
-FWWindow::shapeIPW ()
-{
-    if (mInput)
-    {
-	Window xipw = mInput->ipw;
-	CompWindow *ipw = screen->findWindow (xipw);
-
-	if (ipw)
-	{
-	    cairo_t 				*cr;
-	    int               width, height;
-
-	    width = mInputRect.width ();
-	    height = mInputRect.height ();
-
-	    Pixmap b = XCreatePixmap (screen->dpy (), xipw, width, height, 1);
-
-	    cairo_surface_t *bitmap =
-		    cairo_xlib_surface_create_for_bitmap (screen->dpy (),
-							  b,
-							  DefaultScreenOfDisplay (screen->dpy ()),
-							  width, height);
-
-	    cr = cairo_create (bitmap);
-
-	    cairo_save (cr);
-	    cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
-	    cairo_paint (cr);
-	    cairo_restore (cr);
-
-	    /* Move to our first corner (TopLeft) */
-
-	    cairo_move_to (cr,
-			   mOutput.shapex1 - MIN(mInputRect.x1 (), mInputRect.x2 ()),
-			   mOutput.shapey1 - MIN(mInputRect.y1 (), mInputRect.y2 ()));
-
-	    /* Line to TopRight */
-
-	    cairo_line_to (cr,
-			   mOutput.shapex2 - MIN(mInputRect.x1 (), mInputRect.x2 ()),
-			   mOutput.shapey2 - MIN(mInputRect.y1 (), mInputRect.y2 ()));
-
-	    /* Line to BottomRight */
-
-	    cairo_line_to (cr,
-			   mOutput.shapex4 - MIN(mInputRect.x1 (), mInputRect.x2 ()),
-			   mOutput.shapey4 - MIN(mInputRect.y1 (), mInputRect.y2 ()));
-
-	    /* Line to BottomLeft */
-
-	    cairo_line_to (cr,
-			   mOutput.shapex3 - MIN(mInputRect.x1 (), mInputRect.x2 ()),
-			   mOutput.shapey3 - MIN(mInputRect.y1 (), mInputRect.y2 ()));
-
-	    /* Line to TopLeft */
-
-	    cairo_line_to (cr,
-			   mOutput.shapex1 - MIN(mInputRect.x1 (), mInputRect.x2 ()),
-			   mOutput.shapey1 - MIN(mInputRect.y1 (), mInputRect.y2 ()));
-
-	    /* Ensure it's all closed up */
-
-	    cairo_close_path (cr);
-
-	    /* Fill in the box */
-
-	    cairo_set_source_rgb (cr, 1.0f, 1.0f, 1.0f);
-	    cairo_fill (cr);
-
-	    /* This takes the bitmap we just drew with cairo
-	     * and scans out the white bits (You can see these)
-	     * if you uncomment the following line after this
-	     * comment. Then, all the bits we drew on are clickable,
-	     * leaving us with a nice and neat window shape. Yummy.
-	     */
-
-	    /* XWriteBitmapFile (ipw->screen->display->display,
-								 "/path/to/your/image.bmp",
-								 b,
-								 ipw->width,
-								 ipw->height,
-								 -1, -1);  */
-
-	    XShapeCombineMask (screen->dpy (), xipw,
-			       ShapeBounding,
-			       0,
-			       0,
-			       b,
-			       ShapeSet);
-
-	    XFreePixmap (screen->dpy (), b);
-	    cairo_surface_destroy (bitmap);
-	    cairo_destroy (cr);
-	}
-    }
-}
-
-void
-FWWindow::saveInputShape (XRectangle **retRects,
-			  int       *retCount,
-			  int       *retOrdering)
-{
-    XRectangle *rects;
-    int        count = 0, ordering;
-    Display    *dpy = screen->dpy ();
-
-    rects = XShapeGetRectangles (dpy, window->id (), ShapeInput, &count, &ordering);
-
-    /* check if the returned shape exactly matches the window shape -
-       if that is true, the window currently has no set input shape */
-    if ((count == 1) &&
-	(rects[0].x == -window->geometry ().border ()) &&
-	(rects[0].y == -window->geometry ().border ()) &&
-	(rects[0].width == (window->serverWidth () +
-			    window->serverGeometry ().border ())) &&
-	(rects[0].height == (window->serverHeight () +
-			     window->serverGeometry (). border ())))
-    {
-	count = 0;
-    }
-    
-    *retRects    = rects;
-    *retCount    = count;
-    *retOrdering = ordering;
-}
-
-void
-FWScreen::addWindowToList (FWWindowInputInfo *info)
-{
-    mTransformedWindows.push_back (info);
-}
-
-void
-FWScreen::removeWindowFromList (FWWindowInputInfo *info)
-{
-    mTransformedWindows.remove (info);
-}
-
-/* Adjust size and location of the input prevention window */
-void
-FWWindow::adjustIPW ()
-{
-    XWindowChanges xwc;
-    Display        *dpy = screen->dpy ();
-    float          f_width, f_height;
-
-    if (!mInput || !mInput->ipw)
-	return;
-
-    f_width  = mInputRect.width ();
-    f_height = mInputRect.height ();
-
-    xwc.x          = mInputRect.x ();
-    xwc.y          = mInputRect.y ();
-    xwc.width      = (int) f_width;
-    xwc.height     = (int) f_height;
-    xwc.stack_mode = Below;
-    /* XXX: This causes XConfigureWindow to break */
-    //xwc.sibling    = window->id ();
-
-    XMapWindow (dpy, mInput->ipw);
-
-    XConfigureWindow (dpy, mInput->ipw,
-		      CWStackMode | CWX | CWY | CWWidth | CWHeight,
-		      &xwc);
-
-    shapeIPW ();
-}
-
-void
-FWScreen::adjustIPWStacking ()
-{
-
-    foreach (FWWindowInputInfo *run, mTransformedWindows)
-    {
-	if (!run->w->prev || run->w->prev->id () != run->ipw)
-	    FWWindow::get (run->w)->adjustIPW ();
-    }
-}
-
-/* Create an input prevention window */
-void
-FWWindow::createIPW ()
-{
-    Window               ipw;
-    XSetWindowAttributes attrib;
-    XWindowChanges       xwc;
-
-    if (!mInput || mInput->ipw)
-	return;
-
-    attrib.override_redirect = true;
-    //attrib.event_mask        = 0;
-
-    xwc.x = mInputRect.x ();
-    xwc.y = mInputRect.y ();
-    xwc.width = mInputRect.width ();
-    xwc.height = mInputRect.height ();
-
-    ipw = XCreateWindow (screen->dpy (),
-			 screen->root (),
-			 xwc.x, xwc.y, xwc.width, xwc.height, 0, CopyFromParent, InputOnly,
-			 CopyFromParent, CWOverrideRedirect, &attrib);
-
-    XMapWindow (screen->dpy (), ipw);
-
-    //XConfigureWindow (screen->dpy (), ipw, CWStackMode | CWX | CWY | CWWidth | CWHeight, &xwc);
-
-    mInput->ipw = ipw;
-
-    //shapeIPW ();
-}
-
-FWWindowInputInfo::FWWindowInputInfo (CompWindow *window) :
-    w (window),
-    ipw (None),
-    inputRects (NULL),
-    nInputRects (0),
-    inputRectOrdering (0),
-    frameInputRects (NULL),
-    frameNInputRects (0),
-    frameInputRectOrdering (0)
-{
-}
-
-FWWindowInputInfo::~FWWindowInputInfo ()
-{
-}
-
-bool
-FWWindow::handleWindowInputInfo ()
-{
-    FREEWINS_SCREEN (screen);
-
-    if (!mTransformed && mInput)
-    {
-	if (mInput->ipw)
-	    XDestroyWindow (screen->dpy (), mInput->ipw);
-
-	unshapeInput ();
-	fws->removeWindowFromList (mInput);
-
-	delete mInput;
-	mInput = NULL;
-
-	return false;
-    }
-    else if (mTransformed && !mInput)
-    {
-	mInput = new FWWindowInputInfo (window);
-	if (!mInput)
-	    return false;
-
-	shapeInput ();
-	createIPW ();
-	fws->addWindowToList (mInput);
-    }
-
-    return true;
-}
-
-/* Shape the input of the window when scaled.
- * Since the IPW will be dealing with the input, removing input
- * from the window entirely is a perfectly good solution. */
-void
-FWWindow::shapeInput ()
-{
-    Window     frame;
-    Display    *dpy = screen->dpy();
-
-    saveInputShape (&mInput->inputRects,
-		    &mInput->nInputRects,
-		    &mInput->inputRectOrdering);
-
-    frame = window->frame();
-    if (frame)
-    {
-	saveInputShape (&mInput->frameInputRects, &mInput->frameNInputRects,
-			&mInput->frameInputRectOrdering);
-    }
-    else
-    {
-	mInput->frameInputRects        = NULL;
-	mInput->frameNInputRects       = -1;
-	mInput->frameInputRectOrdering = 0;
-    }
-
-    /* clear shape */
-    XShapeSelectInput (dpy, window->id(), NoEventMask);
-    XShapeCombineRectangles  (dpy, window->id(), ShapeInput, 0, 0,
-			      NULL, 0, ShapeSet, 0);
-    
-    if (frame)
-	XShapeCombineRectangles  (dpy, window->frame(), ShapeInput, 0, 0,
-				  NULL, 0, ShapeSet, 0);
-
-    XShapeSelectInput (dpy, window->id(), ShapeNotify);
-}
-
-/* Restores the shape of the window:
- * If the window had a custom shape defined by inputRects then we restore
- * that in order with XShapeCombineRectangles.
- * Most windows have no specific defined shape so we can restore it with
- * setting the shape to a 0x0 mask
- */
-void
-FWWindow::unshapeInput ()
-{
-    Display *dpy = screen->dpy ();
-
-    if (mInput->nInputRects)
-    {
-	XShapeCombineRectangles (dpy, window->id(), ShapeInput, 0, 0,
-				 mInput->inputRects, mInput->nInputRects,
-				 ShapeSet, mInput->inputRectOrdering);
-    }
-    else
-    {
-	XShapeCombineMask (dpy, window->id(), ShapeInput, 0, 0, None, ShapeSet);
-    }
-
-    if (mInput->frameNInputRects >= 0)
-    {
-	if (mInput->frameNInputRects)
-	{
-	    XShapeCombineRectangles (dpy, window->frame(), ShapeInput, 0, 0,
-				     mInput->frameInputRects,
-				     mInput->frameNInputRects,
-				     ShapeSet,
-				     mInput->frameInputRectOrdering);
-	}
-	else
-	{
-	    XShapeCombineMask (dpy, window->frame(), ShapeInput, 0, 0, None, ShapeSet);
-	}
-    }
-}

=== removed file 'plugins/freewins/src/paint.cpp'
--- plugins/freewins/src/paint.cpp	2013-02-20 14:24:30 +0000
+++ plugins/freewins/src/paint.cpp	1970-01-01 00:00:00 +0000
@@ -1,527 +0,0 @@
-/**
- * Compiz Fusion Freewins plugin
- *
- * paint.cpp
- *
- * Copyright (C) 2007  Rodolfo Granata <[e-mail]>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * Author(s):
- * Rodolfo Granata <[e-mail]>
- * Sam Spilsbury <[e-mail]>
- *
- * Button binding support and Reset added by:
- * enigma_0Z <[e-mail]>
- *
- * Most of the input handling here is based on
- * the shelf plugin by
- *        : Kristian Lyngstøl <[e-mail]>
- *        : Danny Baumann <[e-mail]>
- *
- * Description:
- *
- * This plugin allows you to freely transform the texture of a window,
- * whether that be rotation or scaling to make better use of screen space
- * or just as a toy.
- *
- * Todo:
- *  - Fully implement an input redirection system by
- *    finding an inverse matrix, multiplying by it,
- *    translating to the actual window co-ords and
- *    XSendEvent() the co-ords to the actual window.
- *  - Code could be cleaner
- *  - Add timestep and speed options to animation
- *  - Add window hover-over info via paintOutput : i.e
- *    - Resize borders
- *    - 'Reset' Button
- *    - 'Scale' Button
- *    - 'Rotate' Button
- */
-
-#include "freewins.h"
-
-
-/* ------ Window and Output Painting ------------------------------------*/
-
-/* Damage util function */
-
-void
-FWWindow::damageArea ()
-{
-    CompositeScreen::get (screen)->damageRegion (mOutputRect);
-}
-
-/* Animation Prep */
-void
-FWScreen::preparePaint (int	      ms)
-{
-    /* FIXME: should only loop over all windows if at least one animation is running */
-    foreach (CompWindow *w, screen->windows ())
-    {
-	FREEWINS_WINDOW (w);
-	float speed = optionGetSpeed ();
-	fww->mAnimate.steps = ((float) ms / ((20.1 - speed) * 100));
-
-	if (fww->mAnimate.steps < 0.005)
-	    fww->mAnimate.steps = 0.005;
-
-	/* Animation. We calculate how much increment
-	 * a window must rotate / scale per paint by
-	 * using the set destination attributes minus
-	 * the old attributes divided by the time
-	 * remaining.
-	 */
-
-	/* Don't animate if the window is saved */
-	fww->mTransform.angX += (float) fww->mAnimate.steps * (fww->mAnimate.destAngX - fww->mTransform.angX) * speed;
-	fww->mTransform.angY += (float) fww->mAnimate.steps * (fww->mAnimate.destAngY - fww->mTransform.angY) * speed;
-	fww->mTransform.angZ += (float) fww->mAnimate.steps * (fww->mAnimate.destAngZ - fww->mTransform.angZ) * speed;
-
-	fww->mTransform.scaleX += (float) fww->mAnimate.steps * (fww->mAnimate.destScaleX - fww->mTransform.scaleX) * speed;
-	fww->mTransform.scaleY += (float) fww->mAnimate.steps * (fww->mAnimate.destScaleY - fww->mTransform.scaleY) * speed;
-
-	if (((fww->mTransform.angX >= fww->mAnimate.destAngX - 0.05 &&
-	      fww->mTransform.angX <= fww->mAnimate.destAngX + 0.05 ) &&
-	     (fww->mTransform.angY >= fww->mAnimate.destAngY - 0.05 &&
-	      fww->mTransform.angY <= fww->mAnimate.destAngY + 0.05 ) &&
-	     (fww->mTransform.angZ >= fww->mAnimate.destAngZ - 0.05 &&
-	      fww->mTransform.angZ <= fww->mAnimate.destAngZ + 0.05 ) &&
-	     (fww->mTransform.scaleX >= fww->mAnimate.destScaleX - 0.00005 &&
-	      fww->mTransform.scaleX <= fww->mAnimate.destScaleX + 0.00005 ) &&
-	     (fww->mTransform.scaleY >= fww->mAnimate.destScaleY - 0.00005 &&
-	      fww->mTransform.scaleY <= fww->mAnimate.destScaleY + 0.00005 )))
-	{
-	    fww->mResetting = FALSE;
-
-	    fww->mTransform.angX = fww->mAnimate.destAngX;
-	    fww->mTransform.angY = fww->mAnimate.destAngY;
-	    fww->mTransform.angZ = fww->mAnimate.destAngZ;
-	    fww->mTransform.scaleX = fww->mAnimate.destScaleX;
-	    fww->mTransform.scaleY = fww->mAnimate.destScaleY;
-
-	    fww->mTransform.unsnapAngX = fww->mAnimate.destAngX;
-	    fww->mTransform.unsnapAngY = fww->mAnimate.destAngY;
-	    fww->mTransform.unsnapAngZ = fww->mAnimate.destAngZ;
-	    fww->mTransform.unsnapScaleX = fww->mAnimate.destScaleX;
-	    fww->mTransform.unsnapScaleY = fww->mAnimate.destScaleX;
-	}
-	//else
-	//    fww->damageArea ();
-    }
-
-    cScreen->preparePaint (ms);
-}
-
-/* Paint the window rotated or scaled */
-bool
-FWWindow::glPaint (const GLWindowPaintAttrib &attrib,
-		   const GLMatrix	     &transform,
-		   const CompRegion	     &region,
-		   unsigned int		     mask)
-{
-
-    GLMatrix wTransform (transform);
-    int currentCull, invertCull;
-    glGetIntegerv (GL_CULL_FACE_MODE, &currentCull);
-    invertCull = (currentCull == GL_BACK) ? GL_FRONT : GL_BACK;
-
-    bool status;
-
-    FREEWINS_SCREEN (screen);
-
-    /* Has something happened? */
-    
-    /* Check to see if we are painting on a transformed screen */
-    /* Enable this code when we can animate between the two states */
-
-    if ((mTransform.angX != 0.0 ||
-	 mTransform.angY != 0.0 ||
-	 mTransform.angZ != 0.0 ||
-	 mTransform.scaleX != 1.0 ||
-	 mTransform.scaleY != 1.0 ||
-	 mOldWinX != WIN_REAL_X (window) ||
-	 mOldWinY != WIN_REAL_Y (window)) && fws->optionGetShapeWindowTypes ().evaluate (window))
-    {
-	mOldWinX = WIN_REAL_X (window);
-	mOldWinY = WIN_REAL_Y (window);
-
-	/* Figure out where our 'origin' is, don't allow the origin to
-	 * be where we clicked if the window is not grabbed, etc
-	 */
-
-	/* Here we duplicate some of the work the openGL does
-	 * but for different reasons. We have access to the
-	 * window's transformation matrix, so we will create
-	 * our own matrix and apply the same transformations
-	 * to it. From there, we create vectors for each point
-	 * that we wish to track and multiply them by this
-	 * matrix to give us the rotated / scaled co-ordinates.
-	 * From there, we project these co-ordinates onto the flat
-	 * screen that we have using the OGL viewport, projection
-	 * matrix and model matrix. Projection gives us three
-	 * co-ordinates, but we ignore Z and just use X and Y
-	 * to store in a surrounding rectangle. We can use this
-	 * surrounding rectangle to make things like shaping and
-	 * damage a lot more accurate than they used to be.
-	 */
-
-	calculateOutputRect ();
-
-	/* Prepare for transformation by
-	 * doing any necessary adjustments */
-	float autoScaleX = 1.0f;
-	float autoScaleY = 1.0f;
-
-	if (fws->optionGetAutoZoom ())
-	{
-	    float apparantWidth = mOutputRect.width ();
-	    float apparantHeight = mOutputRect.height ();
-
-	    autoScaleX = (float) WIN_OUTPUT_W (window) / (float) apparantWidth;
-	    autoScaleY = (float) WIN_OUTPUT_H (window) / (float) apparantHeight;
-
-	    if (autoScaleX >= 1.0f)
-		autoScaleX = 1.0f;
-	    if (autoScaleY >= 1.0f)
-		autoScaleY = 1.0f;
-
-	    autoScaleX = autoScaleY = (autoScaleX + autoScaleY) / 2;
-
-	    /* Because we modified the scale after calculating
-	     * the output rect, we need to recalculate again */
-	    calculateOutputRect ();
-
-	}
-	/*
-	float scaleX = autoScaleX - (1 - mTransform.scaleX);
-	float scaleY = autoScaleY - (1 - mTransform.scaleY);
-	*/
-
-	/* Actually Transform the window */
-	mask |= PAINT_WINDOW_TRANSFORMED_MASK;
-
-	/* Adjust the window in the matrix to prepare for transformation */
-	if (mGrab != grabRotate && mGrab != grabScale)
-	{
-
-	    calculateInputOrigin (WIN_REAL_X (window) + WIN_REAL_W (window) / 2.0f,
-				  WIN_REAL_Y (window) + WIN_REAL_H (window) / 2.0f);
-	    calculateOutputOrigin (WIN_OUTPUT_X (window) + WIN_OUTPUT_W (window) / 2.0f,
-				   WIN_OUTPUT_Y (window) + WIN_OUTPUT_H (window) / 2.0f);
-	}
-
-	float adjustX = 0.0f;
-	float adjustY = 0.0f;
-	fws->modifyMatrix (wTransform,
-			   mTransform.angX,
-			   mTransform.angY,
-			   mTransform.angZ,
-			   mIMidX, mIMidY , 0.0f,
-			   mTransform.scaleX,
-			   mTransform.scaleY,
-			   1.0f, adjustX, adjustY, TRUE);
-
-	/* Create rects for input after we've dealt with output */
-	calculateInputRect ();
-
-	/* Determine if the window is inverted */
-	Bool xInvert = FALSE;
-	Bool yInvert = FALSE;
-
-	Bool needsInvert = FALSE;
-	float renX = fabs (fmodf (mTransform.angX, 360.0f));
-	float renY = fabs (fmodf (mTransform.angY, 360.0f));
-
-	if (90 < renX && renX < 270)
-	    xInvert = TRUE;
-
-	if (90 < renY && renY < 270)
-	    yInvert = TRUE;
-
-	if ((xInvert || yInvert) && !(xInvert && yInvert))
-	    needsInvert = TRUE;
-
-	if (needsInvert)
-	    glCullFace (invertCull);
-
-	status = gWindow->glPaint (attrib, wTransform, region, mask);
-
-	if (needsInvert)
-	    glCullFace (currentCull);
-
-    }
-    else
-    {
-	status = gWindow->glPaint (attrib, wTransform, region, mask);
-    }
-
-    // Check if there are rotated windows
-    if (!((mTransform.angX >= 0.0f - 0.05 &&
-	   mTransform.angX <= 0.0f + 0.05 ) &&
-	  (mTransform.angY >= 0.0f - 0.05 &&
-	   mTransform.angY <= 0.0f + 0.05 ) &&
-	  (mTransform.angZ >= 0.0f - 0.05 &&
-	   mTransform.angZ <= 0.0f + 0.05 ) &&
-	  (mTransform.scaleX >= 1.0f - 0.00005 &&
-	   mTransform.scaleX <= 1.0f + 0.00005 ) &&
-	  (mTransform.scaleY >= 1.0f - 0.00005 &&
-	   mTransform.scaleY <= 1.0f + 0.00005 )) && !mTransformed)
-	mTransformed = TRUE;
-    else if (mTransformed)
-	mTransformed = FALSE;
-
-    /* There is still animation to be done */
-    if (!(((mTransform.angX >= mAnimate.destAngX - 0.05 &&
-	    mTransform.angX <= mAnimate.destAngX + 0.05 ) &&
-	   (mTransform.angY >= mAnimate.destAngY - 0.05 &&
-	    mTransform.angY <= mAnimate.destAngY + 0.05 ) &&
-	   (mTransform.angZ >= mAnimate.destAngZ - 0.05 &&
-	    mTransform.angZ <= mAnimate.destAngZ + 0.05 ) &&
-	   (mTransform.scaleX >= mAnimate.destScaleX - 0.00005 &&
-	    mTransform.scaleX <= mAnimate.destScaleX + 0.00005 ) &&
-	   (mTransform.scaleY >= mAnimate.destScaleY - 0.00005 &&
-	    mTransform.scaleY <= mAnimate.destScaleY + 0.00005 ))))
-    {
-	damageArea ();
-	mIsAnimating = TRUE;
-    }
-    else if (mIsAnimating) /* We're done animating now, and we were animating */
-    {
-	if (handleWindowInputInfo ())
-	    adjustIPW ();
-	mIsAnimating = FALSE;
-    }
-
-    return status;
-}
-
-/* Paint the window axis help onto the screen */
-bool
-FWScreen::glPaintOutput (const GLScreenPaintAttrib &attrib,
-			 const GLMatrix		   &transform,
-			 const CompRegion	   &region,
-			 CompOutput		   *output,
-			 unsigned int		   mask)
-{
-    GLMatrix zTransform (transform);
-
-    if (!mTransformedWindows.empty ())
-	mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK;
-
-    bool status = gScreen->glPaintOutput (attrib, transform, region, output, mask);
-
-    if (mAxisHelp && mHoverWindow)
-    {
-	int j;
-	float x = WIN_REAL_X(mHoverWindow) + WIN_REAL_W(mHoverWindow)/2.0;
-	float y = WIN_REAL_Y(mHoverWindow) + WIN_REAL_H(mHoverWindow)/2.0;
-
-	FREEWINS_WINDOW (mHoverWindow);
-
-	float zRad = fww->mRadius * (optionGetTdPercent () / 100);
-
-	bool wasCulled = glIsEnabled (GL_CULL_FACE);
-
-	zTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
-
-	glPushMatrix ();
-	glLoadMatrixf (zTransform.getMatrix ());
-
-	if (wasCulled)
-	    glDisable (GL_CULL_FACE);
-
-	if (optionGetShowCircle () && optionGetRotationAxis () == RotationAxisAlwaysCentre)
-	{
-	    glColor4usv  (optionGetCircleColor ());
-	    glEnable (GL_BLEND);
-
-	    glBegin (GL_POLYGON);
-	    for (j = 0; j < 360; j += 10)
-		glVertex3f ( x + zRad * cos(D2R(j)), y + zRad * sin(D2R(j)), 0.0 );
-	    glEnd ();
-
-	    glDisable (GL_BLEND);
-	    glColor4usv  (optionGetLineColor ());
-	    glLineWidth (3.0);
-
-	    glBegin (GL_LINE_LOOP);
-	    for (j = 360; j >= 0; j -= 10)
-		glVertex3f ( x + zRad * cos(D2R(j)), y + zRad * sin(D2R(j)), 0.0 );
-	    glEnd ();
-
-	    glBegin (GL_LINE_LOOP);
-	    for (j = 360; j >= 0; j -= 10)
-		glVertex3f( x + fww->mRadius * cos(D2R(j)), y + fww->mRadius * sin(D2R(j)), 0.0 );
-	    glEnd ();
-
-	}
-
-	/* Draw the 'gizmo' */
-	if (optionGetShowGizmo ())
-	{
-	    glPushMatrix ();
-
-	    glTranslatef (x, y, 0.0);
-
-	    glScalef (zRad, zRad, zRad / (float)screen->width ());
-
-	    glRotatef (fww->mTransform.angX, 1.0f, 0.0f, 0.0f);
-	    glRotatef (fww->mTransform.angY, 0.0f, 1.0f, 0.0f);
-	    glRotatef (fww->mTransform.angZ, 0.0f, 0.0f, 1.0f);
-
-	    glLineWidth (4.0f);
-
-	    for (int i = 0; i < 3; i++)
-	    {
-		glPushMatrix ();
-		glColor4f (1.0 * (i==0), 1.0 * (i==1), 1.0 * (i==2), 1.0);
-		glRotatef (90.0, 1.0 * (i==0), 1.0 * (i==1), 1.0 * (i==2));
-
-		glBegin (GL_LINE_LOOP);
-		for (j=360; j>=0; j -= 10)
-		    glVertex3f ( cos (D2R (j)), sin (D2R (j)), 0.0 );
-		glEnd ();
-		glPopMatrix ();
-	    }
-
-	    glPopMatrix ();
-	    glColor4usv (defaultColor);
-	}
-
-	/* Draw the bounding box */
-	if (optionGetShowRegion ())
-	{
-	    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-	    glEnable (GL_BLEND);
-	    glColor4us (0x2fff, 0x2fff, 0x4fff, 0x4fff);
-	    glRecti (fww->mInputRect.x1 (), fww->mInputRect.y1 (), fww->mInputRect.x2 (), fww->mInputRect.y2 ());
-	    glColor4us (0x2fff, 0x2fff, 0x4fff, 0x9fff);
-	    glBegin (GL_LINE_LOOP);
-	    glVertex2i (fww->mInputRect.x1 (), fww->mInputRect.y1 ());
-	    glVertex2i (fww->mInputRect.x2 (), fww->mInputRect.y1 ());
-	    glVertex2i (fww->mInputRect.x1 (), fww->mInputRect.y2 ());
-	    glVertex2i (fww->mInputRect.x2 (), fww->mInputRect.y2 ());
-	    glEnd ();
-	    glColor4usv (defaultColor);
-	    glDisable (GL_BLEND);
-	    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
-	}
-
-	if (optionGetShowCross ())
-	{
-
-	    glColor4usv  (optionGetCrossLineColor ());
-	    glBegin(GL_LINES);
-	    glVertex3f(x, y - (WIN_REAL_H (mHoverWindow) / 2), 0.0f);
-	    glVertex3f(x, y + (WIN_REAL_H (mHoverWindow) / 2), 0.0f);
-	    glEnd ();
-
-	    glBegin(GL_LINES);
-	    glVertex3f(x - (WIN_REAL_W (mHoverWindow) / 2), y, 0.0f);
-	    glVertex3f(x + (WIN_REAL_W (mHoverWindow) / 2), y, 0.0f);
-	    glEnd ();
-
-	    /* Move to our first corner (TopLeft)  */
-	    if (fww->mInput)
-	    {
-		glBegin(GL_LINES);
-		glVertex3f(fww->mOutput.shapex1, fww->mOutput.shapey1, 0.0f);
-		glVertex3f(fww->mOutput.shapex2, fww->mOutput.shapey2, 0.0f);
-		glEnd ();
-
-		glBegin(GL_LINES);
-		glVertex3f(fww->mOutput.shapex2, fww->mOutput.shapey2, 0.0f);
-		glVertex3f(fww->mOutput.shapex4, fww->mOutput.shapey4, 0.0f);
-		glEnd ();
-
-		glBegin(GL_LINES);
-		glVertex3f(fww->mOutput.shapex4, fww->mOutput.shapey4, 0.0f);
-		glVertex3f(fww->mOutput.shapex3, fww->mOutput.shapey3, 0.0f);
-		glEnd ();
-
-		glBegin(GL_LINES);
-		glVertex3f(fww->mOutput.shapex3, fww->mOutput.shapey3, 0.0f);
-		glVertex3f(fww->mOutput.shapex1, fww->mOutput.shapey1, 0.0f);
-		glEnd ();
-	    }
-	}
-	if (wasCulled)
-	    glEnable(GL_CULL_FACE);
-
-	glColor4usv(defaultColor);
-	glPopMatrix ();
-    }
-
-    return status;
-}
-
-void
-FWScreen::donePaint ()
-{
-
-    if (mAxisHelp && mHoverWindow)
-    {
-	FREEWINS_WINDOW (mHoverWindow);
-
-	REGION region;
-
-	region.rects = &region.extents;
-	region.numRects = region.size = 1;
-
-	region.extents.x1 = MIN (WIN_REAL_X (mHoverWindow),
-				 WIN_REAL_X (mHoverWindow)
-				 + WIN_REAL_W (mHoverWindow)
-				 / 2.0f - fww->mRadius);
-	region.extents.x2 = MAX (WIN_REAL_X (mHoverWindow),
-				 WIN_REAL_X (mHoverWindow)
-				 + WIN_REAL_W (mHoverWindow)
-				 / 2.0f + fww->mRadius);
-
-	region.extents.y1 = MIN (WIN_REAL_Y (mHoverWindow),
-				 WIN_REAL_Y (mHoverWindow)
-				 + WIN_REAL_H (mHoverWindow)
-				 / 2.0f - fww->mRadius);
-	region.extents.y2 = MAX (WIN_REAL_Y (mHoverWindow),
-				 WIN_REAL_Y (mHoverWindow)
-				 + WIN_REAL_H (mHoverWindow)
-				 / 2.0f + fww->mRadius);
-
-	CompRegion damageRegion (region.extents.x1, region.extents.y1, region.extents.x2 - region.extents.x1, region.extents.y2 - region.extents.y1);
-
-	cScreen->damageRegion (damageRegion);
-    }
-
-    cScreen->donePaint ();
-}
-
-/* Damage the Window Rect */
-bool
-FWWindow::damageRect (bool initial,
-		      const CompRect &rect)
-{
-    FREEWINS_SCREEN(screen);
-
-    if (mTransformed)
-	damageArea ();
-
-    /**
-     * Special situations where we must damage the screen
-     * i.e when we are playing with windows and wobbly is
-     * enabled
-     */
-
-    if ((mGrab == grabMove && !fws->optionGetImmediateMoves ())
-	|| (mIsAnimating || window->grabbed ()))
-	fws->cScreen->damageScreen ();
-
-    return cWindow->damageRect (initial, rect);
-}

=== removed file 'plugins/freewins/src/util.cpp'
--- plugins/freewins/src/util.cpp	2013-02-20 14:24:30 +0000
+++ plugins/freewins/src/util.cpp	1970-01-01 00:00:00 +0000
@@ -1,526 +0,0 @@
-/**
- * Compiz Fusion Freewins plugin
- *
- * util.cpp
- *
- * Copyright (C) 2007  Rodolfo Granata <[e-mail]>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * Author(s):
- * Rodolfo Granata <[e-mail]>
- * Sam Spilsbury <[e-mail]>
- *
- * Button binding support and Reset added by:
- * enigma_0Z <[e-mail]>
- *
- * Most of the input handling here is based on
- * the shelf plugin by
- *        : Kristian Lyngstøl <[e-mail]>
- *        : Danny Baumann <[e-mail]>
- *
- * Description:
- *
- * This plugin allows you to freely transform the texture of a window,
- * whether that be rotation or scaling to make better use of screen space
- * or just as a toy.
- *
- * Todo:
- *  - Fully implement an input redirection system by
- *    finding an inverse matrix, multiplying by it,
- *    translating to the actual window co-ords and
- *    XSendEvent() the co-ords to the actual window.
- *  - Code could be cleaner
- *  - Add timestep and speed options to animation
- *  - Add window hover-over info via paintOutput : i.e
- *    - Resize borders
- *    - 'Reset' Button
- *    - 'Scale' Button
- *    - 'Rotate' Button
- */
-
-#include "freewins.h"
-
-
-/* ------ Utility Functions ---------------------------------------------*/
-
-/* Rotate and project individual vectors */
-void
-FWScreen::rotateProjectVector (GLVector &vector,
-			       GLMatrix &transform,
-			       GLdouble *resultX,
-			       GLdouble *resultY,
-			       GLdouble *resultZ)
-{
-    vector = transform * vector;
-
-    GLint viewport[4];		// Viewport
-    GLdouble modelview[16];	// Modelview Matrix
-    GLdouble projection[16];	// Projection Matrix
-
-    glGetIntegerv (GL_VIEWPORT, viewport);
-    glGetDoublev (GL_MODELVIEW_MATRIX, modelview);
-    glGetDoublev (GL_PROJECTION_MATRIX, projection);
-
-    gluProject (vector[GLVector::x], vector[GLVector::y], vector[GLVector::z],
-		modelview, projection, viewport,
-		resultX, resultY, resultZ);
-
-    /* Y must be negated */
-    *resultY = screen->height () - *resultY;
-}
-
-/* Scales z by 0 and does perspective distortion so that it
- * looks the same wherever on the screen
- *
- * This code taken from animation.c,
- * Copyright (c) 2006 Erkin Bahceci
- */
-void
-FWScreen::perspectiveDistortAndResetZ (GLMatrix &transform)
-{
-    float v = -1.0 / ::screen->width ();
-    /*
-      This does
-      transform = M * transform, where M is
-      1, 0, 0, 0,
-      0, 1, 0, 0,
-      0, 0, 0, v,
-      0, 0, 0, 1
-    */
-
-    transform[8] = v * transform[12];
-    transform[9] = v * transform[13];
-    transform[10] = v * transform[14];
-    transform[11] = v * transform[15];
-}
-
-void
-FWScreen::modifyMatrix  (GLMatrix &transform,
-			 float angX, float angY, float angZ,
-			 float tX, float tY, float tZ,
-			 float scX, float scY, float scZ,
-			 float adjustX, float adjustY, bool paint)
-{
-    /* Create our transformation Matrix */
-    transform.translate (tX, tY, 0.0);
-    if (paint)
-	perspectiveDistortAndResetZ (transform);
-    else
-	transform.scale (1.0f, 1.0f, 1.0f / screen->width ());
-    transform.rotate (angX, 1.0f, 0.0f, 0.0f);
-    transform.rotate (angY, 0.0f, 1.0f, 0.0f);
-    transform.rotate (angZ, 0.0f, 0.0f, 1.0f);
-    transform.scale (scX, 1.0f, 0.0f);
-    transform.scale (1.0f, scY, 0.0f);
-    transform.translate (-(tX), -(tY), 0.0f);
-}
-
-/*
-static float det3(float m00, float m01, float m02,
-		 float m10, float m11, float m12,
-		 float m20, float m21, float m22)
-{
-    float ret = 0.0;
-
-    ret += m00 * m11 * m22 - m21 * m12 * m00;
-    ret += m01 * m12 * m20 - m22 * m10 * m01;
-    ret += m02 * m10 * m21 - m20 * m11 * m02;
-
-    return ret;
-}
-
-static void FWFindInverseMatrix(CompTransform *m, CompTransform *r)
-{
-    float *mm = m->m;
-    float d, c[16];
-
-    d = mm[0] * det3(mm[5], mm[6], mm[7],
-			mm[9], mm[10], mm[11],
-			 mm[13], mm[14], mm[15]) -
-
-	  mm[1] * det3(mm[4], mm[6], mm[7],
-			mm[8], mm[10], mm[11],
-			 mm[12], mm[14], mm[15]) +
-
-	  mm[2] * det3(mm[4], mm[5], mm[7],
-			mm[8], mm[9], mm[11],
-			 mm[12], mm[13], mm[15]) -
-
-	  mm[3] * det3(mm[4], mm[5], mm[6],
-			mm[8], mm[9], mm[10],
-			 mm[12], mm[13], mm[14]);
-
-    c[0] = det3(mm[5], mm[6], mm[7],
-		  mm[9], mm[10], mm[11],
-		  mm[13], mm[14], mm[15]);
-    c[1] = -det3(mm[4], mm[6], mm[7],
-		  mm[8], mm[10], mm[11],
-		  mm[12], mm[14], mm[15]);
-    c[2] = det3(mm[4], mm[5], mm[7],
-		  mm[8], mm[9], mm[11],
-		  mm[12], mm[13], mm[15]);
-    c[3] = -det3(mm[4], mm[5], mm[6],
-		  mm[8], mm[9], mm[10],
-		  mm[12], mm[13], mm[14]);
-
-    c[4] = -det3(mm[1], mm[2], mm[3],
-		  mm[9], mm[10], mm[11],
-		  mm[13], mm[14], mm[15]);
-    c[5] = det3(mm[0], mm[2], mm[3],
-		  mm[8], mm[10], mm[11],
-		  mm[12], mm[14], mm[15]);
-    c[6] = -det3(mm[0], mm[1], mm[3],
-		  mm[8], mm[9], mm[11],
-		  mm[12], mm[13], mm[15]);
-    c[7] = det3(mm[0], mm[1], mm[2],
-		  mm[8], mm[9], mm[10],
-		  mm[12], mm[13], mm[14]);
-
-    c[8] = det3(mm[1], mm[2], mm[3],
-		  mm[5], mm[6], mm[7],
-		  mm[13], mm[14], mm[15]);
-    c[9] = -det3(mm[0], mm[2], mm[3],
-		  mm[4], mm[6], mm[7],
-		  mm[12], mm[14], mm[15]);
-    c[10] = det3(mm[0], mm[1], mm[3],
-		  mm[4], mm[5], mm[7],
-		  mm[12], mm[13], mm[15]);
-    c[11] = -det3(mm[0], mm[1], mm[2],
-		  mm[4], mm[5], mm[6],
-		  mm[12], mm[13], mm[14]);
-
-    c[12] = -det3(mm[1], mm[2], mm[3],
-		  mm[5], mm[6], mm[7],
-		  mm[9], mm[10], mm[11]);
-    c[13] = det3(mm[0], mm[2], mm[3],
-		  mm[4], mm[6], mm[7],
-		  mm[8], mm[10], mm[11]);
-    c[14] = -det3(mm[0], mm[1], mm[3],
-		  mm[4], mm[5], mm[7],
-		  mm[8], mm[9], mm[11]);
-    c[15] = det3(mm[0], mm[1], mm[2],
-		  mm[4], mm[5], mm[6],
-		  mm[8], mm[9], mm[10]);
-
-    r->m[0] = c[0] / d;
-    r->m[1] = c[4] / d;
-    r->m[2] = c[8] / d;
-    r->m[3] = c[12] / d;
-
-    r->m[4] = c[1] / d;
-    r->m[5] = c[5] / d;
-    r->m[6] = c[9] / d;
-    r->m[7] = c[13] / d;
-
-    r->m[8] = c[2] / d;
-    r->m[9] = c[6] / d;
-    r->m[10] = c[10] / d;
-    r->m[11] = c[14] / d;
-
-    r->m[12] = c[3] / d;
-    r->m[13] = c[7] / d;
-    r->m[14] = c[11] / d;
-    r->m[15] = c[15] / d;
-
-    return;
-}
-*/
-
-/* Create a rect from 4 screen points */
-CompRect
-FWScreen::createSizedRect (float xScreen1,
-			   float xScreen2,
-			   float xScreen3,
-			   float xScreen4,
-			   float yScreen1,
-			   float yScreen2,
-			   float yScreen3,
-			   float yScreen4)
-{
-    /* Left most point */
-    float leftmost = xScreen1;
-
-    if (xScreen2 <= leftmost)
-	leftmost = xScreen2;
-
-    if (xScreen3 <= leftmost)
-	leftmost = xScreen3;
-
-    if (xScreen4 <= leftmost)
-	leftmost = xScreen4;
-
-    /* Right most point */
-    float rightmost = xScreen1;
-
-    if (xScreen2 >= rightmost)
-	rightmost = xScreen2;
-
-    if (xScreen3 >= rightmost)
-	rightmost = xScreen3;
-
-    if (xScreen4 >= rightmost)
-	rightmost = xScreen4;
-
-    /* Top most point */
-    float topmost = yScreen1;
-
-    if (yScreen2 <= topmost)
-	topmost = yScreen2;
-
-    if (yScreen3 <= topmost)
-	topmost = yScreen3;
-
-    if (yScreen4 <= topmost)
-	topmost = yScreen4;
-
-    /* Bottom most point */
-    float bottommost = yScreen1;
-
-    if (yScreen2 >= bottommost)
-	bottommost = yScreen2;
-
-    if (yScreen3 >= bottommost)
-	bottommost = yScreen3;
-
-    if (yScreen4 >= bottommost)
-	bottommost = yScreen4;
-/*
-    Box rect;
-    rect.x1 = leftmost;
-    rect.x2 = rightmost;
-    rect.y1 = topmost;
-    rect.y2 = bottommost;
-*/
-    return CompRect (leftmost, topmost, rightmost - leftmost, bottommost - topmost);
-}
-
-CompRect
-FWWindow::calculateWindowRect (GLVector c1,
-			       GLVector c2,
-			       GLVector c3,
-			       GLVector c4)
-{
-    FREEWINS_SCREEN (screen);
-
-    GLMatrix transform;
-    GLdouble xScreen1 = 0.0f, yScreen1 = 0.0f, zScreen1 = 0.0f;
-    GLdouble xScreen2 = 0.0f, yScreen2 = 0.0f, zScreen2 = 0.0f;
-    GLdouble xScreen3 = 0.0f, yScreen3 = 0.0f, zScreen3 = 0.0f;
-    GLdouble xScreen4 = 0.0f, yScreen4 = 0.0f, zScreen4 = 0.0f;
-
-    transform.reset ();
-    fws->modifyMatrix (transform,
-		       mTransform.angX,
-		       mTransform.angY,
-		       mTransform.angZ,
-		       mIMidX, mIMidY, 0.0f,
-		       mTransform.scaleX,
-		       mTransform.scaleY, 0.0f, 0.0f, 0.0f, false);
-
-    fws->rotateProjectVector(c1, transform, &xScreen1, &yScreen1, &zScreen1);
-    fws->rotateProjectVector(c2, transform, &xScreen2, &yScreen2, &zScreen2);
-    fws->rotateProjectVector(c3, transform, &xScreen3, &yScreen3, &zScreen3);
-    fws->rotateProjectVector(c4, transform, &xScreen4, &yScreen4, &zScreen4);
-
-    /* Save the non-rectangular points so that we can shape the rectangular IPW */
-
-    mOutput.shapex1 = xScreen1;
-    mOutput.shapex2 = xScreen2;
-    mOutput.shapex3 = xScreen3;
-    mOutput.shapex4 = xScreen4;
-    mOutput.shapey1 = yScreen1;
-    mOutput.shapey2 = yScreen2;
-    mOutput.shapey3 = yScreen3;
-    mOutput.shapey4 = yScreen4;
-
-
-    return fws->createSizedRect(xScreen1, xScreen2, xScreen3, xScreen4,
-				yScreen1, yScreen2, yScreen3, yScreen4);
-}
-
-void
-FWWindow::calculateOutputRect ()
-{
-    GLVector corner1 = GLVector (WIN_OUTPUT_X (window), WIN_OUTPUT_Y (window), 1.0f, 1.0f);
-    GLVector corner2 = GLVector (WIN_OUTPUT_X (window) + WIN_OUTPUT_W (window), WIN_OUTPUT_Y (window), 1.0f, 1.0f);
-    GLVector corner3 = GLVector (WIN_OUTPUT_X (window), WIN_OUTPUT_Y (window) + WIN_OUTPUT_H (window), 1.0f, 1.0f);
-    GLVector corner4 = GLVector (WIN_OUTPUT_X (window) + WIN_OUTPUT_W (window), WIN_OUTPUT_Y (window) + WIN_OUTPUT_H (window), 1.0f, 1.0f);
-
-    mOutputRect = calculateWindowRect (corner1, corner2, corner3, corner4);
-}
-
-void
-FWWindow::calculateInputRect ()
-{
-    GLVector corner1 = GLVector (WIN_REAL_X (window), WIN_REAL_Y (window), 1.0f, 1.0f);
-    GLVector corner2 = GLVector (WIN_REAL_X (window) + WIN_REAL_W (window), WIN_REAL_Y (window), 1.0f, 1.0f);
-    GLVector corner3 = GLVector (WIN_REAL_X (window), WIN_REAL_Y (window) + WIN_REAL_H (window), 1.0f, 1.0f);
-    GLVector corner4 = GLVector (WIN_REAL_X (window) + WIN_REAL_W (window), WIN_REAL_Y (window) + WIN_REAL_H (window), 1.0f, 1.0f);
-
-    mInputRect = calculateWindowRect (corner1, corner2, corner3, corner4);
-}
-
-void
-FWWindow::calculateInputOrigin (float x, float y)
-{
-    mIMidX = x;
-    mIMidY = y;
-}
-
-void
-FWWindow::calculateOutputOrigin (float x, float y)
-{
-    float dx, dy;
-
-    dx = x - WIN_OUTPUT_X (window);
-    dy = y - WIN_OUTPUT_Y (window);
-
-    mOMidX = WIN_OUTPUT_X (window) + dx * mTransform.scaleX;
-    mOMidY = WIN_OUTPUT_Y (window) + dy * mTransform.scaleY;
-}
-
-/* Change angles more than 360 into angles out of 360 */
-/*static int FWMakeIntoOutOfThreeSixty (int value)
-{
-    while (value > 0)
-    {
-	value -= 360;
-    }
-
-    if (value < 0)
-	value += 360;
-
-    return value;
-}*/
-
-/* Determine if we clicked in the z-axis region */
-void
-FWWindow::determineZAxisClick (int px,
-			       int py,
-			       bool motion)
-{
-    bool directionChange = FALSE;
-
-    if (!mCan2D && motion)
-    {
-
-	static int steps;
-
-	/* Check if we are going in a particular 3D direction
-	 * because if we are going left/right and we suddenly
-	 * change to 2D mode this would not be expected behaviour.
-	 * It is only if we have a change in direction that we want
-	 * to change to 2D rotation.
-	 */
-
-	Direction direction, oldDirection = LeftRight;
-
-	static int ddx, ddy;
-
-	unsigned int dx = pointerX - lastPointerX;
-	unsigned int dy = pointerY - lastPointerY;
-
-	ddx += dx;
-	ddy += dy;
-
-	if (steps >= 10)
-	{
-	    if (ddx > ddy)
-		direction = LeftRight;
-	    else
-		direction = UpDown;
-
-	    if (direction != oldDirection)
-		directionChange = TRUE;
-
-	    direction = oldDirection;
-	}
-
-	steps++;
-
-    }
-    else
-	directionChange = TRUE;
-
-    if (directionChange)
-    {
-	float clickRadiusFromCenter;
-
-	int x = (WIN_REAL_X(window) + WIN_REAL_W(window)/2.0);
-	int y = (WIN_REAL_Y(window) + WIN_REAL_H(window)/2.0);
-
-	clickRadiusFromCenter = sqrt(pow((x - px), 2) + pow((y - py), 2));
-
-	if (clickRadiusFromCenter > mRadius * (FWScreen::get (screen)->optionGetTdPercent () / 100))
-	{
-	    mCan2D = TRUE;
-	    mCan3D = FALSE;
-	}
-	else
-	{
-	    mCan2D = FALSE;
-	    mCan3D = TRUE;
-	}
-    }
-}
-
-/* Check to see if we can shape a window */
-bool
-FWWindow::canShape ()
-{
-    FREEWINS_SCREEN (screen);
-
-    if (!fws->optionGetDoShapeInput ())
-	return FALSE;
-    
-    if (!screen->XShape ())
-	return FALSE;
-    
-    if (!fws->optionGetShapeWindowTypes ().evaluate (window))
-	return FALSE;
-    
-    return TRUE;
-}
-
-/* Checks if w is a ipw and returns the real window */
-CompWindow *
-FWScreen::getRealWindow (CompWindow *w)
-{
-    FWWindowInputInfo *info;
-
-    foreach (info, mTransformedWindows)
-    {
-	if (w->id () == info->ipw)
-	    return info->w;
-    }
-
-    return NULL;