cegui: headers diff between 0.7.2 and 0.7.3 versions

	CEGUIAnimationInstance.h	CEGUIAnimationInstance.h

	skipping to change at line 184	skipping to change at line 184
	void setSpeed(float speed);	void setSpeed(float speed);

	/*!	/*!
	\brief	\brief
	Retrieves current playback speed	Retrieves current playback speed
	*/	*/
	float getSpeed() const;	float getSpeed() const;

	/*!	/*!
	\brief	\brief

		Controls whether the next time step is skipped
		*/
		void setSkipNextStep(bool skip);

		/*!
		\brief
		Returns true if the next step is going to be skipped

		\par
		If it was skipped already, this returns false as step resets
		it to false after it skips one step.
		*/
		bool getSkipNextStep() const;

		/*!
		\brief
		Sets the max delta before step skipping occurs

		\param
		maxDelta delta in seconds, if this value is reached, the step is sk
		ipped
		(use -1.0f if you never want to skip - this is the default
		)

		\par
		If you want to ensure your animation is not skipped entirely after
		layouts
		are loaded or other time consuming operations are done, use this me
		thod.

		For example setMaxStepDeltaSkip(1.0f / 25.0f) ensures that if FPS d
		rops
		below 25, the animation just stops progressing and waits till FPS r
		aises.
		*/
		void setMaxStepDeltaSkip(float maxDelta);

		/*!
		\brief
		Gets the max delta before step skipping occurs
		*/
		float getMaxStepDeltaSkip() const;

		/*!
		\brief
		Sets the max delta before step clamping occurs

		\param
		maxDelta delta in seconds, if this value is reached, the step is cl
		amped.
		(use -1.0f if you never want to clamp - this is the defaul
		t)

		\par
		If you want to ensure the animation steps at most 1.0 / 60.0 second
		s at a timem
		you should call setMaxStepDeltaClamp(1.0f / 60.0f). This essentiall
		y slows
		the animation down in case the FPS drops below 60.
		*/
		void setMaxStepDeltaClamp(float maxDelta);

		/*!
		\brief
		Gets the max delta before step clamping occurs
		*/
		float getMaxStepDeltaClamp() const;

		/*!
		\brief
	Starts this animation instance - sets position to 0.0 and unpauses	Starts this animation instance - sets position to 0.0 and unpauses


		\param
		skipNextStep if true the next injected time pulse is skipped

	\par	\par
	This also causes base values to be purged!	This also causes base values to be purged!
	*/	*/

	void start();	void start(bool skipNextStep = true);

	/*!	/*!
	\brief	\brief
	Stops this animation instance - sets position to 0.0 and pauses	Stops this animation instance - sets position to 0.0 and pauses
	*/	*/
	void stop();	void stop();

	/*!	/*!
	\brief	\brief
	Pauses this animation instance - stops it from stepping forward	Pauses this animation instance - stops it from stepping forward
	*/	*/
	void pause();	void pause();

	/*!	/*!
	\brief	\brief
	Unpauses this animation instance - allows it to step forward again	Unpauses this animation instance - allows it to step forward again


		\param
		skipNextStep if true the next injected time pulse is skipped
	*/	*/

	void unpause();	void unpause(bool skipNextStep = true);

	/*!	/*!
	\brief	\brief
	Pauses the animation if it's running and unpauses it if it isn't	Pauses the animation if it's running and unpauses it if it isn't


		\param
		skipNextStep if true the next injected time pulse is skipped
		(only applies when unpausing!)
	*/	*/

	void togglePause();	void togglePause(bool skipNextStep = true);

	/*!	/*!
	\brief	\brief
	Returns true if this animation instance is currently unpaused,	Returns true if this animation instance is currently unpaused,
	if it is stepping forward.	if it is stepping forward.
	*/	*/
	bool isRunning() const;	bool isRunning() const;

	/*!	/*!
	\brief	\brief

	skipping to change at line 333	skipping to change at line 403
	* should always be higher or equal to 0.0 and lower or equal to durati on of	* should always be higher or equal to 0.0 and lower or equal to durati on of
	* animation definition	* animation definition
	*/	*/
	float d_position;	float d_position;
	//! playback speed, 1.0 means normal playback	//! playback speed, 1.0 means normal playback
	float d_speed;	float d_speed;
	//! needed for RM_Bounce mode, if true, we bounce backwards	//! needed for RM_Bounce mode, if true, we bounce backwards
	bool d_bounceBackwards;	bool d_bounceBackwards;
	//! true if this animation is unpaused	//! true if this animation is unpaused
	bool d_running;	bool d_running;

		//! skip next update (true if the next update should be skipped entirel
		y)
		bool d_skipNextStep;
		//! skip the update if the step is larger than this value
		float d_maxStepDeltaSkip;
		//! always clamp step delta to this value
		float d_maxStepDeltaClamp;

	typedef std::map<String, String> PropertyValueMap;	typedef std::map<String, String> PropertyValueMap;
	/** cached saved values, used for relative application method	/** cached saved values, used for relative application method
	* and keyframe property source, see Affector and KeyFrame classes	* and keyframe property source, see Affector and KeyFrame classes
	*/	*/
	PropertyValueMap d_savedPropertyValues;	PropertyValueMap d_savedPropertyValues;

	typedef std::vector<Event::Connection> ConnectionTracker;	typedef std::vector<Event::Connection> ConnectionTracker;
	//! tracks auto event connections we make.	//! tracks auto event connections we make.
	ConnectionTracker d_autoConnections;	ConnectionTracker d_autoConnections;

End of changes. 8 change blocks.
	3 lines changed or deleted	90 lines changed or added

	CEGUIAnimationManager.h	CEGUIAnimationManager.h

	skipping to change at line 94	skipping to change at line 94
	void addInterpolator(Interpolator* interpolator);	void addInterpolator(Interpolator* interpolator);

	/*!	/*!
	\brief	\brief
	Removes interpolator	Removes interpolator
	*/	*/
	void removeInterpolator(Interpolator* interpolator);	void removeInterpolator(Interpolator* interpolator);

	/*!	/*!
	\brief	\brief

	Retrieves interpolator by name	Retrieves interpolator by type
	*/	*/

	Interpolator* getInterpolator(const String& name) const;	Interpolator* getInterpolator(const String& type) const;

	/*!	/*!
	\brief	\brief
	Creates a new Animation definition	Creates a new Animation definition

	\see	\see
	Animation	Animation
	*/	*/
	Animation* createAnimation(const String& name);	Animation* createAnimation(const String& name);


End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	CEGUIScriptModule.h	CEGUIScriptModule.h

	skipping to change at line 229	skipping to change at line 229
	//! String that holds some id information about the module.	//! String that holds some id information about the module.
	String d_identifierString;	String d_identifierString;
	//! holds the default resource group ID for loading script files.	//! holds the default resource group ID for loading script files.
	static String d_defaultResourceGroup;	static String d_defaultResourceGroup;
	};	};

	/*!	/*!
	\brief	\brief
	Functor class used for binding named script functions to events	Functor class used for binding named script functions to events
	*/	*/

	class ScriptFunctor	class CEGUIEXPORT ScriptFunctor
	{	{
	public:	public:
	ScriptFunctor(const String& functionName) : scriptFunctionName(funct ionName) {}	ScriptFunctor(const String& functionName) : scriptFunctionName(funct ionName) {}
	ScriptFunctor(const ScriptFunctor& obj) : scriptFunctionName(obj.script FunctionName) {}	ScriptFunctor(const ScriptFunctor& obj) : scriptFunctionName(obj.script FunctionName) {}
	bool operator()(const EventArgs& e) const;	bool operator()(const EventArgs& e) const;

	private:	private:
	// no assignment possible	// no assignment possible
	ScriptFunctor& operator=(const ScriptFunctor& rhs);	ScriptFunctor& operator=(const ScriptFunctor& rhs);


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	CEGUIString.h	CEGUIString.h

	skipping to change at line 91	skipping to change at line 91
	mutable size_type d_encodeddatlen; //!< holds length of encoded data (in case it's smaller than buffer).	mutable size_type d_encodeddatlen; //!< holds length of encoded data (in case it's smaller than buffer).
	mutable size_type d_encodedbufflen; //!< length of above buffer (since buffer can be bigger then the data it holds to save re-alloc ations).	mutable size_type d_encodedbufflen; //!< length of above buffer (since buffer can be bigger then the data it holds to save re-alloc ations).

	utf32 d_quickbuff[STR_QUICKBUFF_SIZE]; //!< This is a integrated 'quick' buffer to save allocations for smallish strings	utf32 d_quickbuff[STR_QUICKBUFF_SIZE]; //!< This is a integrated 'quick' buffer to save allocations for smallish strings
	utf32* d_buffer; //!< Pointer the the main buffer memory. This is only valid wh en quick-buffer is not being used	utf32* d_buffer; //!< Pointer the the main buffer memory. This is only valid wh en quick-buffer is not being used

	public:	public:
	/***************************************************************** ****	/***************************************************************** ****
	Iterator Classes	Iterator Classes
	****************************************************************** ***/	****************************************************************** ***/

	/*!	//! regular iterator for String.
	\brief	class iterator : public std::iterator<std::random_access_iterator_tag,
	Constant forward iterator class for String objects	utf32>
	*/	{
	#if defined(_MSC_VER) && (_MSC_VER <= 1200)	public:
	class const_iterator : public std::iterator<std::random_access_itera	iterator() : d_ptr(0) {}
	tor_tag, utf32>	explicit iterator(utf32* const ptr) : d_ptr(ptr) {}
	#else
	class const_iterator : public std::iterator<std::random_access_itera
	tor_tag, utf32, std::ptrdiff_t, const utf32*, const utf32&>
	#endif
	{


	public:	utf32& operator*() const
	////////////////////////////////////////////////////////////	{
	//////////////	return *d_ptr;
	// data	}
	////////////////////////////////////////////////////////////
	//////////////
	const utf32* d_ptr;


	////////////////////////////////////////////////////////////	utf32* operator->() const
	//////////////	{
	// Methods	return &**this;
	////////////////////////////////////////////////////////////	}
	//////////////
	const_iterator(void)
	{
	d_ptr = 0;
	}
	const_iterator(const_pointer ptr)
	{
	d_ptr = ptr;
	}


	const_reference operator*() const	String::iterator& operator++()
	{	{
	return *d_ptr;	++d_ptr;
	}	return *this;
		}


	#if defined(_MSC_VER) && (_MSC_VER <= 1200)	String::iterator operator++(int)
	# pragma warning (push)	{
	# pragma warning (disable : 4284)	String::iterator temp = *this;
	#endif	++*this;
	const_pointer operator->() const	return temp;
	{	}
	return &**this;
	}


	#if defined(_MSC_VER) && (_MSC_VER <= 1200)	String::iterator& operator--()
	# pragma warning (pop)	{
	#endif	--d_ptr;
		return *this;
		}


	const_iterator& operator++()	String::iterator operator--(int)
	{	{
	++d_ptr;	String::iterator temp = *this;
	return *this;	--*this;
	}	return temp;
		}


	const_iterator operator++(int)	String::iterator& operator+=(difference_type offset)
	{	{
	const_iterator temp = *this;	d_ptr += offset;
	++*this;	return *this;
	return temp;	}
	}


	const_iterator& operator--()	String::iterator operator+(difference_type offset) const
	{	{
	--d_ptr;	String::iterator temp = *this;
	return *this;	return temp += offset;
	}	}


	const_iterator operator--(int)	String::iterator& operator-=(difference_type offset)
	{	{
	const_iterator temp = *this;	return *this += -offset;
	--*this;	}
	return temp;
	}


	const_iterator& operator+=(difference_type offset)	String::iterator operator-(difference_type offset) const
	{	{
	d_ptr += offset;	String::iterator temp = *this;
	return *this;	return temp -= offset;
	}	}


	const_iterator operator+(difference_type offset) const	utf32& operator[](difference_type offset) const
	{	{
	const_iterator temp = *this;	return (this + offset);
	return temp += offset;	}
	}


	const_iterator& operator-=(difference_type offset)	friend difference_type operator-(const String::iterator& lhs,
	{	const String::iterator& rhs)
	return *this += -offset;	{ return lhs.d_ptr - rhs.d_ptr; }
	}


	const_iterator operator-(difference_type offset) const	friend String::iterator operator+(difference_type offset, const Str
	{	ing::iterator& iter)
	const_iterator temp = *this;	{ return iter + offset; }
	return temp -= offset;
	}


	difference_type operator-(const const_iterator& iter) const	friend bool operator==(const String::iterator& lhs,
	{	const String::iterator& rhs)
	return d_ptr - iter.d_ptr;	{ return lhs.d_ptr == rhs.d_ptr; }
	}


	const_reference operator[](difference_type offset) const	friend bool operator!=(const String::iterator& lhs,
	{	const String::iterator& rhs)
	return (this + offset);	{ return lhs.d_ptr != rhs.d_ptr; }
	}


	bool operator==(const const_iterator& iter) const	friend bool operator<(const String::iterator& lhs,
	{	const String::iterator& rhs)
	return d_ptr == iter.d_ptr;	{ return lhs.d_ptr < rhs.d_ptr; }
	}


	bool operator!=(const const_iterator& iter) const	friend bool operator>(const String::iterator& lhs,
	{	const String::iterator& rhs)
	return !(*this == iter);	{ return lhs.d_ptr > rhs.d_ptr; }
	}


	bool operator<(const const_iterator& iter) const	friend bool operator<=(const String::iterator& lhs,
	{	const String::iterator& rhs)
	return d_ptr < iter.d_ptr;	{ return lhs.d_ptr <= rhs.d_ptr; }
	}


	bool operator>(const const_iterator& iter) const	friend bool operator>=(const String::iterator& lhs,
	{	const String::iterator& rhs)
	return (!(iter < *this));	{ return lhs.d_ptr >= rhs.d_ptr; }
	}


	bool operator<=(const const_iterator& iter) const	utf32* d_ptr;
	{	};
	return (!(iter < *this));
	}


	bool operator>=(const const_iterator& iter) const	//! const iterator for String.
	{	class const_iterator : public std::iterator<std::random_access_iterator
	return (!(*this < iter));	_tag, const utf32>
	}	{
		public:
		const_iterator() : d_ptr(0) {}
		explicit const_iterator(const utf32* const ptr) : d_ptr(ptr) {}
		const_iterator(const String::iterator& iter) : d_ptr(iter.d_ptr) {}


	friend const_iterator operator+(difference_type offset, cons	const utf32& operator*() const
	t const_iterator& iter)	{
	{	return *d_ptr;
	return iter + offset;	}
	}


	};	const utf32* operator->() const
		{
		return &**this;
		}


	/*!	String::const_iterator& operator++()
	\brief	{
	Forward iterator class for String objects	++d_ptr;
	*/	return *this;
	class iterator : public const_iterator	}
	{
	public:
	iterator(void) {}
	iterator(pointer ptr) : const_iterator(ptr) {}


	reference operator*() const	String::const_iterator operator++(int)
	{	{
	return ((reference)*(const_iterator )this);	String::const_iterator temp = *this;
	}	++*this;
		return temp;
		}


	#if defined(_MSC_VER) && (_MSC_VER <= 1200)	String::const_iterator& operator--()
	# pragma warning (push)	{
	# pragma warning (disable : 4284)	--d_ptr;
	#endif	return *this;
		}


	pointer operator->() const	String::const_iterator operator--(int)
	{	{
	return &**this;	String::const_iterator temp = *this;
	}	--*this;
		return temp;
		}


	#if defined(_MSC_VER) && (_MSC_VER <= 1200)	String::const_iterator& operator+=(difference_type offset)
	# pragma warning (pop)	{
	#endif	d_ptr += offset;
		return *this;
		}


	iterator& operator++()	String::const_iterator operator+(difference_type offset) const
	{	{
	++this->d_ptr;	String::const_iterator temp = *this;
	return *this;	return temp += offset;
	}	}


	iterator operator++(int)	String::const_iterator& operator-=(difference_type offset)
	{	{
	iterator temp = *this;	return *this += -offset;
	++*this;	}
	return temp;
	}


	iterator& operator--()	String::const_iterator operator-(difference_type offset) const
	{	{
	--this->d_ptr;	String::const_iterator temp = *this;
	return *this;	return temp -= offset;
	}	}


	iterator operator--(int)	const utf32& operator[](difference_type offset) const
	{	{
	iterator temp = *this;	return (this + offset);
	--*this;	}
	return temp;
	}


	iterator& operator+=(difference_type offset)	String::const_iterator& operator=(const String::iterator& iter)
	{	{
	this->d_ptr += offset;	d_ptr = iter.d_ptr;
	return *this;	return *this;
	}	}


	iterator operator+(difference_type offset) const	friend String::const_iterator operator+(difference_type offset, con
	{	st String::const_iterator& iter)
	iterator temp = *this;	{ return iter + offset; }
	return temp += offset;
	}


	iterator& operator-=(difference_type offset)	friend difference_type operator-(const String::const_iterator& lhs,
	{	const String::const_iterator& rhs)
	return *this += -offset;	{ return lhs.d_ptr - rhs.d_ptr; }
	}


	iterator operator-(difference_type offset) const	friend bool operator==(const String::const_iterator& lhs,
	{	const String::const_iterator& rhs)
	iterator temp = *this;	{ return lhs.d_ptr == rhs.d_ptr; }
	return temp -= offset;
	}


	difference_type operator-(const const_iterator& iter) const	friend bool operator!=(const String::const_iterator& lhs,
	{	const String::const_iterator& rhs)
	return ((const_iterator)*this - iter);	{ return lhs.d_ptr != rhs.d_ptr; }
	}


	reference operator[](difference_type offset) const	friend bool operator<(const String::const_iterator& lhs,
	{	const String::const_iterator& rhs)
	return (this + offset);	{ return lhs.d_ptr < rhs.d_ptr; }
	}


	friend iterator operator+(difference_type offset, const iter	friend bool operator>(const String::const_iterator& lhs,
	ator& iter)	const String::const_iterator& rhs)
	{	{ return lhs.d_ptr > rhs.d_ptr; }
	return iter + offset;
	}


	};	friend bool operator<=(const String::const_iterator& lhs,
		const String::const_iterator& rhs)
		{ return lhs.d_ptr <= rhs.d_ptr; }

		friend bool operator>=(const String::const_iterator& lhs,
		const String::const_iterator& rhs)
		{ return lhs.d_ptr >= rhs.d_ptr; }

		const utf32* d_ptr;
		};

	/*!	/*!
	\brief	\brief
	Constant reverse iterator class for String objects	Constant reverse iterator class for String objects
	*/	*/
	#if defined(_MSC_VER) && ((_MSC_VER <= 1200) \|\| ((_MSC_VER <= 1300) && defi ned(_STLPORT_VERSION)))	#if defined(_MSC_VER) && ((_MSC_VER <= 1200) \|\| ((_MSC_VER <= 1300) && defi ned(_STLPORT_VERSION)))
	typedef std::reverse_iterator<const_iterator, const_pointer, const_r eference, difference_type> const_reverse_iterator;	typedef std::reverse_iterator<const_iterator, const_pointer, const_r eference, difference_type> const_reverse_iterator;
	#else	#else
	typedef std::reverse_iterator<const_iterator> const_reverse_iterat or;	typedef std::reverse_iterator<const_iterator> const_reverse_iterat or;
	#endif	#endif

	skipping to change at line 2404	skipping to change at line 2383
	Index of the first code point to be removed.	Index of the first code point to be removed.

	\param len	\param len
	Maximum number of code points to be removed.	Maximum number of code points to be removed.

	\return	\return
	This String after the erase operation.	This String after the erase operation.

	\exception std::out_of_range Thrown if \a idx is invalid for this String.	\exception std::out_of_range Thrown if \a idx is invalid for this String.
	*/	*/

	String& erase(size_type idx, size_type len = npos)	String& erase(size_type idx, size_type len)
	{	{
	// cover the no-op case.	// cover the no-op case.
	if (len == 0)	if (len == 0)
	return *this;	return *this;

	if (d_cplength <= idx)	if (d_cplength <= idx)
	CEGUI_THROW(std::out_of_range("Index is out of range for CEGUI::String"));	CEGUI_THROW(std::out_of_range("Index is out of range for CEGUI::String"));

	if (len == npos)	if (len == npos)
	len = d_cplength - idx;	len = d_cplength - idx;

End of changes. 42 change blocks.
	206 lines changed or deleted	181 lines changed or added

	CEGUISystem.h	CEGUISystem.h

	skipping to change at line 639	skipping to change at line 639
	void setDefaultTooltip(const String& tooltipType);	void setDefaultTooltip(const String& tooltipType);

	/*!	/*!
	\brief	\brief
	return a poiter to the system default tooltip. May return 0.	return a poiter to the system default tooltip. May return 0.

	\return	\return
	Pointer to the current system default tooltip. May return 0 if	Pointer to the current system default tooltip. May return 0 if
	no system default tooltip is available.	no system default tooltip is available.
	*/	*/

	Tooltip* getDefaultTooltip(void) const { return d_defaultTooltip; }	Tooltip* getDefaultTooltip(void) const;

	/*!	/*!
	\brief	\brief
	Internal method to directly set the current modal target.	Internal method to directly set the current modal target.

	\note	\note
	This method is called internally by Window, and must be used by client code.	This method is called internally by Window, and must be used by client code.
	Doing so will most likely not have the expected results.	Doing so will most likely not have the expected results.
	*/	*/
	void setModalTarget(Window* target) {d_modalTarget = tar get;}	void setModalTarget(Window* target) {d_modalTarget = tar get;}

	skipping to change at line 1197	skipping to change at line 1197
	//! invalidate all windows and any rendering surfaces they may be using .	//! invalidate all windows and any rendering surfaces they may be using .
	void invalidateAllWindows();	void invalidateAllWindows();

	//! return common ancestor of two windows.	//! return common ancestor of two windows.
	Window* getCommonAncestor(Window* w1, Window* w2);	Window* getCommonAncestor(Window* w1, Window* w2);

	//! call some function for a chain of windows: (top, bottom]	//! call some function for a chain of windows: (top, bottom]
	void notifyMouseTransition(Window* top, Window* bottom,	void notifyMouseTransition(Window* top, Window* bottom,
	void (Window::*func)(MouseEventArgs&),	void (Window::*func)(MouseEventArgs&),
	MouseEventArgs& args);	MouseEventArgs& args);

		//! create a window of type d_defaultTooltipType for use as the Tooltip
		void createSystemOwnedDefaultTooltipWindow() const;
		//! destroy the default tooltip window if the system owns it.
		void destroySystemOwnedDefaultTooltipWindow();

	/***************************************************************** ****	/***************************************************************** ****
	Handlers for System events	Handlers for System events
	****************************************************************** ***/	****************************************************************** ***/
	/*!	/*!
	\brief	\brief
	Handler called when the main system GUI Sheet (or root windo w) is changed.	Handler called when the main system GUI Sheet (or root windo w) is changed.

	\a e is a WindowEventArgs with 'window' set to the old root window.	\a e is a WindowEventArgs with 'window' set to the old root window.
	*/	*/

	skipping to change at line 1287	skipping to change at line 1291
	// scripting	// scripting
	ScriptModule* d_scriptModule; //!< Points to the s cripting support module.	ScriptModule* d_scriptModule; //!< Points to the s cripting support module.
	String d_termScriptName; //!< Name of the script to run upon system shutdown.	String d_termScriptName; //!< Name of the script to run upon system shutdown.

	float d_mouseScalingFactor; //!< Scaling applied to mouse movement inputs.	float d_mouseScalingFactor; //!< Scaling applied to mouse movement inputs.

	XMLParser* d_xmlParser; //!< XMLParser object we use to process xml files.	XMLParser* d_xmlParser; //!< XMLParser object we use to process xml files.
	bool d_ourXmlParser; //!< true when we created the xml parse r.	bool d_ourXmlParser; //!< true when we created the xml parse r.
	DynamicModule* d_parserModule; //! pointer to parser module.	DynamicModule* d_parserModule; //! pointer to parser module.


	Tooltip* d_defaultTooltip; //!< System default tooltip object.	//! System default tooltip object.
	bool d_weOwnTooltip; //!< true if System created the custom	mutable Tooltip* d_defaultTooltip;
	Tooltip.	//! true if System created d_defaultTooltip.
		mutable bool d_weOwnTooltip;
		//! type of window to create as d_defaultTooltip
		String d_defaultTooltipType;

	static String d_defaultXMLParserName; //!< Holds name of default XMLP arser	static String d_defaultXMLParserName; //!< Holds name of default XMLP arser

	//! Holds a pointer to the image codec to use.	//! Holds a pointer to the image codec to use.
	ImageCodec* d_imageCodec;	ImageCodec* d_imageCodec;
	//! true when we created the image codec.	//! true when we created the image codec.
	bool d_ourImageCodec;	bool d_ourImageCodec;
	/** Holds a pointer to the image codec module. If d_imageCodecModule is 0 we	/** Holds a pointer to the image codec module. If d_imageCodecModule is 0 we
	* are not owner of the image codec object	* are not owner of the image codec object
	*/	*/

End of changes. 3 change blocks.
	4 lines changed or deleted	11 lines changed or added

	CEGUIVersion.h	CEGUIVersion.h

	skipping to change at line 42	skipping to change at line 42
	*************************************************************************/	*************************************************************************/
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	#ifndef _CEGUIVersion_h_	#ifndef _CEGUIVersion_h_
	#define _CEGUIVersion_h_	#define _CEGUIVersion_h_

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// Define CEGUI version	// Define CEGUI version
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	#define CEGUI_VERSION_MAJOR 0	#define CEGUI_VERSION_MAJOR 0
	#define CEGUI_VERSION_MINOR 7	#define CEGUI_VERSION_MINOR 7

	#define CEGUI_VERSION_PATCH 2	#define CEGUI_VERSION_PATCH 3

	#endif // end of guard _CEGUIVersion_h_	#endif // end of guard _CEGUIVersion_h_

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	CEGUIWindow.h	CEGUIWindow.h

	skipping to change at line 2916	skipping to change at line 2916
	child windows, this is so that child windows that access the parent in	child windows, this is so that child windows that access the parent in
	their update code get the correct updated state.	their update code get the correct updated state.

	\param elapsed	\param elapsed
	float value indicating the number of seconds passed since the last	float value indicating the number of seconds passed since the last
	update.	update.

	\return	\return
	Nothing.	Nothing.
	*/	*/

	void update(float elapsed);	virtual void update(float elapsed);

	/*!	/*!
	\brief	\brief
	Writes an xml representation of this window object to \a out_stream .	Writes an xml representation of this window object to \a out_stream .

	\param xml_stream	\param xml_stream
	Stream where xml data should be output.	Stream where xml data should be output.

	\return	\return
	Nothing.	Nothing.

	skipping to change at line 3234	skipping to change at line 3234
	Return whether mouse input that is not directly handled by this Win dow	Return whether mouse input that is not directly handled by this Win dow
	(including it's event subscribers) should be propagated back to the	(including it's event subscribers) should be propagated back to the
	Window's parent.	Window's parent.

	\return	\return
	- true if unhandled mouse input will be propagated to the parent.	- true if unhandled mouse input will be propagated to the parent.
	- false if unhandled mouse input will not be propagated.	- false if unhandled mouse input will not be propagated.
	*/	*/
	bool isMouseInputPropagationEnabled() const;	bool isMouseInputPropagationEnabled() const;


		/*!
		\brief
		Clones this Window and returns the result

		\param
		newName new name of the cloned window

		\param
		deepCopy if true, even children are copied (the old name prefix wil
		l
		be replaced with new name prefix)

		\return
		the cloned Window
		*/
		Window* clone(const String& newName, const bool deepCopy = true) const;

		//! copies this widget's properties to given target widget
		virtual void clonePropertiesTo(Window& target) const;
		//! copies this widget's child widgets to given target widget
		virtual void cloneChildWidgetsTo(Window& target) const;

	protected:	protected:
	// friend classes for construction / initialisation purposes (for now)	// friend classes for construction / initialisation purposes (for now)
	friend class System;	friend class System;
	friend class WindowManager;	friend class WindowManager;

	/******************************************************************** *	/******************************************************************** *
	Event trigger methods	Event trigger methods
	********************************************************************* /	********************************************************************* /
	/*!	/*!
	\brief	\brief

End of changes. 2 change blocks.
	1 lines changed or deleted	23 lines changed or added

	FalEditbox.h	FalEditbox.h

	skipping to change at line 135	skipping to change at line 135

	//! return whether the blinking caret is enabled.	//! return whether the blinking caret is enabled.
	bool isCaretBlinkEnabled() const;	bool isCaretBlinkEnabled() const;
	//! return the caret blink timeout period (only used if blink is enable d).	//! return the caret blink timeout period (only used if blink is enable d).
	float getCaretBlinkTimeout() const;	float getCaretBlinkTimeout() const;
	//! set whether the blinking caret is enabled.	//! set whether the blinking caret is enabled.
	void setCaretBlinkEnabled(bool enable);	void setCaretBlinkEnabled(bool enable);
	//! set the caret blink timeout period (only used if blink is enabled).	//! set the caret blink timeout period (only used if blink is enabled).
	void setCaretBlinkTimeout(float seconds);	void setCaretBlinkTimeout(float seconds);


		/*!
		\brief
		Sets the horizontal text formatting to be used from now onwards.

		\param format
		Specifies the formatting to use. Currently can only be one of the
		following HorizontalTextFormatting values:
		- HTF_LEFT_ALIGNED (default)
		- HTF_RIGHT_ALIGNED
		- HTF_CENTRE_ALIGNED
		*/
		void setTextFormatting(const HorizontalTextFormatting format);
		HorizontalTextFormatting getTextFormatting() const;

	void render();	void render();

	// overridden from EditboxWindowRenderer base class.	// overridden from EditboxWindowRenderer base class.
	size_t getTextIndexFromPosition(const Point& pt) const;	size_t getTextIndexFromPosition(const Point& pt) const;
	// overridden from WindowRenderer class	// overridden from WindowRenderer class
	void update(float elapsed);	void update(float elapsed);

	protected:	protected:
	// properties	// properties
	static FalagardEditboxProperties::BlinkCaret d_blinkCaretProperty;	static FalagardEditboxProperties::BlinkCaret d_blinkCaretProperty;
	static FalagardEditboxProperties::BlinkCaretTimeout d_blinkCaretTimeout Property;	static FalagardEditboxProperties::BlinkCaretTimeout d_blinkCaretTimeout Property;

		static FalagardEditboxProperties::TextFormatting d_textFormattingProper
		ty;

		//! helper to draw the base imagery (container and what have you)
		void renderBaseImagery(const WidgetLookFeel& wlf) const;
		//! helper to set 'visual' to the string we will render (part of)
		void setupVisualString(String& visual) const;
		size_t getCaretIndex(const String& visual_string) const;
		float calculateTextOffset(const Rect& text_area,
		const float text_extent,
		const float caret_width,
		const float extent_to_caret);
		void renderTextNoBidi(const WidgetLookFeel& wlf,
		const String& text,
		const Rect& text_area,
		float text_offset);
		void renderTextBidi(const WidgetLookFeel& wlf,
		const String& text,
		const Rect& text_area,
		float text_offset);
		bool editboxIsFocussed() const;
		void renderCaret(const ImagerySection& imagery,
		const Rect& text_area,
		const float text_offset,
		const float extent_to_caret) const;

		bool isUnsupportedFormat(const HorizontalTextFormatting format);

	//! x rendering offset used last time we drew the widget.	//! x rendering offset used last time we drew the widget.
	float d_lastTextOffset;	float d_lastTextOffset;
	//! true if the caret imagery should blink.	//! true if the caret imagery should blink.
	bool d_blinkCaret;	bool d_blinkCaret;
	//! time-out in seconds used for blinking the caret.	//! time-out in seconds used for blinking the caret.
	float d_caretBlinkTimeout;	float d_caretBlinkTimeout;
	//! current time elapsed since last caret blink state change.	//! current time elapsed since last caret blink state change.
	float d_caretBlinkElapsed;	float d_caretBlinkElapsed;
	//! true if caret should be shown.	//! true if caret should be shown.
	bool d_showCaret;	bool d_showCaret;

		//! horizontal formatting. Only supports left, right, and centred.
		HorizontalTextFormatting d_textFormatting;
	};	};

	} // End of CEGUI namespace section	} // End of CEGUI namespace section

	#if defined(_MSC_VER)	#if defined(_MSC_VER)
	# pragma warning(pop)	# pragma warning(pop)
	#endif	#endif

	#endif // end of guard _FalEditbox_h_	#endif // end of guard _FalEditbox_h_

End of changes. 3 change blocks.
	0 lines changed or deleted	43 lines changed or added

	FalEditboxProperties.h	FalEditboxProperties.h

	skipping to change at line 89	skipping to change at line 89
	"BlinkCaretTimeout",	"BlinkCaretTimeout",
	"Property to get/set the caret blink timeout / speed. "	"Property to get/set the caret blink timeout / speed. "
	"Value is a float value indicating the timeout in seconds.",	"Value is a float value indicating the timeout in seconds.",
	"0.66")	"0.66")
	{}	{}

	String get(const PropertyReceiver* receiver) const;	String get(const PropertyReceiver* receiver) const;
	void set(PropertyReceiver* receiver, const String& value);	void set(PropertyReceiver* receiver, const String& value);
	};	};


		/*!
		\brief
		Property to access the horizontal formatting mode setting.

		\par Usage:
		- Name: TextFormatting
		- Format: "[text]".

		\par Where [text] is one of:
		- "LeftAligned"
		- "RightAligned"
		- "HorzCentred"
		*/
		class TextFormatting : public Property
		{
		public:
		TextFormatting() : Property(
		"TextFormatting",
		"Property to get/set the horizontal formatting mode. "
		"Value is one of: LeftAligned, RightAligned or HorzCentred",
		"LeftAligned")
		{}

		String get(const PropertyReceiver* receiver) const;
		void set(PropertyReceiver* receiver, const String& value);
		};

	} // End of FalagardEditboxProperties namespace section	} // End of FalagardEditboxProperties namespace section

	} // End of CEGUI namespace section	} // End of CEGUI namespace section

	#endif // end of guard _FalEditboxProperties_h_	#endif // end of guard _FalEditboxProperties_h_

End of changes. 1 change blocks.
	0 lines changed or deleted	27 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	CEGUIConfig.h	CEGUIConfig.h

	skipping to change at line 63	skipping to change at line 63
	// Set this to the default XMLParser to be used.	// Set this to the default XMLParser to be used.
	// (XercesParser, ExpatParser, LibxmlParser or TinyXMLParser).	// (XercesParser, ExpatParser, LibxmlParser or TinyXMLParser).
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	#ifndef CEGUI_DEFAULT_XMLPARSER	#ifndef CEGUI_DEFAULT_XMLPARSER
	# define CEGUI_DEFAULT_XMLPARSER ExpatParser	# define CEGUI_DEFAULT_XMLPARSER ExpatParser
	#endif	#endif

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// Set this to the default ImageCodec to be used.	// Set this to the default ImageCodec to be used.
	// CoronaImageCodec, DevILImageCodec, FreeImageImageCodec,	// CoronaImageCodec, DevILImageCodec, FreeImageImageCodec,

	// SILLYImageCodec, TGAImageCodec	// SILLYImageCodec, TGAImageCodec or STBImageCodec
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	#ifndef CEGUI_DEFAULT_IMAGE_CODEC	#ifndef CEGUI_DEFAULT_IMAGE_CODEC
	# define CEGUI_DEFAULT_IMAGE_CODEC SILLYImageCodec	# define CEGUI_DEFAULT_IMAGE_CODEC SILLYImageCodec
	#endif	#endif

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// The following are required to build the integrated copy of TinyXML.	// The following are required to build the integrated copy of TinyXML.
	// If for some reason you decide you need to use an external version of	// If for some reason you decide you need to use an external version of
	// TinyXML, you can change these defines as required (you will also likely	// TinyXML, you can change these defines as required (you will also likely
	// need to set up some linker stuff as well).	// need to set up some linker stuff as well).

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	CEGUILayoutContainer.h	CEGUILayoutContainer.h

	skipping to change at line 109	skipping to change at line 109
	/*!	/*!
	\brief	\brief
	(re)layouts all windows inside this layout container if it was mark ed	(re)layouts all windows inside this layout container if it was mark ed
	necessary	necessary
	*/	*/
	virtual void layoutIfNecessary();	virtual void layoutIfNecessary();

	/// @copydoc Window::getUnclippedInnerRect_impl	/// @copydoc Window::getUnclippedInnerRect_impl
	virtual Rect getUnclippedInnerRect_impl(void) const;	virtual Rect getUnclippedInnerRect_impl(void) const;


		/// @copydoc Window::update
		virtual void update(float elapsed);

	protected:	protected:
	/// @copydoc Window::getClientChildWindowContentArea_impl	/// @copydoc Window::getClientChildWindowContentArea_impl
	virtual Rect getClientChildWindowContentArea_impl() const;	virtual Rect getClientChildWindowContentArea_impl() const;

	//! @copydoc Window::testClassName_impl	//! @copydoc Window::testClassName_impl
	virtual bool testClassName_impl(const String& class_name) const	virtual bool testClassName_impl(const String& class_name) const
	{	{
	if (class_name == "LayoutContainer") return true;	if (class_name == "LayoutContainer") return true;

	return Window::testClassName_impl(class_name);	return Window::testClassName_impl(class_name);
	}	}

	size_t getIdxOfChildWindow(Window* wnd) const;	size_t getIdxOfChildWindow(Window* wnd) const;

	/// @copydoc Window::addChild_impl	/// @copydoc Window::addChild_impl
	virtual void addChild_impl(Window* wnd);	virtual void addChild_impl(Window* wnd);
	/// @copydoc Window::removeChild_impl	/// @copydoc Window::removeChild_impl
	virtual void removeChild_impl(Window* wnd);	virtual void removeChild_impl(Window* wnd);

	/// @copydoc Window::drawSelf
	virtual void drawSelf(const RenderingContext& ctx);

	/******************************************************************** *	/******************************************************************** *
	Event trigger methods	Event trigger methods
	********************************************************************* /	********************************************************************* /
	/*!	/*!
	\brief	\brief
	Handler called when child window gets sized	Handler called when child window gets sized

	\param e	\param e
	WindowEventArgs object whose 'window' pointer field is set to the	WindowEventArgs object whose 'window' pointer field is set to the

End of changes. 2 change blocks.
	2 lines changed or deleted	3 lines changed or added

	CEGUITooltip.h	CEGUITooltip.h

	skipping to change at line 408	skipping to change at line 408

	/**************************************************************** ****	/**************************************************************** ****
	Data fields	Data fields
	***************************************************************** ***/	***************************************************************** ***/
	TipState d_state; //!< Current tooltip state.	TipState d_state; //!< Current tooltip state.
	float d_elapsed; //!< Used to track state change timings	float d_elapsed; //!< Used to track state change timings
	const Window* d_target; //!< Current target Window for this Too ltip.	const Window* d_target; //!< Current target Window for this Too ltip.
	float d_hoverTime; //!< tool-tip hover time (seconds mouse must stay stationary before tip shows).	float d_hoverTime; //!< tool-tip hover time (seconds mouse must stay stationary before tip shows).
	float d_displayTime; //!< tool-tip display time (seconds tha t tip is showsn for).	float d_displayTime; //!< tool-tip display time (seconds tha t tip is showsn for).
	float d_fadeTime; //!< tool-tip fade time (seconds it tak es for tip to fade in and/or out).	float d_fadeTime; //!< tool-tip fade time (seconds it tak es for tip to fade in and/or out).

		//! are in positionSelf function? (to avoid infinite recursion issu
		es)
		bool d_inPositionSelf;

	private:	private:
	/**************************************************************** *****	/**************************************************************** *****
	Static Properties for this class	Static Properties for this class
	***************************************************************** ****/	***************************************************************** ****/
	static TooltipProperties::HoverTime d_hoverTimeProperty;	static TooltipProperties::HoverTime d_hoverTimeProperty;
	static TooltipProperties::DisplayTime d_displayTimeProperty;	static TooltipProperties::DisplayTime d_displayTimeProperty;
	static TooltipProperties::FadeTime d_fadeTimeProperty;	static TooltipProperties::FadeTime d_fadeTimeProperty;

	/**************************************************************** *****	/**************************************************************** *****

End of changes. 1 change blocks.
	0 lines changed or deleted	3 lines changed or added