Creando Widgets GTK - Historial de revisións

Xavi o 7 de novembro de 2023 ás 17:04

2023-11-07T17:04:52Z

← Revisión máis antiga		Revisión como estaba o 7 de novembro de 2023 ás 17:04
Liña 1:		Liña 1:
	== Estructura dun Widget GTK+ ==		== Estructura dun Widget GTK+ ==
	mm
	GTK+ está programado en C, pero utilizando técnicas de orientación a objxectos. Un widget GTK+ non é máis que unha estructura que conten atributos (variables) e métodos (punteiros a funcións) representando as distintas sinais ás que vai a reaccionar o Widget.		GTK+ está programado en C, pero utilizando técnicas de orientación a objxectos. Un widget GTK+ non é máis que unha estructura que conten atributos (variables) e métodos (punteiros a funcións) representando as distintas sinais ás que vai a reaccionar o Widget.

Xavi o 7 de novembro de 2023 ás 17:04

2023-11-07T17:04:37Z

← Revisión máis antiga		Revisión como estaba o 7 de novembro de 2023 ás 17:04
Liña 1:		Liña 1:
	== Estructura dun Widget GTK+ ==		== Estructura dun Widget GTK+ ==
			mm
	GTK+ está programado en C, pero utilizando técnicas de orientación a objxectos. Un widget GTK+ non é máis que unha estructura que conten atributos (variables) e métodos (punteiros a funcións) representando as distintas sinais ás que vai a reaccionar o Widget.		GTK+ está programado en C, pero utilizando técnicas de orientación a objxectos. Un widget GTK+ non é máis que unha estructura que conten atributos (variables) e métodos (punteiros a funcións) representando as distintas sinais ás que vai a reaccionar o Widget.

Xavi: /* Estructura dun Widget GTK+ */

2019-06-12T09:32:33Z

Estructura dun Widget GTK+

← Revisión máis antiga		Revisión como estaba o 12 de xuño de 2019 ás 09:32
Liña 8:		Liña 8:
	Vexamos un exemplo coa clase GtkButton:		Vexamos un exemplo coa clase GtkButton:

	<source lang='C' style='font-size:90%'>		<source lang='C' style='font-size:80%'>
	// Estructura definindo a nova clase		// Estructura definindo a nova clase
	struct _GtkButtonClass		struct _GtkButtonClass

Xavi o 12 de xuño de 2019 ás 09:32

2019-06-12T09:32:20Z

← Revisión máis antiga		Revisión como estaba o 12 de xuño de 2019 ás 09:32
Liña 8:		Liña 8:
	Vexamos un exemplo coa clase GtkButton:		Vexamos un exemplo coa clase GtkButton:

	<source lang='C' style='font-size:40%'>		<source lang='C' style='font-size:90%'>
	// Estructura definindo a nova clase		// Estructura definindo a nova clase
	struct _GtkButtonClass		struct _GtkButtonClass

Xavi o 12 de xuño de 2019 ás 09:32

2019-06-12T09:32:05Z

← Revisión máis antiga		Revisión como estaba o 12 de xuño de 2019 ás 09:32
Liña 8:		Liña 8:
	Vexamos un exemplo coa clase GtkButton:		Vexamos un exemplo coa clase GtkButton:

	<source lang='C'>		<source lang='C' style='font-size:40%'>
	// Estructura definindo a nova clase		// Estructura definindo a nova clase
	struct _GtkButtonClass		struct _GtkButtonClass

Xavi o 26 de xuño de 2014 ás 09:54

2014-06-26T09:54:21Z

← Revisión máis antiga		Revisión como estaba o 26 de xuño de 2014 ás 09:54
Liña 8:		Liña 8:
	Vexamos un exemplo coa clase GtkButton:		Vexamos un exemplo coa clase GtkButton:

			<source lang='C'>
	<c>
	// Estructura definindo a nova clase		// Estructura definindo a nova clase
	struct _GtkButtonClass		struct _GtkButtonClass
Liña 32:		Liña 32:
	};		};

	</c>		</source>
	Pódese observar claramente que o primeiro campo das estructuras _GtkButtonClass e _GtkButton permiten facer un ''cast'' á clase pai con total seguridade. Tamén podemos observar os atributos dos obxectos en _GtkButton e os punteiros ós tratamentos de sinal en _GtkButtonClass.		Pódese observar claramente que o primeiro campo das estructuras _GtkButtonClass e _GtkButton permiten facer un ''cast'' á clase pai con total seguridade. Tamén podemos observar os atributos dos obxectos en _GtkButton e os punteiros ós tratamentos de sinal en _GtkButtonClass.

Liña 40:		Liña 40:
	=== Ficheiro de Cabeceira ===		=== Ficheiro de Cabeceira ===
	Descargar		Descargar
			<source lang='C'>
	<c>
	/* GtkCalendarButton		/* GtkCalendarButton
	* Copyright (C) 2007 Francisco Javier Taboada Aguado		* Copyright (C) 2007 Francisco Javier Taboada Aguado
Liña 130:		Liña 130:

	#endif /* __GTK_CALENDAR_BUTTON_H__ */		#endif /* __GTK_CALENDAR_BUTTON_H__ */
	</c>		</source>

	=== Implementación ===		=== Implementación ===
	Descargar		Descargar
			<source lang='C'>
	<c>
	/* GtkCalendarButton		/* GtkCalendarButton
	* Copyright (C) 2007 Francisco Javier Taboada Aguado		* Copyright (C) 2007 Francisco Javier Taboada Aguado
Liña 374:		Liña 374:
	#define __GTK_CALENDAR_BUTTON_C__		#define __GTK_CALENDAR_BUTTON_C__

	</c>		</source>

	=== Proba ===		=== Proba ===
	Descargar		Descargar
			<source lang='C'>
	<c>
	/* GtkCalendarButton		/* GtkCalendarButton
	* Copyright (C) 2007 Francisco Javier Taboada Aguado		* Copyright (C) 2007 Francisco Javier Taboada Aguado
Liña 432:		Liña 432:
	}		}

	</c>		</source>

	== Habilitando o Widget no Glade ==		== Habilitando o Widget no Glade ==
Liña 446:		Liña 446:
	=== O Ficheiro de Descrición (Catálogo) ===		=== O Ficheiro de Descrición (Catálogo) ===
	O ficheiro de descrición é un ficheiro XML coa seguinte estructura:		O ficheiro de descrición é un ficheiro XML coa seguinte estructura:
			<source lang='C'>
	<c>
	<glade-catalog name="nome_do_catalogo" library="nome_libraría_dinámica">		<glade-catalog name="nome_do_catalogo" library="nome_libraría_dinámica">

Liña 460:		Liña 460:

	</glade-catalog>		</glade-catalog>
	</c>		</source>

	==== O Tag ''glade-catalog'' ====		==== O Tag ''glade-catalog'' ====
Liña 477:		Liña 477:

	==== Definición de Clases de Widgets ====		==== Definición de Clases de Widgets ====
			<source lang='C'>
	<c>
	<glade-widget-class name="nome_da_clase" generic-name="nome_xenerico_obxecto" title="Nome_na_paleta">		<glade-widget-class name="nome_da_clase" generic-name="nome_xenerico_obxecto" title="Nome_na_paleta">

Liña 494:		Liña 494:
	</children>		</children>
	</glade-widget-class>		</glade-widget-class>
	</c>		</source>

	==== Definición de Grupos ====		==== Definición de Grupos ====
Liña 503:		Liña 503:

	O catálogo para un widget como o do exemplo, é moi sinxelo, e ademáis non precisa de libraría de soporte xa que é moi simple.		O catálogo para un widget como o do exemplo, é moi sinxelo, e ademáis non precisa de libraría de soporte xa que é moi simple.
			<source lang='xml'>
	<c>
	<?xml version="1.0" encoding="UTF-8"?>		<?xml version="1.0" encoding="UTF-8"?>
	<glade-catalog name="gtkcalendarbutton" library="gtkcalendarbutton" domain="glade3" book="gtkcalendarbutton">		<glade-catalog name="gtkcalendarbutton" library="gtkcalendarbutton" domain="glade3" book="gtkcalendarbutton">
Liña 517:		Liña 517:

	</glade-catalog>		</glade-catalog>
	</c>		</source>

	== Referencias ==		== Referencias ==

Xavi: Nova páxina: "== Estructura dun Widget GTK+ == GTK+ está programado en C, pero utilizando técnicas de orientación a objxectos. Un widget GTK+ non é máis que unha estructura que conten atri..."

2014-06-26T09:52:19Z

Nova páxina: "== Estructura dun Widget GTK+ == GTK+ está programado en C, pero utilizando técnicas de orientación a objxectos. Un widget GTK+ non é máis que unha estructura que conten atri..."

Páxina nova

== Estructura dun Widget GTK+ ==
GTK+ está programado en C, pero utilizando técnicas de orientación a objxectos. Un widget GTK+ non é máis que unha estructura que conten atributos (variables) e métodos (punteiros a funcións) representando as distintas sinais ás que vai a reaccionar o Widget.

O primeiro campo da estructura representando un Widget ten que ser a estructura da clase da que descende (herencia) de xeito que se poda facer un ''casting'' á clase pai.

En paralelo a estructura definindo o novo Widget, é necesario crear unha estructura para almacenar a información relativa a cada elemento (obxecto) creado. Dun xeito similar á definición da nova clase Widget, o primeiro campo desta estructura debe ser o obxecto pai.

Vexamos un exemplo coa clase GtkButton:

<c>
// Estructura definindo a nova clase
struct _GtkButtonClass
{
GtkContainerClass parent_class; //Estructura que almacena a clase pai

void (* pressed) (GtkButton *button); // Sitio para os manexadores de sinal
void (* released) (GtkButton *button);
void (* clicked) (GtkButton *button);
void (* enter) (GtkButton *button);
void (* leave) (GtkButton *button);
};

// Estructura definindo o novo obxecto
struct _GtkButton
{
GtkContainer container; // Estructura que conten o obxecto pai

GtkWidget *child;

guint in_button : 1;
guint button_down : 1;
};

</c>
Pódese observar claramente que o primeiro campo das estructuras _GtkButtonClass e _GtkButton permiten facer un ''cast'' á clase pai con total seguridade. Tamén podemos observar os atributos dos obxectos en _GtkButton e os punteiros ós tratamentos de sinal en _GtkButtonClass.

== Creando un Novo Widget: GtkCalendarButton ==
Este widget consistirá nun botón que amosará unha data. O pulsar o botón aparecerá unha ventana emerxente cun calendario que permitirá elexir unha data que será a que se poña no botón.
A clase pai do ''GtkCalendarButton'' será GtkVBoxClass e o obxecto pai GtkVBox, xa que o botón aparecerá nun contedor.
=== Ficheiro de Cabeceira ===
Descargar
<c>
/* GtkCalendarButton
* Copyright (C) 2007 Francisco Javier Taboada Aguado
*
* Esta librería é software libre; poderás redistribuilo e/ou
* modificalo baixo os termos da Licencia Xeral Pública GNU (GPL) tal
* e como indica a Free Software Foundation; baixo a versión 2
* ou posteriores.
*
* Esta librería distribúese coa esperanza de que sexa útil, pero
* SEN NINGUNHA GARANTIA; incluso sen a garantizar a súa adecuación
* para un propósito concreto. Véxase a GPL para máis detalles.
*
* Deberías ter recibida unha copia da GPL xunto con esta librería,
* se non fora así escribe a :
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __GTK_CALENDAR_BUTTON_H__
#define __GTK_CALENDAR_BUTTON_H__

#include <gdk/gdk.h>
#include <gtk/gtkvbox.h>
#include <gtk/gtktogglebutton.h>
#include <gtk/gtkcalendar.h>

G_BEGIN_DECLS

// Declaración dos novos tipos
#define GTK_TYPE_CALENDAR_BUTTON (gtk_calendar_button_get_type ())
#define GTK_CALENDAR_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), \\
GTK_TYPE_CALENDAR_BUTTON, GtkCalendarButton))
#define GTK_CALENDAR_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), \\
GTK_TYPE_CALENDAR_BUTTON, GtkCalendarButtonClass))
#define GTK_IS_CALENDAR_BUTTON(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \\
GTK_TYPE_CALENDAR_BUTTON))
#define GTK_IS_CALENDAR_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), \\
GTK_TYPE_CALENDAR_BUTTON))
#define GTK_CALENDAR_BUTTON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), \\
GTK_TYPE_CALENDAR_BUTTON, GtkCalendarButtonClass))

typedef struct _GtkCalendarButton GtkCalendarButton;
typedef struct _GtkCalendarButtonClass GtkCalendarButtonClass;

// Estructura para o obxecto
struct _GtkCalendarButton
{
GtkVBox ct;

GtkButton *bt;
GtkCalendar *cal;
GtkWindow *win;
};

// Estructura para a clase
struct _GtkCalendarButtonClass
{
GtkVBoxClass parent_class;

void (* calendar_show) (GtkCalendarButton *cbutton); // Sitio para poñer os handlers
void (* calendar_hide) (GtkCalendarButton *cbutton); // Sitio para poñer os handlers
void (* calendar_select) (GtkCalendarButton *cbutton); // Sitio para poñer os handlers

/* Padding for future expansion */
void (*_gtk_reserved1) (void);
void (*_gtk_reserved2) (void);
void (*_gtk_reserved3) (void);
void (*_gtk_reserved4) (void);
};

// Tipo de datos para almacenar as datas
typedef struct tagGtkCBDate {
int dia;
int mes;
int ano;
} GtkCBDate;

// Funcións de uso externo
GType gtk_calendar_button_get_type (void) G_GNUC_CONST;
GtkWidget* gtk_calendar_button_new (void);
GtkWidget *gtk_calendar_button_new_with_date (GtkCBDate *date);
GtkCBDate *gtk_calendar_button_get_date(GtkCalendarButton *cb,GtkCBDate *date);
void gtk_calendar_button_set_date(GtkCalendarButton *cb,GtkCBDate *date);

G_END_DECLS

#endif /* __GTK_CALENDAR_BUTTON_H__ */
</c>

=== Implementación ===
Descargar
<c>
/* GtkCalendarButton
* Copyright (C) 2007 Francisco Javier Taboada Aguado
*
* Esta librería é software libre; poderás redistribuilo e/ou
* modificalo baixo os termos da Licencia Xeral Pública GNU (GPL) tal
* e como indica a Free Software Foundation; baixo a versión 2
* ou posteriores.
*
* Esta librería distribúese coa esperanza de que sexa útil, pero
* SEN NINGUNHA GARANTIA; incluso sen a garantizar a súa adecuación
* para un propósito concreto. Véxase a GPL para máis detalles.
*
* Deberías ter recibida unha copia da GPL xunto con esta librería,
* se non fora así escribe a :
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/

#include <gtk/gtklabel.h>
#include <gtk/gtkmain.h>
#include <gtk/gtksignal.h>
#include <gtk/gtkprivate.h>
#include <gtk/gtkmarshal.h>

#include "gtkcalendarbutton.h"

// Sinais que emite o widget
enum {
GTKCALENDARBUTTONSHOW_SIGNAL,
GTKCALENDARBUTTONHIDE_SIGNAL,
GTKCALENDARBUTTONSELECT_SIGNAL,
LAST_SIGNAL
};

static void gtk_calendar_button_class_init (GtkCalendarButtonClass *class);
static void gtk_calendar_button_init (GtkCalendarButton *calendar_button);

static void gtk_calendar_button_pressed (GtkButton *button);
static void gtk_calendar_button_released (GtkButton *button);
static void gtk_calendar_button_clicked (GtkButton *button);
static gboolean gtk_calendar_button_press_event( GtkWidget *widget, GtkCalendarButton *calendar_button );
static gboolean gtk_calendar_button_day_selected( GtkWidget *widget, GtkCalendarButton *calendar_button );

char *parseDate(GtkCBDate *date,char *buffer);

// Táboa para garda-los sinais.
static guint calendar_button_signals[LAST_SIGNAL] = { 0 };

// Definimos GtkCalendarButton como heredada de VBOX.
G_DEFINE_TYPE (GtkCalendarButton, gtk_calendar_button, GTK_TYPE_VBOX)

/* Inicialización da clase.
*
* Aquí sobreescribimos métodos da clase e creamos os sinais.
*/
static void gtk_calendar_button_class_init (GtkCalendarButtonClass *class)
{
GObjectClass *gobject_class;

gobject_class = G_OBJECT_CLASS (class);
/* Poderíamos acceder ós métodos das clases pais para modifica-lo seu comportamento.

GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
GtkVBoxClass *vbox_class;

widget_class = (GtkWidgetClass*) class;
container_class = (GtkContainerClass*) class;
vbox_class = (GtkVBoxClass*) class;

gobject_class->set_property = gtk_calendar_button_set_property;
gobject_class->get_property = gtk_calendar_button_get_property;

widget_class->expose_event = gtk_calendar_button_expose;
widget_class->mnemonic_activate = gtk_calendar_button_mnemonic_activate;
*/

class->calendar_show = NULL;
class->calendar_hide = NULL;
class->calendar_select = NULL;

calendar_button_signals[GTKCALENDARBUTTONSHOW_SIGNAL] =
g_signal_new ("calendar_show",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCalendarButtonClass, calendar_show),
NULL, NULL,
gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);

calendar_button_signals[GTKCALENDARBUTTONHIDE_SIGNAL] =
g_signal_new ("calendar_hide",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCalendarButtonClass, calendar_hide),
NULL, NULL,
gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
calendar_button_signals[GTKCALENDARBUTTONSELECT_SIGNAL] =
g_signal_new ("calendar_select",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkCalendarButtonClass, calendar_select),
g_signal_accumulator_true_handled, NULL,
gtk_marshal_BOOLEAN__POINTER,
G_TYPE_BOOLEAN, 1,GTK_TYPE_POINTER);
}

/* Auxiliar
* A partir dunha data numérica devolve unha representación alfabética
* TODO: Internacionalización.
*/
char *parseDate(GtkCBDate *date,char *buffer)
{
char *meses[]={"Xaneiro","Febreiro","Marzo","Abril","Maio","Xuño","Xullo","Agosto",
"Setembro","Outubre","Novembro","Decembro"};

snprintf(buffer,255,"%d de %s de %d",date->dia,meses[(date->mes)-1],date->ano);
return buffer;
}
/***************/

/* Inicialización do Obxecto
*
* Aquí creamos os atributos do obxecto.
*
*/
static void gtk_calendar_button_init (GtkCalendarButton *calendar_button)
{
int dia,mes,ano;
GtkCBDate date;
char buffer[256];

// Creamos unha ventana popup e incrustamos un calendario nela
calendar_button->win=(GtkWindow *)gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_position(calendar_button->win,GTK_WIN_POS_MOUSE);
calendar_button->cal=(GtkCalendar *)gtk_calendar_new();
gtk_container_add(GTK_CONTAINER(calendar_button->win),GTK_WIDGET(calendar_button->cal));

// Creamos o botón e o poñemos no widget (é da clase VBox..)
calendar_button->bt=(GtkButton *)gtk_button_new();
gtk_container_add(GTK_CONTAINER(calendar_button),GTK_WIDGET(calendar_button->bt));

// Conectamos as sinais de clicked do botón e de seleccionar unha data no calendario con doble click.
g_signal_connect(G_OBJECT(calendar_button->bt),"clicked",
G_CALLBACK(gtk_calendar_button_press_event),(gpointer)calendar_button);

g_signal_connect(G_OBJECT(calendar_button->cal),"day_selected_double_click",
G_CALLBACK(gtk_calendar_button_day_selected),(gpointer)calendar_button);

// Ocultamos o calendario, e poñemos a data de hoxe como etiqueta do botón
gtk_widget_hide(GTK_WIDGET(calendar_button->win));
gtk_calendar_get_date(calendar_button->cal,&date.ano,&date.mes,&date.dia);
date.mes++;
gtk_button_set_label(calendar_button->bt,parseDate(&date,buffer));

// Facemos visible o botón.
gtk_widget_show_all(GTK_WIDGET(calendar_button->bt));
}

/* Crea un novo obxecto gtk_calendar_button
*
*/
GtkWidget*gtk_calendar_button_new (void)
{
return g_object_new (GTK_TYPE_CALENDAR_BUTTON, NULL);
}

/* Crea un novo obxecto gtk_calendar_button coa data indicada
*
*/
GtkWidget *gtk_calendar_button_new_with_date (GtkCBDate *date)
{
GtkWidget *w;

w=gtk_calendar_button_new();
gtk_calendar_button_set_date(GTK_CALENDAR_BUTTON(w),date);
return w;
}
/* O usuario fixo un doble click nunha data. Cambiamos a etiqueta do botón e ocultamos o calendario
*
*/
static gboolean gtk_calendar_button_day_selected( GtkWidget *widget, GtkCalendarButton *calendar_button )
{
GtkCBDate date;
char buffer[256];
gboolean ret;

// Recuperamos a data
gtk_calendar_get_date(calendar_button->cal,&date.ano,&date.mes,&date.dia);
date.mes++;
// Sinal de seleccionada a data.
g_signal_emit (G_OBJECT(calendar_button),calendar_button_signals[GTKCALENDARBUTTONSELECT_SIGNAL], 0,&date,&ret);
if (!ret) // Se devolve TRUE, non fago nada
{
gtk_button_set_label(calendar_button->bt,parseDate(&date,buffer));
// Sinal de ocultar
g_signal_emit (G_OBJECT(calendar_button),calendar_button_signals[GTKCALENDARBUTTONHIDE_SIGNAL], 0);
gtk_widget_hide(GTK_WIDGET(calendar_button->win));
}
return TRUE;
}

/* O usuario fixo click no botón de abrir o calendario
*
*/
static gboolean gtk_calendar_button_press_event( GtkWidget *widget, GtkCalendarButton *calendar_button ) {
// Sinal de Amosar
g_signal_emit (G_OBJECT(calendar_button),calendar_button_signals[GTKCALENDARBUTTONHIDE_SIGNAL], 0);
gtk_widget_show_all(GTK_WIDGET(calendar_button->win));
return TRUE;
}

/* Devolve a data do botón
*
*/
GtkCBDate *gtk_calendar_button_get_date(GtkCalendarButton *cb,GtkCBDate *date)
{
gtk_calendar_get_date(cb->cal,&(date->ano),&(date->mes),&(date->dia));
date->mes++;
return date;
}

/* Pon unha data no botón
*
*/
void gtk_calendar_button_set_date(GtkCalendarButton *cb,GtkCBDate *date)
{
char buffer[256];

gtk_calendar_select_month(cb->cal,(date->mes)-1,date->ano);
gtk_calendar_select_day(cb->cal,date->dia);
gtk_button_set_label(cb->bt,parseDate(date,buffer));
}

#define __GTK_CALENDAR_BUTTON_C__

</c>

=== Proba ===
Descargar
<c>
/* GtkCalendarButton
* Copyright (C) 2007 Francisco Javier Taboada Aguado
*
* Esta librería é software libre; poderás redistribuilo e/ou
* modificalo baixo os termos da Licencia Xeral Pública GNU (GPL) tal
* e como indica a Free Software Foundation; baixo a versión 2
* ou posteriores.
*
* Esta librería distribúese coa esperanza de que sexa útil, pero
* SEN NINGUNHA GARANTIA; incluso sen a garantizar a súa adecuación
* para un propósito concreto. Véxase a GPL para máis detalles.
*
* Deberías ter recibida unha copia da GPL xunto con esta librería,
* se non fora así escribe a :
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/

#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include "gtkcalendarbutton.h"

gboolean seleccionada(GtkCalendarButton *cb,GtkCBDate *d)
{
printf("Seleccionada %d/%d/%d!!!\n",d->dia,d->mes,d->ano);
return FALSE;
}

int main( int argc,char *argv[])
{
GtkWidget *window;
GtkWidget *cb;

gtk_init (&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Dial");
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (exit), NULL);

gtk_container_set_border_width (GTK_CONTAINER (window), 10);

cb=gtk_calendar_button_new();
gtk_container_add (GTK_CONTAINER (window), cb);
g_signal_connect(G_OBJECT(cb),"calendar_select",G_CALLBACK(seleccionada),NULL);

gtk_widget_show_all (window);

gtk_main ();

return 0;
}

</c>

== Habilitando o Widget no Glade ==
Esta característica so está dispoñible a partir do Glade-3.

=== Introducción ===
A partir do Glade-3 é posible incorporar novos Widgets á paleta e manexalos co interface engadindo "plugins". Un "plugin" consiste nun ficheiro de descrición, unha librería dinámica e as iconas para os novos widgets na paleta e no árbol de widgets.

A meirande parte das propiedades dos widgets poden manexarse dun xeito automático, pero pode ser necesario código para algunhas porpiedades avanzadas. Todo esto se especifica no ficheiro de descrición onde se poden especificar valores por defecto, propiedades non visibles, funcións específicas a chamar... etc.

O ficheiro de descrición tamén se utiliza para agrupar widgets en categorías que se amosarán na paleta de glade-3.

=== O Ficheiro de Descrición (Catálogo) ===
O ficheiro de descrición é un ficheiro XML coa seguinte estructura:
<c>
<glade-catalog name="nome_do_catalogo" library="nome_libraría_dinámica">

<init-function>función de inicialización</init-function>

<glade-widget-classes>

... definición dos widgets

</glade-widget-classes>

... definición dos grupos

</glade-catalog>
</c>

==== O Tag ''glade-catalog'' ====
===== Propiedades Obrigatorias =====
*''name'': E unha cadea de caracteres identificando o catálogo.
*''library'': E o nome da librería que se instalará en $prefix/lib/glade-3/modules

===== Propiedades Opcionais =====
*''depends'': Utilízase para indicar a herencia do widget poñendo o 'name' do catálogo necesario. Normalmente indicarase ''depends="gtk+"''.
*''domain'': Dominio para o soporte multilinguaxe GTK.
*''book'': Espacio de nomes para a documentación mediante gtk-doc.
*''fixed'': Para permitir que o widget sexa manexado co administrador de deseño GtkFixed.

==== O Tag ''init-function'' ====
Utilízase para dar un puntode entrada global o plugin. Se chamará antes que se cree calquera widget do catálogo.

==== Definición de Clases de Widgets ====
<c>
<glade-widget-class name="nome_da_clase" generic-name="nome_xenerico_obxecto" title="Nome_na_paleta">

... Funcións de soporte do widget

<properties>

... definición de propidades

</properties>

<children>

... descrición dos fillos

</children>
</glade-widget-class>
</c>

==== Definición de Grupos ====
=== Instalación ===
*Copiar o catálogo a /usr/share/glade3/catalogs/
*Copiar o icono a /usr/share/glade3/pixmaps/22x22/
*Copiar a librería a /usr/lib/glade3/modules/

O catálogo para un widget como o do exemplo, é moi sinxelo, e ademáis non precisa de libraría de soporte xa que é moi simple.
<c>
<?xml version="1.0" encoding="UTF-8"?>
<glade-catalog name="gtkcalendarbutton" library="gtkcalendarbutton" domain="glade3" book="gtkcalendarbutton">

<glade-widget-classes>
<glade-widget-class name="GtkCalendarButton" generic-name="gtkcalendarbutton" title="Calendar">
</glade-widget-class>
</glade-widget-classes>

<glade-widget-group name="Custom" title="Widget Personais">
<glade-widget-class-ref name="GtkCalendarButton"/>
</glade-widget-group>

</glade-catalog>
</c>

== Referencias ==
Este tutorial é básicamente unha traducción do [http://www.gtk.org/tutorial/x2191.html tutorial de gtk.org]