src/core/na-object-id.c

   1 /*
   2  * Nautilus-Actions
   3  * A Nautilus extension which offers configurable context menu actions.
   4  *
   5  * Copyright (C) 2005 The GNOME Foundation
   6  * Copyright (C) 2006, 2007, 2008 Frederic Ruaudel and others (see AUTHORS)
   7  * Copyright (C) 2009, 2010, 2011 Pierre Wieser and others (see AUTHORS)
   8  *
   9  * This Program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This Program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this Library; see the file COPYING.  If not,
  21  * write to the Free Software Foundation, Inc., 59 Temple Place,
  22  * Suite 330, Boston, MA 02111-1307, USA.
  23  *
  24  * Authors:
  25  *   Frederic Ruaudel <grumz@grumz.net>
  26  *   Rodrigo Moya <rodrigo@gnome-db.org>
  27  *   Pierre Wieser <pwieser@trychlos.org>
  28  *   ... and many others (see AUTHORS)
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include <glib/gi18n.h>
  36
  37 #include <api/na-core-utils.h>
  38 #include <api/na-object-api.h>
  39
  40 /* private class data
  41  */
  42 struct _NAObjectIdClassPrivate {
  43         void *empty;                                            /* so that gcc -pedantic is happy */
  44 };
  45
  46 /* private instance data
  47  */
  48 struct _NAObjectIdPrivate {
  49         gboolean   dispose_has_run;
  50 };
  51
  52 static NAObjectClass *st_parent_class = NULL;
  53
  54 static GType    register_type( void );
  55 static void     class_init( NAObjectIdClass *klass );
  56 static void     instance_init( GTypeInstance *instance, gpointer klass );
  57 static void     instance_dispose( GObject *object );
  58 static void     instance_finalize( GObject *object );
  59
  60 static gboolean object_is_valid( const NAObject *object );
  61
  62 static gchar   *v_new_id( const NAObjectId *object, const NAObjectId *new_parent );
  63
  64 GType
  65 na_object_id_get_type( void )
  66 {
  67         static GType item_type = 0;
  68
  69         if( item_type == 0 ){
  70                 item_type = register_type();
  71         }
  72
  73         return( item_type );
  74 }
  75
  76 static GType
  77 register_type( void )
  78 {
  79         static const gchar *thisfn = "na_object_id_register_type";
  80         GType type;
  81
  82         static GTypeInfo info = {
  83                 sizeof( NAObjectIdClass ),
  84                 NULL,
  85                 NULL,
  86                 ( GClassInitFunc ) class_init,
  87                 NULL,
  88                 NULL,
  89                 sizeof( NAObjectId ),
  90                 0,
  91                 ( GInstanceInitFunc ) instance_init
  92         };
  93
  94         g_debug( "%s", thisfn );
  95
  96         type = g_type_register_static( NA_OBJECT_TYPE, "NAObjectId", &info, 0 );
  97
  98         return( type );
  99 }
 100
 101 static void
 102 class_init( NAObjectIdClass *klass )
 103 {
 104         static const gchar *thisfn = "na_object_id_class_init";
 105         GObjectClass *object_class;
 106         NAObjectClass *naobject_class;
 107
 108         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 109
 110         st_parent_class = g_type_class_peek_parent( klass );
 111
 112         object_class = G_OBJECT_CLASS( klass );
 113         object_class->dispose = instance_dispose;
 114         object_class->finalize = instance_finalize;
 115
 116         naobject_class = NA_OBJECT_CLASS( klass );
 117         naobject_class->dump = NULL;
 118         naobject_class->copy = NULL;
 119         naobject_class->are_equal = NULL;
 120         naobject_class->is_valid = object_is_valid;
 121
 122         klass->private = g_new0( NAObjectIdClassPrivate, 1 );
 123 }
 124
 125 static void
 126 instance_init( GTypeInstance *instance, gpointer klass )
 127 {
 128         NAObjectId *self;
 129
 130         g_return_if_fail( NA_IS_OBJECT_ID( instance ));
 131
 132         self = NA_OBJECT_ID( instance );
 133
 134         self->private = g_new0( NAObjectIdPrivate, 1 );
 135 }
 136
 137 /*
 138  * note that when the tree store is cleared, Gtk begins with the deepest
 139  * levels, so that children are disposed before their parent
 140  * as we try to dispose all children when disposing a parent, we have to
 141  * remove a disposing child from its parent
 142  */
 143 static void
 144 instance_dispose( GObject *object )
 145 {
 146         static const gchar *thisfn = "na_object_id_instance_dispose";
 147         NAObjectId *self;
 148         NAObjectItem *parent;
 149
 150         g_return_if_fail( NA_IS_OBJECT_ID( object ));
 151
 152         self = NA_OBJECT_ID( object );
 153
 154         if( !self->private->dispose_has_run ){
 155
 156                 self->private->dispose_has_run = TRUE;
 157
 158                 parent = na_object_get_parent( object );
 159                 g_debug( "%s: parent=%p (%s)",
 160                                 thisfn, ( void * ) parent, parent ? G_OBJECT_TYPE_NAME( parent ) : "n/a" );
 161                 if( parent ){
 162                         na_object_remove_item( parent, object );
 163                         na_object_set_parent( object, NULL );
 164                 }
 165
 166                 self->private->dispose_has_run = TRUE;
 167
 168                 /* chain up to the parent class */
 169                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 170                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 171                 }
 172         }
 173 }
 174
 175 static void
 176 instance_finalize( GObject *object )
 177 {
 178         NAObjectId *self;
 179
 180         g_return_if_fail( NA_IS_OBJECT_ID( object ));
 181
 182         self = NA_OBJECT_ID( object );
 183
 184         g_free( self->private );
 185
 186         /* chain call to parent class */
 187         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 188                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 189         }
 190 }
 191
 192 /*
 193  * a NAObjectId is valid if it has a non-null id
 194  */
 195 static gboolean
 196 object_is_valid( const NAObject *object )
 197 {
 198         gboolean is_valid;
 199         gchar *id;
 200
 201         is_valid = TRUE;
 202
 203         if( is_valid ){
 204                 id = na_object_get_id( object );
 205                 is_valid = ( id != NULL && strlen( id ) > 0 );
 206                 g_free( id );
 207         }
 208
 209         return( is_valid );
 210 }
 211
 212 /**
 213  * na_object_id_sort_alpha_asc:
 214  * @a: first #NAObjectId.
 215  * @b: second #NAObjectId.
 216  *
 217  * Sort the objects in alphabetical ascending order of their label.
 218  *
 219  * Returns:
 220  *
 221  * <itemizedlist>
 222  *   <listitem>
 223  *     <para>-1 if @a must be sorted before @b,</para>
 224  *   </listitem>
 225  *   <listitem>
 226  *     <para>0 if @a and @b are equal from the local point of view,</para>
 227  *   </listitem>
 228  *   <listitem>
 229  *     <para>1 if @a must be sorted after @b.</para>
 230  *   </listitem>
 231  * </itemizedlist>
 232  *
 233  * Since: 2.30
 234  */
 235 gint
 236 na_object_id_sort_alpha_asc( const NAObjectId *a, const NAObjectId *b )
 237 {
 238         gchar *label_a, *label_b;
 239         gint compare;
 240
 241         label_a = na_object_get_label( a );
 242         label_b = na_object_get_label( b );
 243
 244         compare = na_core_utils_str_collate( label_a, label_b );
 245
 246         g_free( label_b );
 247         g_free( label_a );
 248
 249         return( compare );
 250 }
 251
 252 /**
 253  * na_object_id_sort_alpha_desc:
 254  * @a: first #NAObjectId.
 255  * @b: second #NAObjectId.
 256  *
 257  * Sort the objects in alphabetical descending order of their label.
 258  *
 259  * Returns:
 260  *
 261  * <itemizedlist>
 262  *   <listitem>
 263  *     <para>-1 if @a must be sorted before @b,</para>
 264  *   </listitem>
 265  *   <listitem>
 266  *     <para>0 if @a and @b are equal from the local point of view,</para>
 267  *   </listitem>
 268  *   <listitem>
 269  *     <para>1 if @a must be sorted after @b.</para>
 270  *   </listitem>
 271  * </itemizedlist>
 272  *
 273  * Since: 2.30
 274  */
 275 gint
 276 na_object_id_sort_alpha_desc( const NAObjectId *a, const NAObjectId *b )
 277 {
 278         return( -1 * na_object_id_sort_alpha_asc( a, b ));
 279 }
 280
 281 /**
 282  * na_object_id_prepare_for_paste:
 283  * @object: the #NAObjectId object to be pasted.
 284  * @relabel: whether this object should be relabeled when pasted.
 285  * @renumber: whether this item should be renumbered ?
 286  * @parent: the parent of @object, or %NULL.
 287  *
 288  * Prepares @object to be pasted.
 289  *
 290  * If a #NAObjectProfile, then @object is attached to the specified
 291  * #NAObjectAction @action. The identifier is always renumbered to be
 292  * suitable with the already existing profiles.
 293  *
 294  * If a #NAObjectAction or a #NAObjectMenu, a new identifier is allocated
 295  * if and only if @relabel is %TRUE.
 296  *
 297  * Actual relabeling takes place if @relabel is %TRUE, depending of the
 298  * user preferences.
 299  *
 300  * Since: 2.30
 301  */
 302 void
 303 na_object_id_prepare_for_paste( NAObjectId *object, gboolean relabel, gboolean renumber, NAObjectId *parent )
 304 {
 305         static const gchar *thisfn = "na_object_id_prepare_for_paste";
 306         GList *subitems, *it;
 307
 308         g_return_if_fail( NA_IS_OBJECT_ID( object ));
 309         g_return_if_fail( !parent || NA_IS_OBJECT_ITEM( parent ));
 310
 311         if( !object->private->dispose_has_run ){
 312
 313                 g_debug( "%s: object=%p, relabel=%s, renumber=%s, parent=%p",
 314                                 thisfn, ( void * ) object, relabel ? "True":"False", renumber ? "True":"False", ( void * ) parent );
 315
 316                 if( NA_IS_OBJECT_PROFILE( object )){
 317                         na_object_set_parent( object, parent );
 318                         na_object_set_new_id( object, parent );
 319                         if( renumber && relabel ){
 320                                 na_object_set_copy_of_label( object );
 321                         }
 322
 323                 } else {
 324                         if( renumber ){
 325                                 na_object_set_new_id( object, NULL );
 326                                 if( relabel ){
 327                                         na_object_set_copy_of_label( object );
 328                                 }
 329                                 na_object_set_provider( object, NULL );
 330                                 na_object_set_provider_data( object, NULL );
 331                                 na_object_set_readonly( object, FALSE );
 332                         }
 333                         if( NA_IS_OBJECT_MENU( object )){
 334                                 subitems = na_object_get_items( object );
 335                                 for( it = subitems ; it ; it = it->next ){
 336                                         na_object_prepare_for_paste( it->data, relabel, renumber, NULL );
 337                                 }
 338                         }
 339                 }
 340         }
 341 }
 342
 343 /**
 344  * na_object_id_set_copy_of_label:
 345  * @object: the #NAObjectId object whose label is to be changed.
 346  *
 347  * Sets the 'Copy of' label.
 348  *
 349  * Since: 2.30
 350  */
 351 void
 352 na_object_id_set_copy_of_label( NAObjectId *object )
 353 {
 354         gchar *label, *new_label;
 355
 356         g_return_if_fail( NA_IS_OBJECT_ID( object ));
 357
 358         if( !object->private->dispose_has_run ){
 359
 360                 label = na_object_get_label( object );
 361
 362                 /* i18n: copied items have a label as 'Copy of original label' */
 363                 new_label = g_strdup_printf( _( "Copy of %s" ), label );
 364
 365                 na_object_set_label( object, new_label );
 366
 367                 g_free( new_label );
 368                 g_free( label );
 369         }
 370 }
 371
 372 /**
 373  * na_object_id_set_new_id:
 374  * @object: the #NAObjectId object whose internal identifier is to be
 375  * set.
 376  * @new_parent: if @object is a #NAObjectProfile, then @new_parent
 377  * should be set to the #NAObjectAction new parent. Else, it would not
 378  * be possible to allocate a new profile id compatible with already
 379  * existing ones.
 380  *
 381  * Request a new id to the derived class, and set it.
 382  *
 383  * Since: 2.30
 384  */
 385 void
 386 na_object_id_set_new_id( NAObjectId *object, const NAObjectId *new_parent )
 387 {
 388         static const gchar *thisfn = "na_object_id_set_new_id";
 389         gchar *id;
 390
 391         g_return_if_fail( NA_IS_OBJECT_ID( object ));
 392         g_return_if_fail( !new_parent || NA_IS_OBJECT_ITEM( new_parent ));
 393
 394         if( !object->private->dispose_has_run ){
 395
 396                 g_debug( "%s: object=%p (%s), new_parent=%p (%s)",
 397                                 thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ),
 398                                 ( void * ) new_parent, new_parent ? G_OBJECT_TYPE_NAME( new_parent ) : "n/a" );
 399
 400                 id = v_new_id( object, new_parent );
 401
 402                 if( id ){
 403                         na_object_set_id( object, id );
 404                         g_free( id );
 405                 }
 406         }
 407 }
 408
 409 static gchar *
 410 v_new_id( const NAObjectId *object, const NAObjectId *new_parent )
 411 {
 412         gchar *new_id;
 413         GList *hierarchy, *ih;
 414         gboolean found;
 415
 416         found = FALSE;
 417         new_id = NULL;
 418         hierarchy = g_list_reverse( na_object_get_hierarchy( NA_OBJECT( object )));
 419         /*g_debug( "na_object_id_most_derived_id: object=%p (%s)",
 420                                         ( void * ) object, G_OBJECT_TYPE_NAME( object ));*/
 421
 422         for( ih = hierarchy ; ih && !found ; ih = ih->next ){
 423                 if( NA_OBJECT_ID_CLASS( ih->data )->new_id ){
 424                         new_id = NA_OBJECT_ID_CLASS( ih->data )->new_id( object, new_parent );
 425                         found = TRUE;
 426                 }
 427                 if( G_OBJECT_CLASS_TYPE( ih->data ) == NA_OBJECT_ID_TYPE ){
 428                         break;
 429                 }
 430         }
 431
 432         na_object_free_hierarchy( hierarchy );
 433
 434         return( new_id );
 435 }