Graphics.UI.Gtk.Layout.Fixed

gtk-0.12.4: Binding to the Gtk+ graphical user interface library.

Portability | portable (depends on GHC)
Stability | provisional
Maintainer | gtk2hs-users@lists.sourceforge.net
Safe Haskell | None

Graphics.UI.Gtk.Layout.Fixed

Contents

- Detail
- Class Hierarchy
- Types
- Constructors
- Methods
- Attributes
- Child Attributes

Description

A container which allows you to position widgets at fixed coordinates

Synopsis

- data Fixed
- class ContainerClass o => FixedClass o
- castToFixed :: GObjectClass obj => obj -> Fixed
- gTypeFixed :: GType
- toFixed :: FixedClass o => o -> Fixed
- fixedNew :: IO Fixed
- fixedPut :: (FixedClass self, WidgetClass widget) => self -> widget -> (Int, Int) -> IO ()
- fixedMove :: (FixedClass self, WidgetClass widget) => self -> widget -> (Int, Int) -> IO ()
- fixedSetHasWindow :: FixedClass self => self -> Bool -> IO ()
- fixedGetHasWindow :: FixedClass self => self -> IO Bool
- fixedHasWindow :: FixedClass self => Attr self Bool
- fixedChildX :: (FixedClass self, WidgetClass child) => child -> Attr self Int
- fixedChildY :: (FixedClass self, WidgetClass child) => child -> Attr self Int

# Detail

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 Gtk+ containers, but 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 Hierarchy

     | GObject
     | +----Object
     | +----Widget
     | +----Container
     | +----Fixed

# Types

data Fixed

Instances

Eq Fixed |
Ord Fixed |
GObjectClass Fixed |
FixedClass Fixed |
ContainerClass Fixed |
WidgetClass Fixed |
ObjectClass Fixed |

class ContainerClass o => FixedClass o

Instances

FixedClass Fixed |

castToFixed :: GObjectClass obj => obj -> Fixed

gTypeFixed :: GType

toFixed :: FixedClass o => o -> Fixed

# Constructors

fixedNew :: IO Fixed

Creates a new `Fixed`.

# Methods

fixedPut

Arguments

:: (FixedClass self, WidgetClass widget) |
=> self |
-> widget | `widget` - the widget to add.
-> (Int, Int) | `(x,y)` - the horizontal and vertical position to place the widget at.
-> IO () |

Adds a widget to a `Fixed` container at the given position.

fixedMove

Arguments

:: (FixedClass self, WidgetClass widget) |
=> self |
-> widget | `widget` - the child widget.
-> (Int, Int) | `(x,y)` - the horizontal and vertical position to move the widget to.
-> IO () |

Moves a child of a `Fixed` container to the given position.

fixedSetHasWindow :: FixedClass self => self -> Bool -> IO ()

Sets whether the `Fixed` widget is created with a separate `DrawWindow` for its window or not. (By default, it will be created with no separate `DrawWindow`). This function must be called while the `Fixed` is not realized, for instance, immediately after the window is created.

This function was added to provide an easy migration path for older applications which may expect `Fixed` to have a separate window.

fixedGetHasWindow :: FixedClass self => self -> IO Bool

Gets whether the `Fixed` has its own `DrawWindow`. See `fixedSetHasWindow`.

# Attributes

fixedHasWindow :: FixedClass self => Attr self Bool

'hasWindow' property. See `fixedGetHasWindow` and `fixedSetHasWindow`

# Child Attributes

fixedChildX :: (FixedClass self, WidgetClass child) => child -> Attr self Int

X position of child widget.

Default value: 0

fixedChildY :: (FixedClass self, WidgetClass child) => child -> Attr self Int

Y position of child widget.

Default value: 0