path: root/src/tiles.h

/*
 * Compiz Tiles Plugin
 *
 * tiles.h
 *
 * Copyright (c) 2011 Sam Spilsbury <smspillaz@gmail.com>
 *
 * 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 3
 * 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.
 */

#include <core/core.h>
#include <composite/composite.h>
#include <opengl/opengl.h>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <unordered_map>
#include <hash_fun.h>

#include "tiles_options.h"

class TileLayer;
typedef boost::shared_ptr <TileLayer> TileLayerPtr;

namespace RectMap
{
    class Hash {
	public:
	bool operator() (const CompRect &r) const
	{
	    std::hash <int> h;

	    return h (r.area ());
	}
    };

    class Predicate {
	public:
	bool operator() (const CompRect &a, const CompRect &b) const
	{
	    return (a == b);
	}
    };

    typedef std::unordered_map<CompRect, CompRect, Hash, Predicate> Map;
}

class PrivateTile
{
    public:

	TileLayerPtr mParent;
	CompRect   mRect;
	CompWindow *mWindow;
	CompWindow::Geometry mSaveGeometry;
	unsigned int         mSaveMask;
	CompPoint            mDragBuffer;
	float      mProgress;
};

class Tile :
    public boost::enable_shared_from_this<Tile>
{
    public:

	Tile (TileLayerPtr parent);
	~Tile ();

	/* Target size */
	CompRect     rect ();
	CompWindow * window ();
	GLVector     scale ();

	/* Returns false if window cannot be put
	 * in this tile's allocation */
	bool allocateWindow (CompWindow *);

	/* setTargetSize will allocate a new target size
	 * for this tile, which will be animated to, while
	 * lockTargetSize actually resizes the window to that
	 * size */
	bool setTargetSize (CompRect &);
	void lockTargetSize ();

	void resized (CompRect &);

	bool animate (unsigned int ms);
	void damage ();

	void grab ();
	bool drag (CompPoint &p);
	void ungrab ();

	typedef boost::shared_ptr<Tile> Ptr;
    private:

	PrivateTile *priv;
};

class PrivateTileLayer
{
    public:

    void pushSpace (CompRect r);
    void popSpaces ();

    std::vector<Tile::Ptr> mTiles;
    CompRegion             mDropZones;
    CompOutput             *mOutput;
    RectMap::Map           mPushedSpaces;
    CompPoint              mLastPointer;
};

class TileLayer :
    public boost::enable_shared_from_this <TileLayer>
{
    public:

	TileLayer (CompOutput *output);
	virtual ~TileLayer ();

	const std::vector<Tile::Ptr> & tiles ();

	void handleWindowResize (CompWindow *);
	void handleWindowGrabbed (CompWindow *w);
	void handleWindowGrabMovement (CompWindow *w, CompPoint &p);
	void handleWindowUngrabbed (CompWindow *w);

	bool addWindow (CompWindow *w, CompRect &);
	void removeWindow (CompWindow *w);
	void paintOutline (const GLMatrix &);

	bool animate (unsigned int ms);
	void damage ();

	typedef TileLayerPtr Ptr;

    protected:

	bool tilesToRegion (std::vector <Tile::Ptr> tiles,
			    CompRegion tilesRegion,
			    CompRegion nextRegion);

    private:

	PrivateTileLayer *priv;
};

class PrivateTilesWindow
{
    public:
	CompWindow      *window;
	CompositeWindow *cWindow;
	GLWindow        *gWindow;

	Tile::Ptr       mTile;
};

class TilesWindow :
    public PluginClassHandler <TilesWindow, CompWindow>,
    public WindowInterface,
    public CompositeWindowInterface,
    public GLWindowInterface
{
    public:

	TilesWindow (CompWindow *w);
	~TilesWindow ();

	void grabNotify (int x, int y, unsigned int state, unsigned int mask);
	void ungrabNotify ();

	void moveNotify (int dx, int dy, bool immediate);
	void validateResizeRequest (unsigned int &mask,
				    XWindowChanges *xwc,
				    unsigned int source);
	void resizeNotify (int dx, int dy, int dwidth, int dheight);

	bool glPaint (const GLWindowPaintAttrib &attrib, const GLMatrix &matrix,
		      const CompRegion &region, unsigned int mask);
	bool damageRect (bool initial, const CompRect &rect);

	bool animate (unsigned int ms);

	void damage ();

	CompWindow * window () { return priv->window; } // XXX

    private:

	PrivateTilesWindow *priv;
};

class PrivateTilesScreen
{
    public:

	CompositeScreen *cScreen;
	GLScreen        *gScreen;

	std::vector <TilesWindow *> mDraggedWindows;
	std::vector <TileLayer::Ptr> mTileLayers;
};

class TilesScreen :
    public PluginClassHandler <TilesScreen, CompScreen>,
    public ScreenInterface,
    public CompositeScreenInterface,
    public GLScreenInterface,
    public TilesOptions
{
    public:

	TilesScreen (CompScreen *);
	~TilesScreen ();

	void preparePaint (int);
	bool glPaintOutput (const GLScreenPaintAttrib &attrib, const GLMatrix &matrix,
			    const CompRegion &region, CompOutput *output, unsigned int mask);
	void donePaint ();

	void addGrabbedWindow (TilesWindow *tw);
	void removeGrabbedWindow (TilesWindow *tw);
	void dragGrabbedWindow (TilesWindow *tw, CompPoint pointer);
	bool grabbedWindows ();

    private:

	PrivateTilesScreen *priv;
};

class TilesPluginVTable :
    public CompPlugin::VTableForScreenAndWindow<TilesScreen, TilesWindow>
{
    public:

	bool init ();
};