/*  Inti: Integrated Foundation Classes
 *  Copyright (C) 2002 The Inti Development Team.
 *
 *  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 Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library 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.
 */

//! @file inti/gtk/fixed.h
//! @brief A GtkFixed C++ wrapper interface.
//!
//! Provides Fixed, a container which can place child widgets at fixed positions and
//! with fixed sizes, given in pixels.

#ifndef INTI_GTK_FIXED_H
#define INTI_GTK_FIXED_H

#ifndef INTI_GTK_CONTAINER_H
#include <inti/gtk/container.h>
#endif

#ifndef __GTK_FIXED_H__
#include <gtk/gtkfixed.h>
#endif

namespace Inti {

namespace Gtk {

class FixedClass;

//! @class Fixed fixed.h inti/gtk/fixed.h
//! @brief A GtkFixed C++ wrapper class.
//!
//! The Fixed widget is a container which can place child widgets at fixed positions and
//! with fixed sizes, given in pixels. Fixed performs no automatic layout management. For
//! most applications, you should not use this container! It keeps you from having to 
//! learn about the other containers, and it results in broken applications. With Fixed,
//! the following things will result in truncated text, overlapping widgets, and other
//! display bugs:
//!
//! - Themes, which may change widget sizes.
//!
//! - Fonts other than the one you used to write the app will of course change the size
//!   of widgets containing text; keep in mind that users may use a larger font because
//!   of difficulty reading the default, or they may be using Windows or the framebuffer
//!   port of GTK+, where different fonts are available.
//!
//! - Translation of text into other languages changes its size. Also, display of 
//!   non-English text will use a different font in many cases.
//!
//! - In addition, the fixed widget can't properly be mirrored in right-to-left languages
//!   such as Hebrew and Arabic. i.e. normally GTK+ will flip the interface to put labels
//!   to the right of the thing they label, but it can't do that with Fixed. So your 
//!   application will not be usable in right-to-left languages.
//!
//! - Finally, fixed positioning makes it kind of annoying to add/remove GUI elements, 
//!   since you have to reposition all the other elements. This is a long-term maintenance
//!   problem for your application.
//!
//! If you know none of these things are an issue for your application, and prefer the 
//! simplicity of Fixed, by all means use the widget. But you should be aware of the
//! tradeoffs.

class Fixed : public Container
{
	friend class G::Object;
	friend class FixedClass;

	Fixed(const Fixed&);
	Fixed& operator=(const Fixed&);
	
protected:
//! @name Constructors
//! @{

	explicit Fixed(GtkFixed *fixed, bool reference = false);
	//!< Construct a new Fixed from an existing GtkFixed.
	//!< @param fixed A pointer to a GtkFixed.
	//!< @param reference Set false if the initial reference count is floating, set true if it's not.
	//!<
	//!< <BR>The <EM>fixed</EM> can be a newly created GtkFixed or an existing
	//!< GtkFixed (see G::Object::Object).

//! @}
//  Child properties

	typedef Gtk::ChildProperty<int> XPropertyType;
	typedef Gtk::ChildPropertyProxy<Container, XPropertyType> XPropertyProxy;
	static const XPropertyType x_property;

	typedef Gtk::ChildProperty<int> YPropertyType;
	typedef Gtk::ChildPropertyProxy<Container, YPropertyType> YPropertyProxy;
	static const YPropertyType y_property;

public:
//! @name Constructors
//! @{

	Fixed();
	//!< Construct a new Fixed container.

	virtual ~Fixed();
	//!< Destructor.
	
//! @}
//! @name Accessors
//! @{

	GtkFixed* gtk_fixed() const { return (GtkFixed*)instance; }
	//!< Get a pointer to the GtkFixed structure.

	GtkFixedClass* gtk_fixed_class() const;
	//!< Get a pointer to the GtkFixedClass structure.

	operator GtkFixed* () const;
	//!< Conversion operator; safely converts a Fixed to a GtkFixed pointer.

	bool get_has_window() const;
	//! Returns true if the Fixed widget has it's own Gdk::Window (see set_has_window()).

//! @}
//! @name Methods
//! @{

	void put(Widget& widget, int x, int y);
	//!< Adds a widget to a Fixed container at the given position.
	//!< @param widget The widget to add.
	//!< @param x The horizontal position to place the widget at.
	//!< @param y The vertical position to place the widget at.

	void move(Widget& widget, int x, int y);
	//!< Moves a child of a Fixed container to the given position.
	//!< @param widget The child widget.
	//!< @param x The horizontal position to move the widget to.
	//!< @param y The vertical position to move the widget to.
	
	void set_has_window(bool has_window);
	//!< Sets whether a Fixed widget is created with a separate Gdk::Window or not.
	//!< @param has_window <EM>true</EM> if a separate window should be created.
	//!<
	//!< <BR>By default, Fixed will be created with no separate Gdk::Window. This
	//!< method must be called while the Fixed is not realized, for instance, 
	//!< immediately after the window is created.

//! @}
//! @name Child Property Proxies
//! @{

	const XPropertyProxy prop_x()
	{
		return XPropertyProxy(this, &x_property);
	}
	//!< X position of the child widget (int : Read / Write).

	const YPropertyProxy prop_y()
	{
		return YPropertyProxy(this, &y_property);
	}
	//!< Y position of the child widget (int : Read / Write).

//! @}
};

} // namespace Gtk

} // namespace Inti

#endif // INTI_GTK_FIXED_H

