[andy/viking.git] / src / viktreeview.c

/*
 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
 *
 * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.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 program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <gtk/gtk.h>
#include <string.h>

#include "viking.h"

#include "config.h"

#define TREEVIEW_GET(model,iter,what,dest) gtk_tree_model_get(GTK_TREE_MODEL(model),(iter),(what),(dest),-1)

enum {
  VT_ITEM_EDITED_SIGNAL,
  VT_ITEM_TOGGLED_SIGNAL,
  VT_LAST_SIGNAL
};

static guint treeview_signals[VT_LAST_SIGNAL] = { 0, 0 };

static GObjectClass *parent_class;

enum
{
  NAME_COLUMN = 0,
  VISIBLE_COLUMN,
  ICON_COLUMN,
  /* invisible */

  TYPE_COLUMN,
  ITEM_PARENT_COLUMN,
  ITEM_POINTER_COLUMN,
  ITEM_DATA_COLUMN,
  HAS_VISIBLE_COLUMN,
  EDITABLE_COLUMN,
  /* properties dialog, delete, rename, etc. */
  NUM_COLUMNS
};

struct _VikTreeview {
  GtkTreeView treeview;
  GtkTreeModel *model;

  GdkPixbuf *layer_type_icons[VIK_LAYER_NUM_TYPES];
};

/* TODO: find, make "static" and put up here all non-"a_" functions */
static void treeview_class_init ( VikTreeviewClass *klass );
static void treeview_init ( VikTreeview *vt );
static void treeview_finalize ( GObject *gob );
static void treeview_add_columns ( VikTreeview *vt );

GType vik_treeview_get_type (void)
{
  static GType vt_type = 0;

  if (!vt_type)
  {
    static const GTypeInfo vt_info = 
    {
      sizeof (VikTreeviewClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) treeview_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (VikTreeview),
      0,
      (GInstanceInitFunc) treeview_init,
    };
    vt_type = g_type_register_static ( GTK_TYPE_TREE_VIEW, "VikTreeview", &vt_info, 0 );
  }

  return vt_type;
}

static void treeview_class_init ( VikTreeviewClass *klass )
{
  /* Destructor */
  GObjectClass *object_class;
                                                                                                                                 
  object_class = G_OBJECT_CLASS (klass);
                                                                                                                                 
  object_class->finalize =  treeview_finalize;
                                                                                                                                 
  parent_class = g_type_class_peek_parent (klass);

  treeview_signals[VT_ITEM_EDITED_SIGNAL] = g_signal_new ( "item_edited", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikTreeviewClass, item_edited), NULL, NULL, 
    gtk_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2, GTK_TYPE_POINTER, G_TYPE_POINTER);
  /* VOID__UINT_POINTER: kinda hack-ish, but it works. */

  treeview_signals[VT_ITEM_TOGGLED_SIGNAL] = g_signal_new ( "item_toggled", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikTreeviewClass, item_toggled), NULL, NULL,
    g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, GTK_TYPE_POINTER );
}

static void treeview_edited_cb (GtkCellRendererText *cell, gchar *path_str, const gchar *new_name, VikTreeview *vt)
{
  GtkTreeIter iter;

  /* get type and data */
  vik_treeview_get_iter_from_path_str ( vt, &iter, path_str );

  g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_EDITED_SIGNAL], 0, &iter, new_name );
}

static void treeview_toggled_cb (GtkCellRendererToggle *cell, gchar *path_str, VikTreeview *vt)
{
  GtkTreeIter iter;

  /* get type and data */
  vik_treeview_get_iter_from_path_str ( vt, &iter, path_str );

  g_signal_emit ( G_OBJECT(vt), 
treeview_signals[VT_ITEM_TOGGLED_SIGNAL], 0, &iter );
}

VikTreeview *vik_treeview_new ()
{
  return VIK_TREEVIEW ( g_object_new ( VIK_TREEVIEW_TYPE, NULL ) );
}

gint vik_treeview_item_get_type ( VikTreeview *vt, GtkTreeIter *iter )
{
  gint rv;
  TREEVIEW_GET ( vt->model, iter, TYPE_COLUMN, &rv );
  return rv;
}

gint vik_treeview_item_get_data ( VikTreeview *vt, GtkTreeIter *iter )
{
  gint rv;
  TREEVIEW_GET ( vt->model, iter, ITEM_DATA_COLUMN, &rv );
  return rv;
}

gpointer vik_treeview_item_get_pointer ( VikTreeview *vt, GtkTreeIter *iter )
{
  gpointer rv;
  TREEVIEW_GET ( vt->model, iter, ITEM_POINTER_COLUMN, &rv );
  return rv;
}

void vik_treeview_item_set_pointer ( VikTreeview *vt, GtkTreeIter *iter, gpointer pointer )
{
  gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_POINTER_COLUMN, pointer, -1 );
}

gpointer vik_treeview_item_get_parent ( VikTreeview *vt, GtkTreeIter *iter )
{
  gpointer rv;
  TREEVIEW_GET ( vt->model, iter, ITEM_PARENT_COLUMN, &rv );
  return rv;
}

void vik_treeview_get_iter_from_path_str ( VikTreeview *vt, GtkTreeIter *iter, const gchar *path_str )
{
  gtk_tree_model_get_iter_from_string ( GTK_TREE_MODEL(vt->model), iter, path_str );
}

static void treeview_add_columns ( VikTreeview *vt )
{
  gint col_offset;
  GtkCellRenderer *renderer;
  GtkTreeViewColumn *column;

  renderer = gtk_cell_renderer_text_new ();
  g_signal_connect (renderer, "edited",
		    G_CALLBACK (treeview_edited_cb), vt);

  g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);

  col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
							    -1, "Layer Name",
							    renderer, "text",
							    NAME_COLUMN,
							    "editable", EDITABLE_COLUMN,
							    NULL);

  column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
  gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
				   GTK_TREE_VIEW_COLUMN_FIXED);
  gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 100);
  gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
  gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), TRUE);

  renderer = gtk_cell_renderer_pixbuf_new ();

  g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);

  col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
							    -1, "Type",
							    renderer, "pixbuf",
							    ICON_COLUMN,
							    NULL);


  column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
  gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 33);
  gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
				   GTK_TREE_VIEW_COLUMN_FIXED);
  gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);


  renderer = gtk_cell_renderer_toggle_new ();
  g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);

  g_signal_connect (renderer, "toggled", G_CALLBACK (treeview_toggled_cb), vt);

  col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
							    -1, "Visible",
							    renderer,
							    "active",
							    VISIBLE_COLUMN,
							    "visible",
							    HAS_VISIBLE_COLUMN,
							    "activatable",
							    HAS_VISIBLE_COLUMN,
							    NULL);

  column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
  gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 40);
  gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
				   GTK_TREE_VIEW_COLUMN_FIXED);
  gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);

}

void treeview_init ( VikTreeview *vt )
{
  guint16 i;

  vt->model = GTK_TREE_MODEL(gtk_tree_store_new ( NUM_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN ));

  /* create tree view */
  gtk_tree_view_set_model ( GTK_TREE_VIEW(vt), vt->model );
  treeview_add_columns ( vt );
  g_object_unref (vt->model);

  gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (vt), TRUE);
  gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)),
                               GTK_SELECTION_SINGLE);

  for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
    vt->layer_type_icons[i] = vik_layer_load_icon ( i ); /* if icon can't be loaded, it will be null and simply not be shown. */

}

gboolean vik_treeview_item_get_parent_iter ( VikTreeview *vt, GtkTreeIter *iter,  GtkTreeIter *parent )
{
  return gtk_tree_model_iter_parent ( GTK_TREE_MODEL(vt->model), parent, iter );
}

gboolean vik_treeview_move_item ( VikTreeview *vt, GtkTreeIter *iter, gboolean up )
{
  gint t = vik_treeview_item_get_type ( vt, iter );
  if ( t == VIK_TREEVIEW_TYPE_LAYER )
  {
    GtkTreeIter switch_iter;
    if (up)
    {
      /* iter to path to iter */
      GtkTreePath *path = gtk_tree_model_get_path ( vt->model, iter );
      if ( !gtk_tree_path_prev ( path ) || !gtk_tree_model_get_iter ( vt->model, &switch_iter, path ) )
      {
        gtk_tree_path_free ( path );
        return FALSE;
      }
      gtk_tree_path_free ( path );
    }
    else
    {
      switch_iter = *iter;
      if ( !gtk_tree_model_iter_next ( vt->model, &switch_iter ) )
        return FALSE;
    }
    gtk_tree_store_swap ( GTK_TREE_STORE(vt->model), iter, &switch_iter ); 
    return TRUE;
    /* now, the easy part. actually switching them, not the GUI */
  } /* if item is map */
  return FALSE;
}

gboolean vik_treeview_get_iter_at_pos ( VikTreeview *vt, GtkTreeIter *iter, gint x, gint y )
{
  GtkTreePath *path;
  gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(vt), x, y, &path, NULL, NULL, NULL );
  if ( ! path )
    return FALSE;

  gtk_tree_model_get_iter (GTK_TREE_MODEL(vt->model), iter, path);
  gtk_tree_path_free ( path );
  return TRUE;
}

void vik_treeview_select_iter ( VikTreeview *vt, GtkTreeIter *iter )
{
  gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
}

gboolean vik_treeview_get_selected_iter ( VikTreeview *vt, GtkTreeIter *iter )
{
  return gtk_tree_selection_get_selected ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), NULL, iter );
}

void vik_treeview_item_delete ( VikTreeview *vt, GtkTreeIter *iter )
{
  gtk_tree_store_remove ( GTK_TREE_STORE(vt->model), iter );
}

/* Treeview Reform Project */

void vik_treeview_item_set_name ( VikTreeview *vt, GtkTreeIter *iter, const gchar *to )
{
  g_return_if_fail ( iter != NULL && to != NULL );
  gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, to, -1);
}

void vik_treeview_item_set_visible ( VikTreeview *vt, GtkTreeIter *iter, gboolean to )
{
  g_return_if_fail ( iter != NULL );
  gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, VISIBLE_COLUMN, to, -1 );
}

void vik_treeview_expand ( VikTreeview *vt, GtkTreeIter *iter )
{
  GtkTreePath *path;
  path = gtk_tree_model_get_path ( vt->model, iter );
  gtk_tree_view_expand_row ( GTK_TREE_VIEW(vt), path, FALSE );
  gtk_tree_path_free ( path );
}

void vik_treeview_item_select ( VikTreeview *vt, GtkTreeIter *iter )
{
  gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
}

void vik_treeview_add_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent,
                              gpointer item, gint data, gint icon_type )
{
  g_assert ( iter != NULL );
  g_assert ( icon_type < VIK_LAYER_NUM_TYPES );
  gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
  gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE, 
    TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item, 
    ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE,
    ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 );
}

void vik_treeview_insert_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent,
                              gpointer item, gint data, gint icon_type, GtkTreeIter *sibling )
{
  g_assert ( iter != NULL );
  g_assert ( icon_type < VIK_LAYER_NUM_TYPES );
  gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, sibling );
  gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE, 
    TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item, 
    ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE,
    ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 );
}

void vik_treeview_add_sublayer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item,
                                 gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable )
{
  g_assert ( iter != NULL );

  gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
  gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE, TYPE_COLUMN, VIK_TREEVIEW_TYPE_SUBLAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item, ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, has_visible, EDITABLE_COLUMN, editable, ICON_COLUMN, icon, -1 );
}


#ifdef VIK_CONFIG_ALPHABETIZED_TRW

void vik_treeview_sublayer_realphabetize ( VikTreeview *vt, GtkTreeIter *iter, const gchar *newname )
{
  GtkTreeIter search_iter, parent_iter;
  gchar *search_name;
  g_assert ( iter != NULL );

  gtk_tree_model_iter_parent ( vt->model, &parent_iter, iter );

  g_assert ( gtk_tree_model_iter_children ( vt->model, &search_iter, &parent_iter ) );

  do {
    gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 );
    if ( strcmp ( search_name, newname ) > 0 ) /* not >= or would trip on itself */
    {
      gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, &search_iter );
      return;
    }
  } while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) );

  gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, NULL );
}

void vik_treeview_add_sublayer_alphabetized
                 ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item,
                   gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable )
{
  GtkTreeIter search_iter;
  gchar *search_name;
  g_assert ( iter != NULL );

  if ( gtk_tree_model_iter_children ( vt->model, &search_iter, parent_iter ) )
  {
    gboolean found_greater_string = FALSE;
    do {
      gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 );
      if ( strcmp ( search_name, name ) >= 0 )
      {
        gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, &search_iter );
        found_greater_string = TRUE;
        break;
      }
    } while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) );

    if ( ! found_greater_string )
      gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
  }
  else
    gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );

  gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE, TYPE_COLUMN, VIK_TREEVIEW_TYPE_SUBLAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item, ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, has_visible, EDITABLE_COLUMN, editable, ICON_COLUMN, icon, -1 );
}

#endif

static void treeview_finalize ( GObject *gob )
{
  VikTreeview *vt = VIK_TREEVIEW ( gob );
  guint16 i;

  for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
    if ( vt->layer_type_icons[i] != NULL )
      g_object_unref ( G_OBJECT(vt->layer_type_icons[i]) );

  G_OBJECT_CLASS(parent_class)->finalize(gob);
}
Commit	Line	Data
50a14534 EB	1	/*
	2	* viking -- GPS Data and Topo Analyzer, Explorer, and Manager
	3	*
	4	* Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
	20	*/
	21
	22	#include <gtk/gtk.h>
	23	#include <string.h>
	24
	25	#include "viking.h"
	26
	27	#include "config.h"
	28
	29	#define TREEVIEW_GET(model,iter,what,dest) gtk_tree_model_get(GTK_TREE_MODEL(model),(iter),(what),(dest),-1)
	30
	31	enum {
	32	VT_ITEM_EDITED_SIGNAL,
	33	VT_ITEM_TOGGLED_SIGNAL,
	34	VT_LAST_SIGNAL
	35	};
	36
	37	static guint treeview_signals[VT_LAST_SIGNAL] = { 0, 0 };
	38
	39	static GObjectClass *parent_class;
	40
	41	enum
	42	{
	43	NAME_COLUMN = 0,
	44	VISIBLE_COLUMN,
	45	ICON_COLUMN,
	46	/* invisible */
	47
	48	TYPE_COLUMN,
	49	ITEM_PARENT_COLUMN,
	50	ITEM_POINTER_COLUMN,
	51	ITEM_DATA_COLUMN,
	52	HAS_VISIBLE_COLUMN,
	53	EDITABLE_COLUMN,
	54	/* properties dialog, delete, rename, etc. */
	55	NUM_COLUMNS
	56	};
	57
	58	struct _VikTreeview {
	59	GtkTreeView treeview;
	60	GtkTreeModel *model;
	61
	62	GdkPixbuf *layer_type_icons[VIK_LAYER_NUM_TYPES];
	63	};
	64
65	/* TODO: find, make "static" and put up here all non-"a_" functions */
66	static void treeview_class_init ( VikTreeviewClass *klass );
67	static void treeview_init ( VikTreeview *vt );
68	static void treeview_finalize ( GObject *gob );
69	static void treeview_add_columns ( VikTreeview *vt );
70
71	GType vik_treeview_get_type (void)
72	{
73	static GType vt_type = 0;
74
75	if (!vt_type)
76	{
77	static const GTypeInfo vt_info =
78	{
79	sizeof (VikTreeviewClass),
80	NULL, /* base_init */
81	NULL, /* base_finalize */
82	(GClassInitFunc) treeview_class_init,
83	NULL, /* class_finalize */
84	NULL, /* class_data */
85	sizeof (VikTreeview),
86	0,
87	(GInstanceInitFunc) treeview_init,
88	};
89	vt_type = g_type_register_static ( GTK_TYPE_TREE_VIEW, "VikTreeview", &vt_info, 0 );
90	}
91
92	return vt_type;
93	}
94
95	static void treeview_class_init ( VikTreeviewClass *klass )
96	{
97	/* Destructor */
98	GObjectClass *object_class;
99
100	object_class = G_OBJECT_CLASS (klass);
101
102	object_class->finalize = treeview_finalize;
103
104	parent_class = g_type_class_peek_parent (klass);
105
106	treeview_signals[VT_ITEM_EDITED_SIGNAL] = g_signal_new ( "item_edited", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST \| G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikTreeviewClass, item_edited), NULL, NULL,
752f500c	107	gtk_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2, GTK_TYPE_POINTER, G_TYPE_POINTER);
50a14534 EB	108	/* VOID__UINT_POINTER: kinda hack-ish, but it works. */
	109
	110	treeview_signals[VT_ITEM_TOGGLED_SIGNAL] = g_signal_new ( "item_toggled", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST \| G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikTreeviewClass, item_toggled), NULL, NULL,
752f500c	111	g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, GTK_TYPE_POINTER );
50a14534 EB	112	}
	113
	114	static void treeview_edited_cb (GtkCellRendererText cell, gchar path_str, const gchar new_name, VikTreeview vt)
	115	{
	116	GtkTreeIter iter;
	117
	118	/* get type and data */
	119	vik_treeview_get_iter_from_path_str ( vt, &iter, path_str );
	120
752f500c	121	g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_EDITED_SIGNAL], 0, &iter, new_name );
50a14534 EB	122	}
	123
	124	static void treeview_toggled_cb (GtkCellRendererToggle cell, gchar path_str, VikTreeview *vt)
	125	{
	126	GtkTreeIter iter;
	127
	128	/* get type and data */
	129	vik_treeview_get_iter_from_path_str ( vt, &iter, path_str );
	130
	131	g_signal_emit ( G_OBJECT(vt),
	132	treeview_signals[VT_ITEM_TOGGLED_SIGNAL], 0, &iter );
	133	}
	134
	135	VikTreeview *vik_treeview_new ()
	136	{
	137	return VIK_TREEVIEW ( g_object_new ( VIK_TREEVIEW_TYPE, NULL ) );
	138	}
	139
	140	gint vik_treeview_item_get_type ( VikTreeview vt, GtkTreeIter iter )
	141	{
	142	gint rv;
	143	TREEVIEW_GET ( vt->model, iter, TYPE_COLUMN, &rv );
	144	return rv;
	145	}
	146
	147	gint vik_treeview_item_get_data ( VikTreeview vt, GtkTreeIter iter )
	148	{
	149	gint rv;
	150	TREEVIEW_GET ( vt->model, iter, ITEM_DATA_COLUMN, &rv );
	151	return rv;
	152	}
	153
	154	gpointer vik_treeview_item_get_pointer ( VikTreeview vt, GtkTreeIter iter )
	155	{
	156	gpointer rv;
	157	TREEVIEW_GET ( vt->model, iter, ITEM_POINTER_COLUMN, &rv );
	158	return rv;
	159	}
	160
	161	void vik_treeview_item_set_pointer ( VikTreeview vt, GtkTreeIter iter, gpointer pointer )
	162	{
	163	gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_POINTER_COLUMN, pointer, -1 );
	164	}
	165
	166	gpointer vik_treeview_item_get_parent ( VikTreeview vt, GtkTreeIter iter )
	167	{
	168	gpointer rv;
	169	TREEVIEW_GET ( vt->model, iter, ITEM_PARENT_COLUMN, &rv );
	170	return rv;
	171	}
	172
	173	void vik_treeview_get_iter_from_path_str ( VikTreeview vt, GtkTreeIter iter, const gchar *path_str )
	174	{
	175	gtk_tree_model_get_iter_from_string ( GTK_TREE_MODEL(vt->model), iter, path_str );
	176	}
	177
	178	static void treeview_add_columns ( VikTreeview *vt )
	179	{
	180	gint col_offset;
	181	GtkCellRenderer *renderer;
	182	GtkTreeViewColumn *column;
	183
	184	renderer = gtk_cell_renderer_text_new ();
	185	g_signal_connect (renderer, "edited",
186	G_CALLBACK (treeview_edited_cb), vt);
187
188	g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
189
190	col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
191	-1, "Layer Name",
192	renderer, "text",
193	NAME_COLUMN,
194	"editable", EDITABLE_COLUMN,
195	NULL);
196
197	column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
198	gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
199	GTK_TREE_VIEW_COLUMN_FIXED);
200	gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 100);
201	gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
202	gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), TRUE);
203
204	renderer = gtk_cell_renderer_pixbuf_new ();
205
206	g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
207
208	col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
209	-1, "Type",
210	renderer, "pixbuf",
211	ICON_COLUMN,
212	NULL);
213
214
215	column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
216	gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 33);
217	gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
218	GTK_TREE_VIEW_COLUMN_FIXED);
219	gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
220
221
222	renderer = gtk_cell_renderer_toggle_new ();
223	g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
224
225	g_signal_connect (renderer, "toggled", G_CALLBACK (treeview_toggled_cb), vt);
226
227	col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
228	-1, "Visible",
229	renderer,
230	"active",
231	VISIBLE_COLUMN,
232	"visible",
233	HAS_VISIBLE_COLUMN,
234	"activatable",
235	HAS_VISIBLE_COLUMN,
236	NULL);
237
238	column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
239	gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 40);
240	gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
241	GTK_TREE_VIEW_COLUMN_FIXED);
242	gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
243
244	}
245
246	void treeview_init ( VikTreeview *vt )
247	{
248	guint16 i;
249
250	vt->model = GTK_TREE_MODEL(gtk_tree_store_new ( NUM_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN ));
251
252	/* create tree view */
253	gtk_tree_view_set_model ( GTK_TREE_VIEW(vt), vt->model );
254	treeview_add_columns ( vt );
255	g_object_unref (vt->model);
256
257	gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (vt), TRUE);
258	gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)),
259	GTK_SELECTION_SINGLE);
260
261	for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
262	vt->layer_type_icons[i] = vik_layer_load_icon ( i ); /* if icon can't be loaded, it will be null and simply not be shown. */
263
264	}
265
266	gboolean vik_treeview_item_get_parent_iter ( VikTreeview vt, GtkTreeIter iter, GtkTreeIter *parent )
267	{
268	return gtk_tree_model_iter_parent ( GTK_TREE_MODEL(vt->model), parent, iter );
269	}
270
271	gboolean vik_treeview_move_item ( VikTreeview vt, GtkTreeIter iter, gboolean up )
272	{
273	gint t = vik_treeview_item_get_type ( vt, iter );
274	if ( t == VIK_TREEVIEW_TYPE_LAYER )
275	{
276	GtkTreeIter switch_iter;
277	if (up)
278	{
279	/* iter to path to iter */
280	GtkTreePath *path = gtk_tree_model_get_path ( vt->model, iter );
281	if ( !gtk_tree_path_prev ( path ) \|\| !gtk_tree_model_get_iter ( vt->model, &switch_iter, path ) )
282	{
283	gtk_tree_path_free ( path );
284	return FALSE;
285	}
286	gtk_tree_path_free ( path );
287	}
288	else
289	{
290	switch_iter = *iter;
291	if ( !gtk_tree_model_iter_next ( vt->model, &switch_iter ) )
292	return FALSE;
293	}
294	gtk_tree_store_swap ( GTK_TREE_STORE(vt->model), iter, &switch_iter );
295	return TRUE;
296	/* now, the easy part. actually switching them, not the GUI */
297	} /* if item is map */
298	return FALSE;
299	}
300
301	gboolean vik_treeview_get_iter_at_pos ( VikTreeview vt, GtkTreeIter iter, gint x, gint y )
302	{
303	GtkTreePath *path;
304	gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(vt), x, y, &path, NULL, NULL, NULL );
305	if ( ! path )
306	return FALSE;
307
308	gtk_tree_model_get_iter (GTK_TREE_MODEL(vt->model), iter, path);
309	gtk_tree_path_free ( path );
310	return TRUE;
311	}
312
313	void vik_treeview_select_iter ( VikTreeview vt, GtkTreeIter iter )
314	{
315	gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
316	}
317
318	gboolean vik_treeview_get_selected_iter ( VikTreeview vt, GtkTreeIter iter )
319	{
320	return gtk_tree_selection_get_selected ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), NULL, iter );
321	}
322
323	void vik_treeview_item_delete ( VikTreeview vt, GtkTreeIter iter )
324	{
325	gtk_tree_store_remove ( GTK_TREE_STORE(vt->model), iter );
326	}
327
328	/* Treeview Reform Project */
329
330	void vik_treeview_item_set_name ( VikTreeview vt, GtkTreeIter iter, const gchar *to )
331	{
332	g_return_if_fail ( iter != NULL && to != NULL );
333	gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, to, -1);
334	}
335
336	void vik_treeview_item_set_visible ( VikTreeview vt, GtkTreeIter iter, gboolean to )
337	{
338	g_return_if_fail ( iter != NULL );
339	gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, VISIBLE_COLUMN, to, -1 );
340	}
341
342	void vik_treeview_expand ( VikTreeview vt, GtkTreeIter iter )
343	{
344	GtkTreePath *path;
345	path = gtk_tree_model_get_path ( vt->model, iter );
346	gtk_tree_view_expand_row ( GTK_TREE_VIEW(vt), path, FALSE );
347	gtk_tree_path_free ( path );
348	}
349
350	void vik_treeview_item_select ( VikTreeview vt, GtkTreeIter iter )
351	{
352	gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
353	}
354
355	void vik_treeview_add_layer ( VikTreeview vt, GtkTreeIter parent_iter, GtkTreeIter iter, const gchar name, gpointer parent,
356	gpointer item, gint data, gint icon_type )
357	{
358	g_assert ( iter != NULL );
359	g_assert ( icon_type < VIK_LAYER_NUM_TYPES );
360	gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
361	gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE,
362	TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item,
363	ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE,
364	ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 );
365	}
366
367	void vik_treeview_insert_layer ( VikTreeview vt, GtkTreeIter parent_iter, GtkTreeIter iter, const gchar name, gpointer parent,
368	gpointer item, gint data, gint icon_type, GtkTreeIter *sibling )
369	{
370	g_assert ( iter != NULL );
371	g_assert ( icon_type < VIK_LAYER_NUM_TYPES );
372	gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, sibling );
373	gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE,
374	TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item,
375	ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE,
376	ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 );
377	}
378
379	void vik_treeview_add_sublayer ( VikTreeview vt, GtkTreeIter parent_iter, GtkTreeIter iter, const gchar name, gpointer parent, gpointer item,
380	gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable )
381	{
382	g_assert ( iter != NULL );
383
384	gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
385	gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE, TYPE_COLUMN, VIK_TREEVIEW_TYPE_SUBLAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item, ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, has_visible, EDITABLE_COLUMN, editable, ICON_COLUMN, icon, -1 );
386	}
387
388
389	#ifdef VIK_CONFIG_ALPHABETIZED_TRW
390
391	void vik_treeview_sublayer_realphabetize ( VikTreeview vt, GtkTreeIter iter, const gchar *newname )
392	{
393	GtkTreeIter search_iter, parent_iter;
394	gchar *search_name;
395	g_assert ( iter != NULL );
396
397	gtk_tree_model_iter_parent ( vt->model, &parent_iter, iter );
398
399	g_assert ( gtk_tree_model_iter_children ( vt->model, &search_iter, &parent_iter ) );
400
401	do {
402	gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 );
403	if ( strcmp ( search_name, newname ) > 0 ) /* not >= or would trip on itself */
404	{
405	gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, &search_iter );
406	return;
407	}
408	} while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) );
409
410	gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, NULL );
411	}
412
413	void vik_treeview_add_sublayer_alphabetized
414	( VikTreeview vt, GtkTreeIter parent_iter, GtkTreeIter iter, const gchar name, gpointer parent, gpointer item,
415	gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable )
416	{
417	GtkTreeIter search_iter;
418	gchar *search_name;
419	g_assert ( iter != NULL );
420
421	if ( gtk_tree_model_iter_children ( vt->model, &search_iter, parent_iter ) )
422	{
423	gboolean found_greater_string = FALSE;
424	do {
425	gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 );
426	if ( strcmp ( search_name, name ) >= 0 )
427	{
428	gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, &search_iter );
429	found_greater_string = TRUE;
430	break;
431	}
432	} while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) );
433
434	if ( ! found_greater_string )
435	gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
436	}
437	else
438	gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
439
440	gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE, TYPE_COLUMN, VIK_TREEVIEW_TYPE_SUBLAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item, ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, has_visible, EDITABLE_COLUMN, editable, ICON_COLUMN, icon, -1 );
441	}
442
443	#endif
444
445	static void treeview_finalize ( GObject *gob )
446	{
447	VikTreeview *vt = VIK_TREEVIEW ( gob );
448	guint16 i;
449
450	for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
451	if ( vt->layer_type_icons[i] != NULL )
452	g_object_unref ( G_OBJECT(vt->layer_type_icons[i]) );
453
454	G_OBJECT_CLASS(parent_class)->finalize(gob);
455	}