plugins/symbol-browser/an_symbol_iter.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * an_symbol_iter.c
   4  * Copyright (C) Naba Kumar  <naba@gnome.org>
   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 Library 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 #include <libgnome/gnome-macros.h>
  22 #include <libanjuta/anjuta-utils.h>
  23 #include <libanjuta/anjuta-debug.h>
  24 #include <libanjuta/interfaces/ianjuta-symbol.h>
  25 #include <libanjuta/interfaces/ianjuta-iterable.h>
  26 #include "an_symbol_iter.h"
  27 #include "an_symbol.h"
  28
  29 struct _AnjutaSymbolIterPriv
  30 {
  31         gint current_pos;
  32         const GPtrArray *tm_tags_array;
  33 };
  34
  35 static gpointer parent_class;
  36
  37 static gboolean isymbol_iter_set_position (IAnjutaIterable *iterable,
  38                                                                                    gint position, GError **err);
  39
  40 /* Anjuta symbol iter class */
  41
  42 static void
  43 anjuta_symbol_iter_finalize (GObject * obj)
  44 {
  45         AnjutaSymbolIter *si = ANJUTA_SYMBOL_ITER (obj);
  46
  47         g_free (si->priv);
  48         GNOME_CALL_PARENT (G_OBJECT_CLASS, finalize, (obj));
  49 }
  50
  51 static void
  52 anjuta_symbol_iter_dispose (GObject * obj)
  53 {
  54         /* AnjutaSymbolIter *si = ANJUTA_SYMBOL_ITER (obj); */
  55         GNOME_CALL_PARENT (G_OBJECT_CLASS, dispose, (obj));
  56 }
  57
  58 static void
  59 anjuta_symbol_iter_instance_init (GObject * obj)
  60 {
  61         AnjutaSymbolIter *si;
  62
  63         si = ANJUTA_SYMBOL_ITER (obj);
  64         si->priv = g_new0 (AnjutaSymbolIterPriv, 1);
  65         si->priv->current_pos = 0;
  66 }
  67
  68 static void
  69 anjuta_symbol_iter_class_init (AnjutaSymbolIterClass * klass)
  70 {
  71         AnjutaSymbolIterClass *sic;
  72         GObjectClass *object_class = G_OBJECT_CLASS (klass);
  73
  74         parent_class = g_type_class_peek_parent (klass);
  75         sic = ANJUTA_SYMBOL_ITER_CLASS (klass);
  76         object_class->finalize = anjuta_symbol_iter_finalize;
  77         object_class->dispose = anjuta_symbol_iter_dispose;
  78 }
  79
  80 AnjutaSymbolIter*
  81 anjuta_symbol_iter_new (const GPtrArray *tm_tags_array)
  82 {
  83         AnjutaSymbolIter *si;
  84
  85         g_return_val_if_fail (tm_tags_array != NULL, NULL);
  86
  87         si = g_object_new (ANJUTA_TYPE_SYMBOL_ITER, NULL);
  88         si->priv->tm_tags_array = tm_tags_array;
  89         ianjuta_iterable_first (IANJUTA_ITERABLE (si), NULL);
  90         return si;
  91 }
  92
  93 /* IAnjutaIterable implementation */
  94
  95 static gboolean
  96 isymbol_iter_first (IAnjutaIterable *iterable, GError **err)
  97 {
  98         AnjutaSymbolIter *si = ANJUTA_SYMBOL_ITER (iterable);
  99
 100         si->priv->current_pos = 0;
 101         if (si->priv->tm_tags_array->len <= 0)
 102         {
 103                 anjuta_symbol_set_tag (ANJUTA_SYMBOL (iterable),
 104                                                            NULL);
 105                 return FALSE;
 106         }
 107         /* g_assert (si->priv->tm_tags_array->pdata[si->priv->current_pos]); */
 108         anjuta_symbol_set_tag (ANJUTA_SYMBOL (iterable),
 109                                                    si->priv->tm_tags_array->pdata[0]);
 110         return TRUE;
 111 }
 112
 113 static gboolean
 114 isymbol_iter_next (IAnjutaIterable *iterable, GError **err)
 115 {
 116         AnjutaSymbolIter *si = ANJUTA_SYMBOL_ITER (iterable);
 117
 118         if (si->priv->current_pos >= (si->priv->tm_tags_array->len - 1))
 119         {
 120                 anjuta_symbol_set_tag (ANJUTA_SYMBOL (iterable),
 121                                                         si->priv->tm_tags_array->pdata[si->priv->tm_tags_array->len - 1]);
 122                 return FALSE;
 123         }
 124         si->priv->current_pos++;
 125         /* g_assert (si->priv->tm_tags_array->pdata[si->priv->current_pos]); */
 126         anjuta_symbol_set_tag (ANJUTA_SYMBOL (iterable),
 127                                                 si->priv->tm_tags_array->pdata[si->priv->current_pos]);
 128         return TRUE;
 129 }
 130
 131 static gboolean
 132 isymbol_iter_previous (IAnjutaIterable *iterable, GError **err)
 133 {
 134         AnjutaSymbolIter *si = ANJUTA_SYMBOL_ITER (iterable);
 135
 136         if (si->priv->current_pos <= 0)
 137         {
 138                 anjuta_symbol_set_tag (ANJUTA_SYMBOL (iterable),
 139                                                         si->priv->tm_tags_array->pdata[0]);
 140                 return FALSE;
 141         }
 142         si->priv->current_pos--;
 143         /* g_assert (si->priv->tm_tags_array->pdata[si->priv->current_pos]); */
 144         anjuta_symbol_set_tag (ANJUTA_SYMBOL (iterable),
 145                                                    si->priv->tm_tags_array->pdata[si->priv->current_pos]);
 146         return TRUE;
 147 }
 148
 149 static gboolean
 150 isymbol_iter_last (IAnjutaIterable *iterable, GError **err)
 151 {
 152         AnjutaSymbolIter *si = ANJUTA_SYMBOL_ITER (iterable);
 153
 154         si->priv->current_pos = 0;
 155         if (si->priv->tm_tags_array->len <= 0)
 156         {
 157                 anjuta_symbol_set_tag (ANJUTA_SYMBOL (iterable),
 158                                                         si->priv->tm_tags_array->pdata[0]);
 159                 return FALSE;
 160         }
 161         si->priv->current_pos = si->priv->tm_tags_array->len - 1;
 162         /* g_assert (si->priv->tm_tags_array->pdata[si->priv->current_pos]); */
 163         anjuta_symbol_set_tag (ANJUTA_SYMBOL (iterable),
 164                                                    si->priv->tm_tags_array->pdata[si->priv->current_pos]);
 165         return TRUE;
 166 }
 167
 168 static void
 169 isymbol_iter_foreach (IAnjutaIterable *iterable, GFunc callback,
 170                                           gpointer user_data, GError **err)
 171 {
 172         AnjutaSymbolIter *si = ANJUTA_SYMBOL_ITER (iterable);
 173         gint saved_pos = si->priv->current_pos;
 174
 175         isymbol_iter_first (iterable, NULL);
 176         while (!isymbol_iter_next (iterable, NULL))
 177                 callback (iterable, user_data);
 178         isymbol_iter_set_position (iterable, saved_pos, NULL);
 179 }
 180
 181 static gboolean
 182 isymbol_iter_set_position (IAnjutaIterable *iterable,
 183                                                    gint position, GError **err)
 184 {
 185         AnjutaSymbolIter *si = ANJUTA_SYMBOL_ITER (iterable);
 186         if (position < 0)
 187                 return FALSE;
 188         if (position > (si->priv->tm_tags_array->len - 1))
 189                 return FALSE;
 190         si->priv->current_pos = position;
 191         /* g_assert (si->priv->tm_tags_array->pdata[si->priv->current_pos]); */
 192         anjuta_symbol_set_tag (ANJUTA_SYMBOL (iterable),
 193                                                    si->priv->tm_tags_array->pdata[si->priv->current_pos]);
 194         return TRUE;
 195 }
 196
 197 static gint
 198 isymbol_iter_get_position (IAnjutaIterable *iterable, GError **err)
 199 {
 200         AnjutaSymbolIter *si = ANJUTA_SYMBOL_ITER (iterable);
 201         return si->priv->current_pos;
 202 }
 203
 204 static gint
 205 isymbol_iter_get_length (IAnjutaIterable *iterable, GError **err)
 206 {
 207         AnjutaSymbolIter *si = ANJUTA_SYMBOL_ITER (iterable);
 208         return si->priv->tm_tags_array->len;
 209 }
 210
 211 static void
 212 isymbol_iter_iface_init (IAnjutaIterableIface *iface, GError **err)
 213 {
 214         iface->first = isymbol_iter_first;
 215         iface->next = isymbol_iter_next;
 216         iface->previous = isymbol_iter_previous;
 217         iface->last = isymbol_iter_last;
 218         iface->foreach = isymbol_iter_foreach;
 219         iface->set_position = isymbol_iter_set_position;
 220         iface->get_position = isymbol_iter_get_position;
 221         iface->get_length = isymbol_iter_get_length;
 222 }
 223
 224 ANJUTA_TYPE_BEGIN (AnjutaSymbolIter, anjuta_symbol_iter, ANJUTA_TYPE_SYMBOL);
 225 ANJUTA_TYPE_ADD_INTERFACE (isymbol_iter, IANJUTA_TYPE_ITERABLE);
 226 ANJUTA_TYPE_END;