barrier/lib/synergy/CScreen.h

/*
 * synergy -- mouse and keyboard sharing utility
 * Copyright (C) 2002 Chris Schoeneman
 * 
 * This package is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * found in the file COPYING that should have accompanied this file.
 * 
 * This package 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.
 */

#ifndef CSCREEN_H
#define CSCREEN_H

#include "IScreen.h"
#include "ClipboardTypes.h"
#include "KeyTypes.h"
#include "MouseTypes.h"
#include "OptionTypes.h"

class IClipboard;
class IPlatformScreen;

//! Platform independent screen
/*!
This is a platform independent screen.  It can work as either a
primary or secondary screen.
*/
class CScreen : public IScreen {
public:
	CScreen(IPlatformScreen* platformScreen);
	virtual ~CScreen();

	//! @name manipulators
	//@{

	//! Activate screen
	/*!
	Activate the screen, preparing it to report system and user events.
	For a secondary screen it also means disabling the screen saver if
	synchronizing it and preparing to synthesize events.
	*/
	void				enable();

	//! Deactivate screen
	/*!
	Undoes the operations in activate() and events are no longer
	reported.  It also releases keys that are logically pressed.
	*/
	void				disable();

	//! Enter screen
	/*!
	Called when the user navigates to this screen.  \p toggleMask has the
	toggle keys that should be turned on on the secondary screen.
	*/
	void				enter(KeyModifierMask toggleMask);

	//! Leave screen
	/*!
	Called when the user navigates off this screen.
	*/
	bool				leave();

	//! Update configuration
	/*!
	This is called when the configuration has changed.  \c activeSides
	is a bitmask of EDirectionMask indicating which sides of the
	primary screen are linked to clients.
	*/
	void				reconfigure(UInt32 activeSides);

	//! Warp cursor
	/*!
	Warps the cursor to the absolute coordinates \c x,y.  Also
	discards input events up to and including the warp before
	returning.
	*/
	void				warpCursor(SInt32 x, SInt32 y);

	//! Set clipboard
	/*!
	Sets the system's clipboard contents.  This is usually called
	soon after an enter().
	*/
	void				setClipboard(ClipboardID, const IClipboard*);

	//! Grab clipboard
	/*!
	Grabs (i.e. take ownership of) the system clipboard.
	*/
	void				grabClipboard(ClipboardID);

	//! Activate/deactivate screen saver
	/*!
	Forcibly activates the screen saver if \c activate is true otherwise
	forcibly deactivates it.
	*/
	void				screensaver(bool activate);

	//! Notify of key press
	/*!
	Synthesize key events to generate a press of key \c id.  If possible
	match the given modifier mask.  The KeyButton identifies the physical
	key on the server that generated this key down.  The client must
	ensure that a key up or key repeat that uses the same KeyButton will
	synthesize an up or repeat for the same client key synthesized by
	keyDown().
	*/
	void				keyDown(KeyID id, KeyModifierMask, KeyButton);

	//! Notify of key repeat
	/*!
	Synthesize key events to generate a press and release of key \c id
	\c count times.  If possible match the given modifier mask.
	*/
	void				keyRepeat(KeyID id, KeyModifierMask,
							SInt32 count, KeyButton);

	//! Notify of key release
	/*!
	Synthesize key events to generate a release of key \c id.  If possible
	match the given modifier mask.
	*/
	void				keyUp(KeyID id, KeyModifierMask, KeyButton);

	//! Notify of mouse press
	/*!
	Synthesize mouse events to generate a press of mouse button \c id.
	*/
	void				mouseDown(ButtonID id);

	//! Notify of mouse release
	/*!
	Synthesize mouse events to generate a release of mouse button \c id.
	*/
	void				mouseUp(ButtonID id);

	//! Notify of mouse motion
	/*!
	Synthesize mouse events to generate mouse motion to the absolute
	screen position \c xAbs,yAbs.
	*/
	void				mouseMove(SInt32 xAbs, SInt32 yAbs);

	//! Notify of mouse wheel motion
	/*!
	Synthesize mouse events to generate mouse wheel motion of \c delta.
	\c delta is positive for motion away from the user and negative for
	motion towards the user.  Each wheel click should generate a delta
	of +/-120.
	*/
	void				mouseWheel(SInt32 delta);

	//! Notify of options changes
	/*!
	Resets all options to their default values.
	*/
	void				resetOptions();

	//! Notify of options changes
	/*!
	Set options to given values.  Ignores unknown options and doesn't
	modify options that aren't given in \c options.
	*/
	void				setOptions(const COptionsList& options);

	//! Set clipboard sequence number
	/*!
	Sets the sequence number to use in subsequent clipboard events.
	*/
	void				setSequenceNumber(UInt32);

	//@}
	//! @name accessors
	//@{

	//! Test if cursor on screen
	/*!
	Returns true iff the cursor is on the screen.
	*/
	bool				isOnScreen() const;

	//! Get screen lock state
	/*!
	Returns true if there's any reason that the user should not be
	allowed to leave the screen (usually because a button or key is
	pressed).  If this method returns true it logs a message as to
	why at the CLOG_DEBUG level.
	*/
	bool				isLockedToScreen() const;

	//! Get jump zone size
	/*!
	Return the jump zone size, the size of the regions on the edges of
	the screen that cause the cursor to jump to another screen.
	*/
	SInt32				getJumpZoneSize() const;

	//! Get cursor center position
	/*!
	Return the cursor center position which is where we park the
	cursor to compute cursor motion deltas and should be far from
	the edges of the screen, typically the center.
	*/
	void				getCursorCenter(SInt32& x, SInt32& y) const;

	//! Get the active modifiers
	/*!
	Returns the modifiers that are currently active.
	*/
	KeyModifierMask		getActiveModifiers() const;

	//@}

	// IScreen overrides
	virtual void*		getEventTarget() const;
	virtual bool		getClipboard(ClipboardID id, IClipboard*) const;
	virtual void		getShape(SInt32& x, SInt32& y,
							SInt32& width, SInt32& height) const;
	virtual void		getCursorPos(SInt32& x, SInt32& y) const;

protected:
	void				enablePrimary();
	void				enableSecondary();
	void				disablePrimary();
	void				disableSecondary();

	void				enterPrimary();
	void				enterSecondary(KeyModifierMask toggleMask);
	void				leavePrimary();
	void				leaveSecondary();

private:
	void				releaseKeys();
	void				setToggleState(KeyModifierMask);
	KeyButton			isAnyKeyDown() const;

private:
	// our platform dependent screen
	IPlatformScreen*	m_screen;

	// true if screen is being used as a primary screen, false otherwise
	bool				m_isPrimary;

	// true if screen is enabled
	bool				m_enabled;

	// true if the cursor is on this screen
	bool				m_entered;

	// true if screen saver should be synchronized to server
	bool				m_screenSaverSync;

	// note toggle keys that toggles on up/down (false) or on
	// transition (true)
	KeyModifierMask		m_halfDuplex;

	// the toggle key state when this screen was last entered
	KeyModifierMask		m_toggleKeys;
};

#endif