The SSH host key has changed on 8 April, 2022 to this one: SHA256:573uTBSeh74kvOo0HJXi5ijdzRm8me27suzNEDlGyrQ
Browse Source

Initial commit

This is the latest version found at
http://scentric.net/tutorial/treeview-tutorial-xml.tar.gz
master
Gergely Polonkai 8 years ago
commit
aa71f8211d
  1. 111
      Makefile
  2. 1067
      docbook-utils-a4.dsl
  3. 18
      examples/Makefile
  4. 12
      examples/cell-renderer-spin/Makefile
  5. 361
      examples/cell-renderer-spin/cellrendererspin.c
  6. 70
      examples/cell-renderer-spin/cellrendererspin.h
  7. 144
      examples/cell-renderer-spin/main.c
  8. 12
      examples/custom-cell-renderer/Makefile
  9. 353
      examples/custom-cell-renderer/custom-cell-renderer-progressbar.c
  10. 55
      examples/custom-cell-renderer/custom-cell-renderer-progressbar.h
  11. 114
      examples/custom-cell-renderer/main.c
  12. 12
      examples/custom-list-model-sorted/Makefile
  13. 951
      examples/custom-list-model-sorted/custom-list.c
  14. 107
      examples/custom-list-model-sorted/custom-list.h
  15. 98
      examples/custom-list-model-sorted/main.c
  16. 12
      examples/custom-list-model/Makefile
  17. 664
      examples/custom-list-model/custom-list.c
  18. 97
      examples/custom-list-model/custom-list.h
  19. 80
      examples/custom-list-model/main.c
  20. 14
      examples/hello-world/Makefile
  21. 105
      examples/hello-world/hello-world.c
  22. 12
      examples/simple-list/Makefile
  23. 231
      examples/simple-list/list.c
  24. 12
      examples/tree-model-filter/Makefile
  25. BIN
      examples/tree-model-filter/filter-rows
  26. 2885
      examples/tree-model-filter/guitreemodelfilter.c
  27. 104
      examples/tree-model-filter/guitreemodelfilter.h
  28. BIN
      examples/tree-model-filter/guitreemodelfilter.o
  29. 228
      examples/tree-model-filter/main-filter-rows.c
  30. BIN
      examples/tree-model-filter/main-filter-rows.o
  31. 14
      examples/treeview-demo/Makefile
  32. BIN
      examples/treeview-demo/icon.png
  33. 123
      examples/treeview-demo/main-icon-with-text.c
  34. 178
      examples/treeview-demo/main.c
  35. 14252
      images/cell-renderer-properties.eps
  36. BIN
      images/cell-renderer-properties.png
  37. 2398
      images/renderer.eps
  38. BIN
      images/renderer.png
  39. 14183
      images/tree-view-column.eps
  40. BIN
      images/tree-view-column.png
  41. 3248
      images/treepath.eps
  42. BIN
      images/treepath.png
  43. 10
      treeview-tutorial.css
  44. 7849
      treeview-tutorial.xml

111
Makefile

@ -0,0 +1,111 @@
DOCBASE = treeview-tutorial
DOCEXT = xml
DOCFILE = $(DOCBASE).$(DOCEXT)
SRCBASE = $(DOCBASE)-$(DOCEXT)
default:
@echo
@echo "Makefile targets: html pdf ps force clean check"
@echo
@echo " e.g. make html will create a html version of the tutorial."
@echo
html: $(DOCFILE) docbook-utils-a4.dsl treeview-tutorial.css
db2html --dsl docbook-utils-a4.dsl#html $(DOCFILE) ; \
test -d html && rm -rf ./html/; \
mv $(DOCBASE) html ; \
mkdir html/images; \
cp images/*.png html/images
cp treeview-tutorial.css html/
cat html/treeview-tutorial.html | sed -e 's%</head%<meta name="keywords" content="gtk tree view,treeview,gtk,GtkTreeView,tutorial,documentation,help,introduction,FAQ"><meta name="description" content="Gtk Tree View tutorial"></head%i' > tmp.html
mv tmp.html html/treeview-tutorial.html
pdf: $(DOCFILE)
db2pdf --dsl "docbook-utils-a4.dsl#print" $(DOCFILE)
ps: $(DOCFILE)
db2ps --dsl "docbook-utils-a4.dsl#print" $(DOCFILE)
force:
touch $(DOCFILE) && make html
clean:
rm -rf ./html/ 2>/dev/null
rm -f $(DOCBASE).ps $(DOCBASE).pdf $(DOCBASE).out $(DOCBASE).aux $(DOCBASE).dvi $(DOCBASE).log 2>/dev/null
rm -f examples.tar.gz 2>/dev/null
rm -f *~ 2>/dev/null
rm -rf $(SRCBASE)/ $(SRCBASE).tar.gz 2>/dev/null
check: $(DOCFILE)
xmllint --valid --noout $(DOCFILE)
examples.tar.gz: examples
( test -e examples.tar.gz && rm examples.tar.gz ) || /bin/true
cd examples/ && make clean && cd ..
tar --exclude CVS --exclude .cvsignore -cf examples.tar examples/
gzip examples.tar
src: $(DOCFILE) docbook-utils-a4.dsl treeview-tutorial.css images check
rm -rf $(SRCBASE)/ $(SRCBASE).tar $(SRCBASE).tar.gz 2>/dev/null || /bin/null
mkdir $(SRCBASE)/
cp -R Makefile $(DOCFILE) docbook-utils-a4.dsl treeview-tutorial.css images/ $(SRCBASE)/
tar --exclude CVS --exclude .cvsignore -cf $(SRCBASE).tar $(SRCBASE)/*
gzip $(SRCBASE).tar
dist: html examples
rm -rf treeview-tutorial/ 2>/dev/null || /bin/true
mkdir treeview-tutorial/
rm html/examples.tar.gz 2>/dev/null || /bin/true
cp -R html/ treeview-tutorial/
cp -R examples/ treeview-tutorial/
rm treeview-tutorial.tar.gz 2>/dev/null || /bin/true
tar --exclude CVS --exclude .cvsignore -cf treeview-tutorial.tar treeview-tutorial/
gzip treeview-tutorial.tar
rm -rf treeview-tutorial/
#upload: examples.tar.gz dist html src pdf
# mv examples.tar.gz html/
# mv treeview-tutorial.tar.gz html/
# mv $(SRCBASE).tar.gz html/
# mv $(DOCBASE).pdf html/
# cd html/ && rm -f uploadball.tar && tar cf ../uploadball.tar *html *css examples.tar.gz treeview-tutorial.tar.gz $(SRCBASE).tar.gz $(DOCBASE).pdf images/*png
# rm -f uploadball.tar.bz2
# bzip2 uploadball.tar
# scp uploadball.tar.bz2 uberdork@scentric.sourceforge.net:/home/groups/s/sc/scentric/htdocs/temp/tutorial/
# ssh uberdork@scentric.sourceforge.net "cd /home/groups/s/sc/scentric/htdocs/temp/tutorial && tar xjf uploadball.tar.bz2 && rm uploadball.tar.bz2"
# echo "**** Done. "
upload-html: html
rsync -Cavz \
--rsh="ssh -l uberdork" \
./html/* \
uberdork@shell.sourceforge.net:/home/groups/s/sc/scentric/htdocs/tutorial/
upload: clean upload-html examples.tar.gz src pdf dist
rsync -Cav \
--rsh="ssh -l uberdork" \
./examples.tar.gz \
./$(SRCBASE).tar.gz \
./$(DOCBASE).pdf \
./treeview-tutorial.tar.gz \
uberdork@shell.sourceforge.net:/home/groups/s/sc/scentric/htdocs/tutorial/
#upload: examples.tar.gz dist html src pdf
# mv examples.tar.gz html/
# mv treeview-tutorial.tar.gz html/
# mv $(SRCBASE).tar.gz html/
# mv $(DOCBASE).pdf html/
# cd html/ && rm -f uploadball.tar && tar cf ../uploadball.tar *html *css examples.tar.gz treeview-tutorial.tar.gz $(SRCBASE).tar.gz $(DOCBASE).pdf images/*png
# rm -f uploadball.tar.bz2
# bzip2 uploadball.tar
# scp uploadball.tar.bz2 uberdork@scentric.sourceforge.net:/home/groups/s/sc/scentric/htdocs/temp/tutorial/
# ssh uberdork@scentric.sourceforge.net "cd /home/groups/s/sc/scentric/htdocs/temp/tutorial && tar xjf uploadball.tar.bz2 && rm uploadball.tar.bz2"
# echo "**** Done. "

1067
docbook-utils-a4.dsl

File diff suppressed because it is too large Load Diff

18
examples/Makefile

@ -0,0 +1,18 @@
SUBDIRS = cell-renderer-spin \
custom-cell-renderer \
custom-list-model \
custom-list-model-sorted \
hello-world \
simple-list \
treeview-demo
all: $(SUBDIRS)
for dir in $(SUBDIRS); do\
cd $$dir && make && cd ..;\
done; \
clean: $(SUBDIRS)
for dir in $(SUBDIRS); do\
cd $$dir && make clean && cd ..;\
done;
rm -f `find -name "*~"` || /bin/true

12
examples/cell-renderer-spin/Makefile

@ -0,0 +1,12 @@
CC = gcc
OBJS = main.o cellrendererspin.o
CFLAGS = -g -O2 `pkg-config --cflags gtk+-2.0`
spinbuttonrenderer: $(OBJS)
gcc -o spinbuttonrenderer $(OBJS) `pkg-config --libs gtk+-2.0`
clean:
rm $(OBJS) spinbuttonrenderer 2>/dev/null || /bin/true

361
examples/cell-renderer-spin/cellrendererspin.c

@ -0,0 +1,361 @@
/***************************************************************************
cellrendererspin.c
------------------
begin : Tue Oct 21 2003
copyright : (C) 2003 by Tim-Philipp Müller
email : t.i.m at orange dot net
***************************************************************************/
/***************************************************************************
* *
* 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 is a dirty 15-minute hack that tries to
* make editable cells with spin buttons instead
* of the text entry widget.
*
* Modify how you please. At the moment you need
* to hook up your own cell data function to make
* sure that the number of digits is the same in
* editing mode as it is in non-editing mode.
*
* The parameters passed to _new() should probably
* be properties, and probably we don't need most
* of them anyway. Also, it would be good if there
* was a better method to ensure that the number
* of digits is the same without this.
*
* Maybe one should just rip out the whole _render
* stuff from GtkCellRendererText and make a
* whole new specialised GtkCellRenderFloat
* or something.
*
* If anyone ever completes this code to sth useful,
* or achieves sth similar in another way, or has
* any comments on it, please drop me a mail.
*/
#include "cellrendererspin.h"
#include <gtk/gtkadjustment.h>
#include <gtk/gtkspinbutton.h>
#include <stdlib.h>
#define GUI_CELL_RENDERER_SPIN_PATH "gui-cell-renderer-spin-path"
#define GUI_CELL_RENDERER_SPIN_INFO "gui-cell-renderer-spin-info"
/* Some boring function declarations: GObject type system stuff */
static void gui_cell_renderer_spin_init (GuiCellRendererSpin *cellspin);
static void gui_cell_renderer_spin_class_init (GuiCellRendererSpinClass *klass);
static void gui_cell_renderer_spin_finalize (GObject *gobject);
static gpointer parent_class;
static GtkCellEditable *gui_cell_renderer_spin_start_editing (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags);
struct _GCRSpinInfo
{
gulong focus_out_id;
};
typedef struct _GCRSpinInfo GCRSpinInfo;
/***************************************************************************
*
* gui_cell_renderer_spin_get_type
*
* Here we register our type with the GObject type system if we
* haven't done so yet. Everything else is done in the callbacks.
*
***************************************************************************/
GType
gui_cell_renderer_spin_get_type (void)
{
static GType cell_spin_type = 0;
if (cell_spin_type)
return cell_spin_type;
if (1)
{
static const GTypeInfo cell_spin_info =
{
sizeof (GuiCellRendererSpinClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gui_cell_renderer_spin_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GuiCellRendererSpin),
0, /* n_preallocs */
(GInstanceInitFunc) gui_cell_renderer_spin_init,
};
/* Derive from GtkCellRenderer */
cell_spin_type = g_type_register_static (GTK_TYPE_CELL_RENDERER_TEXT,
"GuiCellRendererSpin",
&cell_spin_info,
0);
}
return cell_spin_type;
}
/***************************************************************************
*
* gui_cell_renderer_spin_init
*
* Set some default properties of the parent (GtkCellRendererText).
*
***************************************************************************/
static void
gui_cell_renderer_spin_init (GuiCellRendererSpin *cellrendererspin)
{
return;
}
/***************************************************************************
*
* gui_cell_renderer_spin_class_init:
*
***************************************************************************/
static void
gui_cell_renderer_spin_class_init (GuiCellRendererSpinClass *klass)
{
GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS(klass);
GObjectClass *object_class = G_OBJECT_CLASS(klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = gui_cell_renderer_spin_finalize;
/* Override the cell renderer's edit-related methods */
cell_class->start_editing = gui_cell_renderer_spin_start_editing;
}
/***************************************************************************
*
* gui_cell_renderer_spin_finalize: free any resources here
*
***************************************************************************/
static void
gui_cell_renderer_spin_finalize (GObject *object)
{
/*
GuiCellRendererSpin *cellrendererspin = GUI_CELL_RENDERER_SPIN(object);
*/
/* Free any dynamically allocated resources here */
/* chain up to parent class to make sure
* they release all their memory as well */
(* G_OBJECT_CLASS (parent_class)->finalize) (object);
}
/***************************************************************************
*
* gui_cell_renderer_spin_new
*
* return a new cell renderer instance
* (all the parameters should really be properties)
*
* Not sure which of all these values are really
* relevant for the spin button - needs checking!
*
***************************************************************************/
GtkCellRenderer *
gui_cell_renderer_spin_new (gdouble lower,
gdouble upper,
gdouble step_inc,
gdouble page_inc,
gdouble page_size,
gdouble climb_rate,
guint digits)
{
GtkCellRenderer *cell;
GuiCellRendererSpin *spincell;
cell = g_object_new(GUI_TYPE_CELL_RENDERER_SPIN, NULL);
spincell = GUI_CELL_RENDERER_SPIN(cell);
spincell->lower = lower;
spincell->upper = upper;
spincell->step_inc = step_inc;
spincell->page_inc = page_inc;
spincell->page_size = page_size;
spincell->climb_rate = climb_rate;
spincell->digits = digits;
return cell;
}
/***************************************************************************
*
* gui_cell_renderer_spin_editing_done
*
***************************************************************************/
static void
gui_cell_renderer_spin_editing_done (GtkCellEditable *spinbutton,
gpointer data)
{
const gchar *path;
const gchar *new_text;
GCRSpinInfo *info;
info = g_object_get_data (G_OBJECT (data), GUI_CELL_RENDERER_SPIN_INFO);
if (info->focus_out_id > 0)
{
g_signal_handler_disconnect (spinbutton, info->focus_out_id);
info->focus_out_id = 0;
}
if (GTK_ENTRY(spinbutton)->editing_canceled)
return;
path = g_object_get_data (G_OBJECT (spinbutton), GUI_CELL_RENDERER_SPIN_PATH);
new_text = gtk_entry_get_text (GTK_ENTRY(spinbutton));
g_signal_emit_by_name(data, "edited", path, new_text);
}
/***************************************************************************
*
* gui_cell_renderer_spin_focus_out_event
*
***************************************************************************/
static gboolean
gui_cell_renderer_spin_focus_out_event (GtkWidget *spinbutton,
GdkEvent *event,
gpointer data)
{
gui_cell_renderer_spin_editing_done (GTK_CELL_EDITABLE (spinbutton), data);
/* entry needs focus-out-event */
return FALSE;
}
/***************************************************************************
*
* gui_cell_renderer_spin_start_editing
*
***************************************************************************/
static gboolean
onButtonPress (GtkWidget *spinbutton, GdkEventButton *bevent, gpointer data)
{
if (bevent->button == 1 && bevent->type == GDK_2BUTTON_PRESS || bevent->type == GDK_3BUTTON_PRESS)
{
g_print ("double or triple click caught and ignored.\n");
return TRUE; /* don't invoke other handlers */
}
return FALSE;
}
/***************************************************************************
*
* gui_cell_renderer_spin_start_editing
*
***************************************************************************/
static GtkCellEditable *
gui_cell_renderer_spin_start_editing (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GtkCellRendererText *celltext;
GuiCellRendererSpin *spincell;
GtkAdjustment *adj;
GtkWidget *spinbutton;
GCRSpinInfo *info;
gdouble curval = 0.0;
celltext = GTK_CELL_RENDERER_TEXT(cell);
spincell = GUI_CELL_RENDERER_SPIN(cell);
/* If the cell isn't editable we return NULL. */
if (celltext->editable == FALSE)
return NULL;
spinbutton = g_object_new (GTK_TYPE_SPIN_BUTTON, "has_frame", FALSE, "numeric", TRUE, NULL);
/* dirty */
if (celltext->text)
curval = atof(celltext->text);
adj = GTK_ADJUSTMENT(gtk_adjustment_new(curval,
spincell->lower,
spincell->upper,
spincell->step_inc,
spincell->page_inc,
spincell->page_size));
gtk_spin_button_configure(GTK_SPIN_BUTTON(spinbutton), adj, spincell->climb_rate, spincell->digits);
g_object_set_data_full (G_OBJECT(spinbutton), GUI_CELL_RENDERER_SPIN_PATH, g_strdup (path), g_free);
gtk_editable_select_region (GTK_EDITABLE (spinbutton), 0, -1);
gtk_widget_show (spinbutton);
g_signal_connect (spinbutton, "editing_done",
G_CALLBACK (gui_cell_renderer_spin_editing_done),
celltext);
/* hack trying to catch the quite annoying effect
* a double click has while editing */
g_signal_connect (spinbutton, "button_press_event",
G_CALLBACK (onButtonPress),
NULL);
info = g_new0(GCRSpinInfo, 1);
info->focus_out_id = g_signal_connect (spinbutton, "focus_out_event",
G_CALLBACK (gui_cell_renderer_spin_focus_out_event),
celltext);
g_object_set_data_full (G_OBJECT (cell), GUI_CELL_RENDERER_SPIN_INFO, info, g_free);
return GTK_CELL_EDITABLE (spinbutton);
}

70
examples/cell-renderer-spin/cellrendererspin.h

@ -0,0 +1,70 @@
/***************************************************************************
cellrendererspin.h
------------------
begin : Tue Oct 21 2003
copyright : (C) 2003 by Tim-Philipp Müller
email : t.i.m at orange dot net
***************************************************************************/
/***************************************************************************
* *
* 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. *
* *
***************************************************************************/
#ifndef _cellrendererspin_h_included_
#define _cellrendererspin_h_included_
#include <gtk/gtkcellrenderertext.h>
/* Some boilerplate GObject type check and type cast macros */
#define GUI_TYPE_CELL_RENDERER_SPIN (gui_cell_renderer_spin_get_type())
#define GUI_CELL_RENDERER_SPIN(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUI_TYPE_CELL_RENDERER_SPIN, GuiCellRendererSpin))
#define GUI_CELL_RENDERER_SPIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GUI_TYPE_CELL_RENDERER_SPIN, GuiCellRendererSpinClass))
#define GUI_IS_CELL_RENDERER_SPIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GUI_TYPE_CELL_RENDERER_SPIN))
#define GUI_IS_CELL_RENDERER_SPIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GUI_TYPE_CELL_RENDERER_SPIN))
#define GUI_CELL_RENDERER_SPIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GUI_TYPE_CELL_RENDERER_SPIN, GuiCellRendererSpinClass))
typedef struct _GuiCellRendererSpin GuiCellRendererSpin;
typedef struct _GuiCellRendererSpinClass GuiCellRendererSpinClass;
struct _GuiCellRendererSpin
{
GtkCellRendererText parent;
gdouble lower;
gdouble upper;
gdouble step_inc;
gdouble page_inc;
gdouble page_size;
gdouble climb_rate;
guint digits;
};
struct _GuiCellRendererSpinClass
{
GtkCellRendererTextClass parent_class;
};
GType gui_cell_renderer_spin_get_type (void);
GtkCellRenderer *gui_cell_renderer_spin_new (gdouble lower,
gdouble upper,
gdouble step_inc,
gdouble page_inc,
gdouble page_size,
gdouble climb_rate,
guint digits);
#endif /* _spinbar_renderer_h_included_ */

144
examples/cell-renderer-spin/main.c

@ -0,0 +1,144 @@
/* a simple test for GuiCellRendererSpin */
#include <gtk/gtk.h>
#include "cellrendererspin.h"
enum
{
COL_NAME = 0,
COL_NUMBER,
NUM_COLS
} ;
static GtkTreeModel *
create_and_fill_model (void)
{
GtkListStore *liststore;
GtkTreeIter iter;
liststore = gtk_list_store_new(NUM_COLS, G_TYPE_STRING, G_TYPE_FLOAT);
gtk_list_store_append(liststore, &iter);
gtk_list_store_set(liststore, &iter, COL_NAME, "M J Smith", COL_NUMBER, 5.0, -1);
gtk_list_store_append(liststore, &iter);
gtk_list_store_set(liststore, &iter, COL_NAME, "K F Hemmingwinski", COL_NUMBER, 3.8, -1);
gtk_list_store_append(liststore, &iter);
gtk_list_store_set(liststore, &iter, COL_NAME, "P C Juanicini", COL_NUMBER, 2.5, -1);
return GTK_TREE_MODEL(liststore);
}
static void
cell_data_func_gpa (GtkTreeViewColumn *col,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer data)
{
gchar buf[32];
GValue val = {0, };
gtk_tree_model_get_value(model, iter, COL_NUMBER, &val);
g_snprintf(buf, sizeof(buf), "%.1f", g_value_get_float(&val));
g_object_set(cell, "text", buf, NULL);
}
static void
on_gpa_edited (GtkCellRendererText *celltext,
const gchar *string_path,
const gchar *new_text,
gpointer data)
{
GtkTreeModel *model = GTK_TREE_MODEL(data);
GtkTreeIter iter;
gchar *name = NULL;
gfloat oldval = 0.0;
gfloat newval = 0.0;
gtk_tree_model_get_iter_from_string(model, &iter, string_path);
gtk_tree_model_get(model, &iter, COL_NAME, &name, COL_NUMBER, &oldval, -1);
if (sscanf(new_text, "%f", &newval) != 1)
g_warning("in %s: problem converting string '%s' into float.\n", __FUNCTION__, new_text);
g_print ("%s: old GPA = %.1f, new GPA = %.1f ('%s')\n", name, oldval, newval, new_text);
gtk_list_store_set(GTK_LIST_STORE(model), &iter, COL_NUMBER, newval, -1);
g_free(name);
}
static GtkWidget *
create_view_and_model (void)
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *view;
GtkTreeModel *model;
view = gtk_tree_view_new();
model = create_and_fill_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
g_object_unref(model); /* destroy model automatically with view */
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_SINGLE);
/* --- Column #1 --- */
col = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_set_title(col, "Name");
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
/* --- Column #2 --- */
col = gtk_tree_view_column_new();
renderer = gui_cell_renderer_spin_new(0.0, 5.0, 0.1, 1.0, 1.0, 0.1, 1);
gtk_tree_view_column_set_title(col, "GPA");
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(col, renderer, cell_data_func_gpa, NULL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
g_object_set(renderer, "editable", TRUE, NULL);
g_signal_connect(renderer, "edited", G_CALLBACK(on_gpa_edited), model);
return view;
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *view;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "delete_event", gtk_main_quit, NULL); /* dirty */
view = create_view_and_model();
gtk_container_add(GTK_CONTAINER(window), view);
gtk_widget_show_all(window);
gtk_main();
return 0;
}

12
examples/custom-cell-renderer/Makefile

@ -0,0 +1,12 @@
CC = gcc
OBJS = main.o custom-cell-renderer-progressbar.o
CFLAGS = -g -O2 `pkg-config --cflags gtk+-2.0`
customlist: $(OBJS)
gcc -o customcellrenderer $(OBJS) `pkg-config --libs gtk+-2.0`
clean:
rm $(OBJS) customcellrenderer 2>/dev/null || /bin/true

353
examples/custom-cell-renderer/custom-cell-renderer-progressbar.c

@ -0,0 +1,353 @@
/***********************************************************
*
* custom-cell-renderer-progressbar.c
*
* part of the Gtk+ tree view tutorial
*
* by Tim-Philipp Mueller < tim at centricular dot net >
*
***********************************************************/
#include "custom-cell-renderer-progressbar.h"
/* This is based mainly on GtkCellRendererProgress
* in GAIM, written and (c) 2002 by Sean Egan
* (Licensed under the GPL), which in turn is
* based on Gtk's GtkCellRenderer[Text|Toggle|Pixbuf]
* implementation by Jonathan Blandford */
/* Some boring function declarations: GObject type system stuff */
static void custom_cell_renderer_progress_init (CustomCellRendererProgress *cellprogress);
static void custom_cell_renderer_progress_class_init (CustomCellRendererProgressClass *klass);
static void custom_cell_renderer_progress_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec);
static void custom_cell_renderer_progress_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec);
static void custom_cell_renderer_progress_finalize (GObject *gobject);
/* These functions are the heart of our custom cell renderer: */
static void custom_cell_renderer_progress_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
GdkRectangle *cell_area,
gint *x_offset,
gint *y_offset,
gint *width,
gint *height);
static void custom_cell_renderer_progress_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
guint flags);
enum
{
PROP_PERCENTAGE = 1,
};
static gpointer parent_class;
/***************************************************************************
*
* custom_cell_renderer_progress_get_type: here we register our type with
* the GObject type system if we
* haven't done so yet. Everything
* else is done in the callbacks.
*
***************************************************************************/
GType
custom_cell_renderer_progress_get_type (void)
{
static GType cell_progress_type = 0;
if (cell_progress_type)
return cell_progress_type;
if (1)
{
static const GTypeInfo cell_progress_info =
{
sizeof (CustomCellRendererProgressClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) custom_cell_renderer_progress_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (CustomCellRendererProgress),
0, /* n_preallocs */
(GInstanceInitFunc) custom_cell_renderer_progress_init,
};
/* Derive from GtkCellRenderer */
cell_progress_type = g_type_register_static (GTK_TYPE_CELL_RENDERER,
"CustomCellRendererProgress",
&cell_progress_info,
0);
}
return cell_progress_type;
}
/***************************************************************************
*
* custom_cell_renderer_progress_init: set some default properties of the
* parent (GtkCellRenderer).
*
***************************************************************************/
static void
custom_cell_renderer_progress_init (CustomCellRendererProgress *cellrendererprogress)
{
GTK_CELL_RENDERER(cellrendererprogress)->mode = GTK_CELL_RENDERER_MODE_INERT;
GTK_CELL_RENDERER(cellrendererprogress)->xpad = 2;
GTK_CELL_RENDERER(cellrendererprogress)->ypad = 2;
}
/***************************************************************************
*
* custom_cell_renderer_progress_class_init:
*
* set up our own get_property and set_property functions, and
* override the parent's functions that we need to implement.
* And make our new "percentage" property known to the type system.
* If you want cells that can be activated on their own (ie. not
* just the whole row selected) or cells that are editable, you
* will need to override 'activate' and 'start_editing' as well.
*
***************************************************************************/
static void
custom_cell_renderer_progress_class_init (CustomCellRendererProgressClass *klass)
{
GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS(klass);
GObjectClass *object_class = G_OBJECT_CLASS(klass);
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = custom_cell_renderer_progress_finalize;
/* Hook up functions to set and get our
* custom cell renderer properties */
object_class->get_property = custom_cell_renderer_progress_get_property;
object_class->set_property = custom_cell_renderer_progress_set_property;
/* Override the two crucial functions that are the heart
* of a cell renderer in the parent class */
cell_class->get_size = custom_cell_renderer_progress_get_size;
cell_class->render = custom_cell_renderer_progress_render;
/* Install our very own properties */
g_object_class_install_property (object_class,
PROP_PERCENTAGE,
g_param_spec_double ("percentage",
"Percentage",
"The fractional progress to display",
0.0, 1.0, 0.0,
G_PARAM_READWRITE));
}
/***************************************************************************
*
* custom_cell_renderer_progress_finalize: free any resources here
*
***************************************************************************/
static void
custom_cell_renderer_progress_finalize (GObject *object)
{
/*
CustomCellRendererProgress *cellrendererprogress = CUSTOM_CELL_RENDERER_PROGRESS(object);
*/
/* Free any dynamically allocated resources here */
(* G_OBJECT_CLASS (parent_class)->finalize) (object);
}
/***************************************************************************
*
* custom_cell_renderer_progress_get_property: as it says
*
***************************************************************************/
static void
custom_cell_renderer_progress_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *psec)
{
CustomCellRendererProgress *cellprogress = CUSTOM_CELL_RENDERER_PROGRESS(object);
switch (param_id)
{
case PROP_PERCENTAGE:
g_value_set_double(value, cellprogress->progress);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, psec);
break;
}
}
/***************************************************************************
*
* custom_cell_renderer_progress_set_property: as it says
*
***************************************************************************/
static void
custom_cell_renderer_progress_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
CustomCellRendererProgress *cellprogress = CUSTOM_CELL_RENDERER_PROGRESS (object);
switch (param_id)
{
case PROP_PERCENTAGE:
cellprogress->progress = g_value_get_double(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
break;
}
}
/***************************************************************************
*
* custom_cell_renderer_progress_new: return a new cell renderer instance
*
***************************************************************************/
GtkCellRenderer *
custom_cell_renderer_progress_new (void)
{
return g_object_new(CUSTOM_TYPE_CELL_RENDERER_PROGRESS, NULL);
}
/***************************************************************************
*
* custom_cell_renderer_progress_get_size: crucial - calculate the size
* of our cell, taking into account
* padding and alignment properties
* of parent.
*
***************************************************************************/
#define FIXED_WIDTH 100
#define FIXED_HEIGHT 10
static void
custom_cell_renderer_progress_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
GdkRectangle *cell_area,
gint *x_offset,
gint *y_offset,
gint *width,
gint *height)
{
gint calc_width;
gint calc_height;
calc_width = (gint) cell->xpad * 2 + FIXED_WIDTH;
calc_height = (gint) cell->ypad * 2 + FIXED_HEIGHT;
if (width)
*width = calc_width;
if (height)
*height = calc_height;
if (cell_area)
{
if (x_offset)
{
*x_offset = cell->xalign * (cell_area->width - calc_width);
*x_offset = MAX (*x_offset, 0);
}
if (y_offset)
{
*y_offset = cell->yalign * (cell_area->height - calc_height);
*y_offset = MAX (*y_offset, 0);
}
}
}
/***************************************************************************
*
* custom_cell_renderer_progress_render: crucial - do the rendering.
*
***************************************************************************/
static void
custom_cell_renderer_progress_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
guint flags)
{
CustomCellRendererProgress *cellprogress = CUSTOM_CELL_RENDERER_PROGRESS (cell);
GtkStateType state;
gint width, height;
gint x_offset, y_offset;
custom_cell_renderer_progress_get_size (cell, widget, cell_area,
&x_offset, &y_offset,
&width, &height);
if (GTK_WIDGET_HAS_FOCUS (widget))
state = GTK_STATE_ACTIVE;
else
state = GTK_STATE_NORMAL;
width -= cell->xpad*2;
height -= cell->ypad*2;
gtk_paint_box (widget->style,
window,
GTK_STATE_NORMAL, GTK_SHADOW_IN,
NULL, widget, "trough",
cell_area->x + x_offset + cell->xpad,
cell_area->y + y_offset + cell->ypad,
width - 1, height - 1);
gtk_paint_box (widget->style,
window,
state, GTK_SHADOW_OUT,
NULL, widget, "bar",
cell_area->x + x_offset + cell->xpad,
cell_area->y + y_offset + cell->ypad,
width * cellprogress->progress,
height - 1);
}

55
examples/custom-cell-renderer/custom-cell-renderer-progressbar.h

@ -0,0 +1,55 @@
/***********************************************************
*
* custom-cell-renderer-progressbar.h
*
* part of the Gtk+ tree view tutorial
*
* by Tim-Philipp Mueller < tim at centricular dot net >
*
***********************************************************/
#ifndef _custom_cell_renderer_progressbar_included_
#define _custom_cell_renderer_progressbar_included_
#include <gtk/gtk.h>
/* Some boilerplate GObject type check and type cast macros.
* 'klass' is used here instead of 'class', because 'class'
* is a c++ keyword */
#define CUSTOM_TYPE_CELL_RENDERER_PROGRESS (custom_cell_renderer_progress_get_type())
#define CUSTOM_CELL_RENDERER_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), CUSTOM_TYPE_CELL_RENDERER_PROGRESS, CustomCellRendererProgress))
#define CUSTOM_CELL_RENDERER_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CUSTOM_TYPE_CELL_RENDERER_PROGRESS, CustomCellRendererProgressClass))
#define CUSTOM_IS_CELL_PROGRESS_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CUSTOM_TYPE_CELL_RENDERER_PROGRESS))
#define CUSTOM_IS_CELL_PROGRESS_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CUSTOM_TYPE_CELL_RENDERER_PROGRESS))
#define CUSTOM_CELL_RENDERER_PROGRESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CUSTOM_TYPE_CELL_RENDERER_PROGRESS, CustomCellRendererProgressClass))
typedef struct _CustomCellRendererProgress CustomCellRendererProgress;
typedef struct _CustomCellRendererProgressClass CustomCellRendererProgressClass;
/* CustomCellRendererProgress: Our custom cell renderer
* structure. Extend according to need */
struct _CustomCellRendererProgress
{
GtkCellRenderer parent;
gdouble progress;
};
struct _CustomCellRendererProgressClass
{
GtkCellRendererClass parent_class;
};
GType custom_cell_renderer_progress_get_type (void);
GtkCellRenderer *custom_cell_renderer_progress_new (void);
#endif /* _custom_cell_renderer_progressbar_included_ */

114
examples/custom-cell-renderer/main.c

@ -0,0 +1,114 @@
/***********************************************************
*
* main.c - testing CustomCellRendererProgress
*
* part of the Gtk+ tree view tutorial
*
* by Tim-Philipp Mueller < tim at centricular dot net >
*
***********************************************************/
#include "custom-cell-renderer-progressbar.h"
static GtkListStore *liststore;
static gboolean increasing = TRUE; /* direction of progress bar change */
enum
{
COL_PERCENTAGE = 0,
COL_TEXT,
NUM_COLS
};
#define STEP 0.01
gboolean
increase_progress_timeout (GtkCellRenderer *renderer)
{
GtkTreeIter iter;
gfloat perc = 0.0;
gchar buf[20];
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(liststore), &iter); /* first and only row */
gtk_tree_model_get (GTK_TREE_MODEL(liststore), &iter, COL_PERCENTAGE, &perc, -1);
if ( perc > (1.0-STEP) || (perc < STEP && perc > 0.0) )
{
increasing = (!increasing);
}
if (increasing)
perc = perc + STEP;
else
perc = perc - STEP;
g_snprintf(buf, sizeof(buf), "%u %%", (guint)(perc*100));
gtk_list_store_set (liststore, &iter, COL_PERCENTAGE, perc, COL_TEXT, buf, -1);
return TRUE; /* Call again */
}
GtkWidget *
create_view_and_model (void)
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GtkWidget *view;
liststore = gtk_list_store_new(NUM_COLS, G_TYPE_FLOAT, G_TYPE_STRING);
gtk_list_store_append(liststore, &iter);
gtk_list_store_set (liststore, &iter, COL_PERCENTAGE, 0.5, -1); /* start at 50% */
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(liststore));
g_object_unref(liststore); /* destroy store automatically with view */
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_add_attribute (col, renderer, "text", COL_TEXT);
gtk_tree_view_column_set_title (col, "Progress");
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
renderer = custom_cell_renderer_progress_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_add_attribute (col, renderer, "percentage", COL_PERCENTAGE);
gtk_tree_view_column_set_title (col, "Progress");
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
g_timeout_add(50, (GSourceFunc) increase_progress_timeout, NULL);
return view;
}
int
main (int argc, char **argv)
{
GtkWidget *window, *view;
gtk_init(&argc,&argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW(window), 150, 100);
g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
view = create_view_and_model();
gtk_container_add(GTK_CONTAINER(window), view);
gtk_widget_show_all(window);
gtk_main();
return 0;
}

12
examples/custom-list-model-sorted/Makefile

@ -0,0 +1,12 @@
CC = gcc
OBJS = main.o custom-list.o
CFLAGS = -g -O2 `pkg-config --cflags gtk+-2.0`
customlist-sorted: $(OBJS)
gcc -o customlist-sorted $(OBJS) `pkg-config --libs gtk+-2.0`
clean:
rm $(OBJS) customlist-sorted 2>/dev/null || /bin/true

951
examples/custom-list-model-sorted/custom-list.c

@ -0,0 +1,951 @@
/***********************************************************
*
* custom-list.c
*
* A simple custom list model with sorting
*
* part of the Gtk+ tree view tutorial
*
* by Tim-Philipp Mueller < tim at centricular dot net >
*
***********************************************************/
#include "custom-list.h"
/* boring declarations of local functions */
static void custom_list_init (CustomList *pkg_tree);
static void custom_list_class_init (CustomListClass *klass);
static void custom_list_tree_model_init (GtkTreeModelIface *iface);
static void custom_list_finalize (GObject *object);
static GtkTreeModelFlags custom_list_get_flags (GtkTreeModel *tree_model);
static gint custom_list_get_n_columns (GtkTreeModel *tree_model);
static GType custom_list_get_column_type (GtkTreeModel *tree_model,
gint index);
static gboolean custom_list_get_iter (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path);
static GtkTreePath *custom_list_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter);
static void custom_list_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
gint column,
GValue *value);
static gboolean custom_list_iter_next (GtkTreeModel *tree_model,
GtkTreeIter *iter);
static gboolean custom_list_iter_children (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent);
static gboolean custom_list_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter);
static gint custom_list_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter);
static gboolean custom_list_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
gint n);
static gboolean custom_list_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child);
/* -- GtkTreeSortable interface functions -- */
static void custom_list_sortable_init (GtkTreeSortableIface *iface);
static gboolean custom_list_sortable_get_sort_column_id (GtkTreeSortable *sortable,
gint *sort_col_id,
GtkSortType *order);
static void custom_list_sortable_set_sort_column_id (GtkTreeSortable *sortable,
gint sort_col_id,
GtkSortType order);
static void custom_list_sortable_set_sort_func (GtkTreeSortable *sortable,
gint sort_col_id,
GtkTreeIterCompareFunc sort_func,
gpointer user_data,
GtkDestroyNotify destroy_func);
static void custom_list_sortable_set_default_sort_func (GtkTreeSortable *sortable,
GtkTreeIterCompareFunc sort_func,
gpointer user_data,
GtkDestroyNotify destroy_func);
static gboolean custom_list_sortable_has_default_sort_func (GtkTreeSortable *sortable);
static void custom_list_resort (CustomList *custom_list);
static GObjectClass *parent_class = NULL; /* GObject stuff - nothing to worry about */
/*****************************************************************************
*
* custom_list_get_type: here we register our new type and its interfaces
* with the type system. If you want to implement
* additional interfaces, you will need to do it here.
*
*****************************************************************************/
GType
custom_list_get_type (void)
{
static GType custom_list_type = 0;
if (custom_list_type)
return custom_list_type;
/* Some boilerplate type registration stuff */
if (1)
{
static const GTypeInfo custom_list_info =
{
sizeof (CustomListClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) custom_list_class_init,
NULL, /* class finalize */