brl/gnome-shell
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Import MxTable as StTable

Browse Source 
Import table code from Mx library

https://bugzilla.gnome.org/show_bug.cgi?id=596811
This commit is contained in:
Owen W. Taylor 2009-09-29 23:13:29 -04:00
parent 91eb613d69
commit 289b19aa31
6 changed files with 2563 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/Makefile-st.am
View File

@ -78,6 +78,8 @@ st_source_h = \
st/st-scroll-bar.h \ st/st-scroll-bar.h \
st/st-scroll-view.h \ st/st-scroll-view.h \
st/st-subtexture.h \ st/st-subtexture.h \
st/st-table.h \
st/st-table-child.h \
st/st-texture-cache.h \ st/st-texture-cache.h \
st/st-texture-frame.h \ st/st-texture-frame.h \
st/st-theme.h \ st/st-theme.h \
@ -90,6 +92,7 @@ st_source_h = \
st_source_private_h = \ st_source_private_h = \
st/st-private.h \ st/st-private.h \
st/st-table-private.h \
st/st-theme-private.h st/st-theme-private.h
# please, keep this sorted alphabetically # please, keep this sorted alphabetically
@ -108,6 +111,8 @@ st_source_c = \
st/st-scroll-bar.c \ st/st-scroll-bar.c \
st/st-scroll-view.c \ st/st-scroll-view.c \
st/st-subtexture.c \ st/st-subtexture.c \
st/st-table.c \
st/st-table-child.c \
st/st-texture-cache.c \ st/st-texture-cache.c \
st/st-texture-frame.c \ st/st-texture-frame.c \
st/st-theme.c \ st/st-theme.c \

805
src/st/st-table-child.c Normal file
View File

@ -0,0 +1,805 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* st-table-child.h: Table child implementation
*
* Copyright 2008, 2009 Intel Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU Lesser General Public License,
* version 2.1, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
* more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
* Boston, MA 02111-1307, USA.
*
* Written by: Thomas Wood <thomas.wood@intel.com>
*
*/
#include "st-private.h"
#include "st-table-child.h"
#include "st-table-private.h"
#include <st/st-widget.h>
#include <st/st-table.h>
/*
* ClutterChildMeta Implementation
*/
/**
* SECTION:st-table-child
* @short_description: The child property store for #StTable
*
* The #ClutterChildMeta implementation for the #StTable container widget.
*
*/
enum {
CHILD_PROP_0,
CHILD_PROP_COL,
CHILD_PROP_ROW,
CHILD_PROP_COL_SPAN,
CHILD_PROP_ROW_SPAN,
CHILD_PROP_X_EXPAND,
CHILD_PROP_Y_EXPAND,
CHILD_PROP_X_ALIGN,
CHILD_PROP_Y_ALIGN,
CHILD_PROP_X_FILL,
CHILD_PROP_Y_FILL,
CHILD_PROP_ALLOCATE_HIDDEN,
};
G_DEFINE_TYPE (StTableChild, st_table_child, CLUTTER_TYPE_CHILD_META);
static void
table_child_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
StTableChild *child = ST_TABLE_CHILD (gobject);
StTable *table = ST_TABLE (CLUTTER_CHILD_META(gobject)->container);
switch (prop_id)
{
case CHILD_PROP_COL:
child->col = g_value_get_int (value);
_st_table_update_row_col (table, -1, child->col);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
case CHILD_PROP_ROW:
child->row = g_value_get_int (value);
_st_table_update_row_col (table, child->row, -1);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
case CHILD_PROP_COL_SPAN:
child->col_span = g_value_get_int (value);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
case CHILD_PROP_ROW_SPAN:
child->row_span = g_value_get_int (value);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
case CHILD_PROP_X_EXPAND:
child->x_expand = g_value_get_boolean (value);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
case CHILD_PROP_Y_EXPAND:
child->y_expand = g_value_get_boolean (value);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
case CHILD_PROP_X_ALIGN:
child->x_align = g_value_get_double (value);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
case CHILD_PROP_Y_ALIGN:
child->y_align = g_value_get_double (value);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
case CHILD_PROP_X_FILL:
child->x_fill = g_value_get_boolean (value);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
case CHILD_PROP_Y_FILL:
child->y_fill = g_value_get_boolean (value);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
case CHILD_PROP_ALLOCATE_HIDDEN:
child->allocate_hidden = g_value_get_boolean (value);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
table_child_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
StTableChild *child = ST_TABLE_CHILD (gobject);
switch (prop_id)
{
case CHILD_PROP_COL:
g_value_set_int (value, child->col);
break;
case CHILD_PROP_ROW:
g_value_set_int (value, child->row);
break;
case CHILD_PROP_COL_SPAN:
g_value_set_int (value, child->col_span);
break;
case CHILD_PROP_ROW_SPAN:
g_value_set_int (value, child->row_span);
break;
case CHILD_PROP_X_EXPAND:
g_value_set_boolean (value, child->x_expand);
break;
case CHILD_PROP_Y_EXPAND:
g_value_set_boolean (value, child->y_expand);
break;
case CHILD_PROP_X_ALIGN:
g_value_set_double (value, child->x_align);
break;
case CHILD_PROP_Y_ALIGN:
g_value_set_double (value, child->y_align);
break;
case CHILD_PROP_X_FILL:
g_value_set_boolean (value, child->x_fill);
break;
case CHILD_PROP_Y_FILL:
g_value_set_boolean (value, child->y_fill);
break;
case CHILD_PROP_ALLOCATE_HIDDEN:
g_value_set_boolean (value, child->allocate_hidden);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
st_table_child_class_init (StTableChildClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GParamSpec *pspec;
gobject_class->set_property = table_child_set_property;
gobject_class->get_property = table_child_get_property;
pspec = g_param_spec_int ("col",
"Column Number",
"The column the widget resides in",
0, G_MAXINT,
0,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_COL, pspec);
pspec = g_param_spec_int ("row",
"Row Number",
"The row the widget resides in",
0, G_MAXINT,
0,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_ROW, pspec);
pspec = g_param_spec_int ("row-span",
"Row Span",
"The number of rows the widget should span",
1, G_MAXINT,
1,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_ROW_SPAN, pspec);
pspec = g_param_spec_int ("col-span",
"Column Span",
"The number of columns the widget should span",
1, G_MAXINT,
1,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_COL_SPAN, pspec);
pspec = g_param_spec_boolean ("x-expand",
"X Expand",
"Whether the child should receive priority "
"when the container is allocating spare space "
"on the horizontal axis",
TRUE,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_X_EXPAND, pspec);
pspec = g_param_spec_boolean ("y-expand",
"Y Expand",
"Whether the child should receive priority "
"when the container is allocating spare space "
"on the vertical axis",
TRUE,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_Y_EXPAND, pspec);
pspec = g_param_spec_double ("x-align",
"X Alignment",
"X alignment of the widget within the cell",
0, 1,
0.5,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_X_ALIGN, pspec);
pspec = g_param_spec_double ("y-align",
"Y Alignment",
"Y alignment of the widget within the cell",
0, 1,
0.5,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_Y_ALIGN, pspec);
pspec = g_param_spec_boolean ("x-fill",
"X Fill",
"Whether the child should be allocated its "
"entire available space, or whether it should "
"be squashed and aligned.",
TRUE,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_X_FILL, pspec);
pspec = g_param_spec_boolean ("y-fill",
"Y Fill",
"Whether the child should be allocated its "
"entire available space, or whether it should "
"be squashed and aligned.",
TRUE,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_Y_FILL, pspec);
pspec = g_param_spec_boolean ("allocate-hidden",
"Allocate Hidden",
"Whether the child should be allocate even "
"if it is hidden",
TRUE,
ST_PARAM_READWRITE);
g_object_class_install_property (gobject_class, CHILD_PROP_ALLOCATE_HIDDEN, pspec);
}
static void
st_table_child_init (StTableChild *self)
{
self->col_span = 1;
self->row_span = 1;
self->x_align = 0.5;
self->y_align = 0.5;
self->x_expand = TRUE;
self->y_expand = TRUE;
self->x_fill = TRUE;
self->y_fill = TRUE;
self->allocate_hidden = TRUE;
}
static StTableChild*
get_child_meta (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
meta = (StTableChild*) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
return meta;
}
/**
* st_table_child_get_col_span:
* @table: an #StTable
* @child: a #ClutterActor
*
* Get the column span of the child. Defaults to 1.
*
* Returns: the column span of the child
*/
gint
st_table_child_get_col_span (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
g_return_val_if_fail (ST_IS_TABLE (table), 0);
g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
meta = get_child_meta (table, child);
return meta->col_span;
}
/**
* st_table_child_set_col_span:
* @table: An #StTable
* @child: An #ClutterActor
* @span: The number of columns to span
*
* Set the column span of the child.
*
*/
void
st_table_child_set_col_span (StTable *table,
ClutterActor *child,
gint span)
{
StTableChild *meta;
g_return_if_fail (ST_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
g_return_if_fail (span > 1);
meta = get_child_meta (table, child);
meta->col_span = span;
clutter_actor_queue_relayout (child);
}
/**
* st_table_child_get_row_span:
* @table: A #StTable
* @child: A #ClutterActor
*
* Get the row span of the child. Defaults to 1.
*
* Returns: the row span of the child
*/
gint
st_table_child_get_row_span (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
g_return_val_if_fail (ST_IS_TABLE (table), 0);
g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
meta = get_child_meta (table, child);
return meta->row_span;
}
/**
* st_table_child_set_row_span:
* @table: A #StTable
* @child: A #ClutterActor
* @span: the number of rows to span
*
* Set the row span of the child.
*
*/
void
st_table_child_set_row_span (StTable *table,
ClutterActor *child,
gint span)
{
StTableChild *meta;
g_return_if_fail (ST_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
g_return_if_fail (span > 1);
meta = get_child_meta (table, child);
meta->row_span = span;
clutter_actor_queue_relayout (child);
}
/**
* st_table_child_get_x_fill:
* @table: A #StTable
* @child: A #ClutterActor
*
* Get the x-fill state of the child
*
* Returns: #TRUE if the child is set to x-fill
*/
gboolean
st_table_child_get_x_fill (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
g_return_val_if_fail (ST_IS_TABLE (table), 0);
g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
meta = get_child_meta (table, child);
return meta->x_fill;
}
/**
* st_table_child_set_x_fill:
* @table: A #StTable
* @child: A #ClutterActor
* @fill: the fill state
*
* Set the fill state of the child on the x-axis. This will cause the child to
* be allocated the maximum available space.
*
*/
void
st_table_child_set_x_fill (StTable *table,
ClutterActor *child,
gboolean fill)
{
StTableChild *meta;
g_return_if_fail (ST_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
meta = get_child_meta (table, child);
meta->x_fill = fill;
clutter_actor_queue_relayout (child);
}
/**
* st_table_child_get_y_fill:
* @table: A #StTable
* @child: A #ClutterActor
*
* Get the y-fill state of the child
*
* Returns: #TRUE if the child is set to y-fill
*/
gboolean
st_table_child_get_y_fill (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
g_return_val_if_fail (ST_IS_TABLE (table), 0);
g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
meta = get_child_meta (table, child);
return meta->y_fill;
}
/**
* st_table_child_set_y_fill:
* @table: A #StTable
* @child: A #ClutterActor
* @fill: the fill state
*
* Set the fill state of the child on the y-axis. This will cause the child to
* be allocated the maximum available space.
*
*/
void
st_table_child_set_y_fill (StTable *table,
ClutterActor *child,
gboolean fill)
{
StTableChild *meta;
g_return_if_fail (ST_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
meta = get_child_meta (table, child);
meta->y_fill = fill;
clutter_actor_queue_relayout (child);
}
/**
* st_table_child_get_x_expand:
* @table: A #StTable
* @child: A #ClutterActor
*
* Get the x-expand property of the child
*
* Returns: #TRUE if the child is set to x-expand
*/
gboolean
st_table_child_get_x_expand (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
g_return_val_if_fail (ST_IS_TABLE (table), 0);
g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
meta = get_child_meta (table, child);
return meta->x_expand;
}
/**
* st_table_child_set_x_expand:
* @table: A #StTable
* @child: A #ClutterActor
* @expand: the new value of the x expand child property
*
* Set x-expand on the child. This causes the column which the child
* resides in to be allocated any extra space if the allocation of the table is
* larger than the preferred size.
*
*/
void
st_table_child_set_x_expand (StTable *table,
ClutterActor *child,
gboolean expand)
{
StTableChild *meta;
g_return_if_fail (ST_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
meta = get_child_meta (table, child);
meta->x_expand = expand;
clutter_actor_queue_relayout (child);
}
/**
* st_table_child_set_y_expand:
* @table: A #StTable
* @child: A #ClutterActor
* @expand: the new value of the y-expand child property
*
* Set y-expand on the child. This causes the row which the child
* resides in to be allocated any extra space if the allocation of the table is
* larger than the preferred size.
*
*/
void
st_table_child_set_y_expand (StTable *table,
ClutterActor *child,
gboolean expand)
{
StTableChild *meta;
g_return_if_fail (ST_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
meta = get_child_meta (table, child);
meta->y_expand = expand;
clutter_actor_queue_relayout (child);
}
/**
* st_table_child_get_y_expand:
* @table: A #StTable
* @child: A #ClutterActor
*
* Get the y-expand property of the child.
*
* Returns: #TRUE if the child is set to y-expand
*/
gboolean
st_table_child_get_y_expand (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
g_return_val_if_fail (ST_IS_TABLE (table), 0);
g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
meta = get_child_meta (table, child);
return meta->y_expand;
}
/**
* st_table_child_get_x_align:
* @table: A #StTable
* @child: A #ClutterActor
*
* Get the x-align value of the child
*
* Returns: An #StAlign value
*/
StAlign
st_table_child_get_x_align (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
g_return_val_if_fail (ST_IS_TABLE (table), 0);
g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
meta = get_child_meta (table, child);
if (meta->x_align == 0.0)
return ST_ALIGN_START;
else if (meta->x_align == 1.0)
return ST_ALIGN_END;
else
return ST_ALIGN_MIDDLE;
}
/**
* st_table_child_set_x_align:
* @table: A #StTable
* @child: A #ClutterActor
* @align: A #StAlign value
*
* Set the alignment of the child within its cell. This will only have an effect
* if the the x-fill property is FALSE.
*
*/
void
st_table_child_set_x_align (StTable *table,
ClutterActor *child,
StAlign align)
{
StTableChild *meta;
g_return_if_fail (ST_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
meta = get_child_meta (table, child);
switch (align)
{
case ST_ALIGN_START:
meta->x_align = 0.0;
break;
case ST_ALIGN_MIDDLE:
meta->x_align = 0.5;
break;
case ST_ALIGN_END:
meta->x_align = 1.0;
break;
}
clutter_actor_queue_relayout (child);
}
/**
* st_table_child_get_y_align:
* @table: A #StTable
* @child: A #ClutterActor
*
* Get the y-align value of the child
*
* Returns: An #StAlign value
*/
StAlign
st_table_child_get_y_align (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
g_return_val_if_fail (ST_IS_TABLE (table), 0);
g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
meta = get_child_meta (table, child);
if (meta->y_align == 0.0)
return ST_ALIGN_START;
else if (meta->y_align == 1.0)
return ST_ALIGN_END;
else
return ST_ALIGN_MIDDLE;
}
/**
* st_table_child_set_y_align:
* @table: A #StTable
* @child: A #ClutterActor
* @align: A #StAlign value
*
* Set the value of the y-align property. This will only have an effect if
* y-fill value is set to FALSE.
*
*/
void
st_table_child_set_y_align (StTable *table,
ClutterActor *child,
StAlign align)
{
StTableChild *meta;
g_return_if_fail (ST_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
meta = get_child_meta (table, child);
switch (align)
{
case ST_ALIGN_START:
meta->y_align = 0.0;
break;
case ST_ALIGN_MIDDLE:
meta->y_align = 0.5;
break;
case ST_ALIGN_END:
meta->y_align = 1.0;
break;
}
clutter_actor_queue_relayout (child);
}
/**
* st_table_child_set_allocate_hidden:
* @table: A #StTable
* @child: A #ClutterActor
* @value: #TRUE if the actor should be allocated when hidden
*
* Set whether the child should be allocate even if it is hidden
*/
void
st_table_child_set_allocate_hidden (StTable *table,
ClutterActor *child,
gboolean value)
{
StTableChild *meta;
g_return_if_fail (ST_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
meta = get_child_meta (table, child);
if (meta->allocate_hidden != value)
{
meta->allocate_hidden = value;
clutter_actor_queue_relayout (child);
g_object_notify (G_OBJECT (meta), "allocate-hidden");
}
}
/**
* st_table_child_get_allocate_hidden:
* @table: A #StTable
* @child: A #ClutterActor
*
* Determine if the child is allocated even if it is hidden
*
* Returns: #TRUE if the actor is allocated when hidden
*/
gboolean
st_table_child_get_allocate_hidden (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
g_return_val_if_fail (ST_IS_TABLE (table), TRUE);
g_return_val_if_fail (CLUTTER_IS_ACTOR (child), TRUE);
meta = get_child_meta (table, child);
return meta->allocate_hidden;
}

129
src/st/st-table-child.h Normal file
View File

@ -0,0 +1,129 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* st-table-child.h: Table child implementation
*
* Copyright 2008, 2009 Intel Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU Lesser General Public License,
* version 2.1, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
* more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
* Boston, MA 02111-1307, USA.
*
* Written by: Thomas Wood <thomas@linux.intel.com>
*
*/
#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
#error "Only <st/st.h> can be included directly.h"
#endif
#ifndef __ST_TABLE_CHILD_H__
#define __ST_TABLE_CHILD_H__
#include <st/st-types.h>
#include <st/st-widget.h>
#include <st/st-table.h>
#include <clutter/clutter.h>
G_BEGIN_DECLS
#define ST_TYPE_TABLE_CHILD (st_table_child_get_type ())
#define ST_TABLE_CHILD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_TABLE_CHILD, StTableChild))
#define ST_IS_TABLE_CHILD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_TABLE_CHILD))
#define ST_TABLE_CHILD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_TABLE_CHILD, StTableChildClass))
#define ST_IS_TABLE_CHILD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_TABLE_CHILD))
#define ST_TABLE_CHILD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_TABLE_CHILD, StTableChildClass))
typedef struct _StTableChild StTableChild;
typedef struct _StTableChildClass StTableChildClass;
/**
* StTableChild:
*
* The contents of the this structure are private and should only be accessed
* through the public API.
*/
struct _StTableChild
{
/*< private >*/
ClutterChildMeta parent_instance;
gint col;
gint row;
gint col_span;
gint row_span;
gdouble x_align;
gdouble y_align;
guint allocate_hidden : 1;
guint x_expand : 1;
guint y_expand : 1;
guint x_fill : 1;
guint y_fill : 1;
};
struct _StTableChildClass
{
ClutterChildMetaClass parent_class;
};
GType st_table_child_get_type (void) G_GNUC_CONST;
gint st_table_child_get_col_span (StTable *table,
ClutterActor *child);
void st_table_child_set_col_span (StTable *table,
ClutterActor *child,
gint span);
gint st_table_child_get_row_span (StTable *table,
ClutterActor *child);
void st_table_child_set_row_span (StTable *table,
ClutterActor *child,
gint span);
gboolean st_table_child_get_x_fill (StTable *table,
ClutterActor *child);
void st_table_child_set_x_fill (StTable *table,
ClutterActor *child,
gboolean fill);
gboolean st_table_child_get_y_fill (StTable *table,
ClutterActor *child);
void st_table_child_set_y_fill (StTable *table,
ClutterActor *child,
gboolean fill);
gboolean st_table_child_get_x_expand (StTable *table,
ClutterActor *child);
void st_table_child_set_x_expand (StTable *table,
ClutterActor *child,
gboolean expand);
gboolean st_table_child_get_y_expand (StTable *table,
ClutterActor *child);
void st_table_child_set_y_expand (StTable *table,
ClutterActor *child,
gboolean expand);
StAlign st_table_child_get_x_align (StTable *table,
ClutterActor *child);
void st_table_child_set_x_align (StTable *table,
ClutterActor *child,
StAlign align);
StAlign st_table_child_get_y_align (StTable *table,
ClutterActor *child);
void st_table_child_set_y_align (StTable *table,
ClutterActor *child,
StAlign align);
void st_table_child_set_allocate_hidden (StTable *table,
ClutterActor *child,
gboolean value);
gboolean st_table_child_get_allocate_hidden (StTable *table,
ClutterActor *child);
G_END_DECLS
#endif /* __ST_TABLE_H__ */

36
src/st/st-table-private.h Normal file
View File

@ -0,0 +1,36 @@
/*
* st-private-private.h: Private declarations for StTable
*
* Copyright 2007 OpenedHand
* Copyright 2009 Intel Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU Lesser General Public License,
* version 2.1, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
* more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
* Boston, MA 02111-1307, USA.
*
*/
#ifndef __ST_TABLE_PRIVATE_H__
#define __ST_TABLE_PRIVATE_H__
#include "st-table.h"
G_BEGIN_DECLS
void _st_table_update_row_col (StTable *table,
gint row,
gint col);
G_END_DECLS
#endif /* __ST_TABLE_PRIVATE_H__ */

1475
src/st/st-table.c Normal file
View File

File diff suppressed because it is too large Load Diff

113
src/st/st-table.h Normal file
View File

@ -0,0 +1,113 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* st-table.h: Table layout widget
*
* Copyright 2008, 2009 Intel Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU Lesser General Public License,
* version 2.1, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
* more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
* Boston, MA 02111-1307, USA.
*
* Written by: Thomas Wood <thomas@linux.intel.com>
*
*/
#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
#error "Only <st/st.h> can be included directly.h"
#endif
#ifndef __ST_TABLE_H__
#define __ST_TABLE_H__
#include <st/st-types.h>
#include <st/st-widget.h>
G_BEGIN_DECLS
/**
* StTableChildOptions:
* @ST_KEEP_ASPECT_RATIO: whether to respect the widget's aspect ratio
* @ST_X_EXPAND: whether to allocate extra space on the widget's x-axis
* @ST_Y_EXPAND: whether to allocate extra space on the widget's y-axis
* @ST_X_FILL: whether to stretch the child to fill the cell horizontally
* @ST_Y_FILL: whether to stretch the child to fill the cell vertically
*
* Denotes the child properties an StTable child will have.
*/
typedef enum
{
ST_KEEP_ASPECT_RATIO = 1 << 0,
ST_X_EXPAND = 1 << 1,
ST_Y_EXPAND = 1 << 2,
ST_X_FILL = 1 << 3,
ST_Y_FILL = 1 << 4
} StTableChildOptions;
#define ST_TYPE_TABLE (st_table_get_type ())
#define ST_TABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_TABLE, StTable))
#define ST_IS_TABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_TABLE))
#define ST_TABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_TABLE, StTableClass))
#define ST_IS_TABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_TABLE))
#define ST_TABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_TABLE, StTableClass))
typedef struct _StTable StTable;
typedef struct _StTablePrivate StTablePrivate;
typedef struct _StTableClass StTableClass;
/**
* StTable:
*
* The contents of this structure is private and should only be accessed using
* the provided API.
*/
struct _StTable
{
/*< private >*/
StWidget parent_instance;
StTablePrivate *priv;
};
struct _StTableClass
{
StWidgetClass parent_class;
};
GType st_table_get_type (void) G_GNUC_CONST;
StWidget* st_table_new (void);
void st_table_set_col_spacing (StTable *table,
gint spacing);
void st_table_set_row_spacing (StTable *table,
gint spacing);
gint st_table_get_col_spacing (StTable *table);
gint st_table_get_row_spacing (StTable *table);
void st_table_add_actor (StTable *table,
ClutterActor *actor,
gint row,
gint column);
void st_table_add_actor_with_properties (StTable *table,
ClutterActor *actor,
gint row,
gint column,
const gchar *first_property_name,
...);
gint st_table_get_row_count (StTable *table);
gint st_table_get_column_count (StTable *table);
G_END_DECLS
#endif /* __ST_TABLE_H__ */