plugins/project-wizard/property.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     property.c
   4     Copyright (C) 2004 Sebastien Granjoux
   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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19 */
  20
  21 /*
  22  * Project properties, used in middle pages
  23  *
  24  *---------------------------------------------------------------------------*/
  25
  26 #include <config.h>
  27
  28 #include "property.h"
  29
  30 #include <glib/gdir.h>
  31
  32 #include <gnome.h>
  33 #include <glib/gi18n.h>
  34 #include <libgnomevfs/gnome-vfs-utils.h>
  35
  36 #include <string.h>
  37 #include <stdlib.h>
  38
  39 #include <libanjuta/anjuta-debug.h>
  40
  41 /*---------------------------------------------------------------------------*/
  42
  43 #define STRING_CHUNK_SIZE       256
  44
  45 /*---------------------------------------------------------------------------*/
  46
  47 struct _NPWPage
  48 {
  49         GNode* list;
  50         GStringChunk* string_pool;
  51         GMemChunk* data_pool;
  52         GMemChunk* item_pool;
  53         NPWValueHeap* value;
  54         gchar* name;
  55         gchar* label;
  56         gchar* description;
  57 };
  58
  59 struct _NPWProperty {
  60         NPWPropertyType type;
  61         NPWPropertyType restriction;
  62         NPWPropertyOptions options;
  63         gchar* label;
  64         gchar* description;
  65         gchar* defvalue;
  66         NPWValue* value;
  67         GtkWidget* widget;
  68         NPWPage* owner;
  69         GSList* item;
  70 };
  71
  72 struct _NPWItem {
  73         const gchar* name;
  74         const gchar* label;
  75 };
  76
  77 static const gchar* NPWPropertyTypeString[] = {
  78         "hidden",
  79         "boolean",
  80         "integer",
  81         "string",
  82         "list",
  83         "directory",
  84         "file",
  85         "icon"
  86 };
  87
  88 static const gchar* NPWPropertyRestrictionString[] = {
  89         "filename"
  90 };
  91
  92 /* Property object
  93  *---------------------------------------------------------------------------*/
  94
  95 static NPWPropertyType
  96 npw_property_type_from_string (const gchar* type)
  97 {
  98         gint i;
  99
 100         for (i = 0; i < NPW_LAST_PROPERTY; i++)
 101         {
 102                 if (strcmp (NPWPropertyTypeString[i], type) == 0)
 103                 {
 104                         return (NPWPropertyType)(i + 1);
 105                 }
 106         }
 107
 108         return NPW_UNKNOWN_PROPERTY;
 109 }
 110
 111 static NPWPropertyRestriction
 112 npw_property_restriction_from_string (const gchar* restriction)
 113 {
 114
 115         if (restriction != NULL)
 116         {
 117                 gint i;
 118
 119                 for (i = 0; i < NPW_LAST_RESTRICTION; i++)
 120                 {
 121                         if (strcmp (NPWPropertyRestrictionString[i], restriction) == 0)
 122                         {
 123                                 return (NPWPropertyRestriction)(i + 1);
 124                         }
 125                 }
 126         }
 127
 128         return NPW_NO_RESTRICTION;
 129 }
 130
 131 NPWProperty*
 132 npw_property_new (NPWPage* owner)
 133 {
 134         NPWProperty* this;
 135
 136         g_return_val_if_fail (owner, NULL);
 137
 138         this = g_chunk_new0(NPWProperty, owner->data_pool);
 139         this->owner = owner;
 140         this->type = NPW_UNKNOWN_PROPERTY;
 141         this->restriction = NPW_NO_RESTRICTION;
 142         this->item = NULL;
 143         /* value is set to NULL */
 144         g_node_append_data (owner->list, this);
 145
 146         return this;
 147 }
 148
 149 void
 150 npw_property_free (NPWProperty* this)
 151 {
 152         GNode* node;
 153
 154         if (this->item != NULL)
 155         {
 156                 g_slist_free (this->item);
 157         }
 158         node = g_node_find_child (this->owner->list, G_TRAVERSE_ALL, this);
 159         if (node != NULL)
 160         {
 161                 g_node_destroy (node);
 162                 /* Memory allocated in string pool and data pool is not free */
 163         }
 164 }
 165
 166 void
 167 npw_property_set_type (NPWProperty* this, NPWPropertyType type)
 168 {
 169         this->type = type;
 170 }
 171
 172 void
 173 npw_property_set_string_type (NPWProperty* this, const gchar* type)
 174 {
 175         npw_property_set_type (this, npw_property_type_from_string (type));
 176 }
 177
 178
 179 NPWPropertyType
 180 npw_property_get_type (const NPWProperty* this)
 181 {
 182         return this->type;
 183 }
 184
 185 void
 186 npw_property_set_restriction (NPWProperty* this, NPWPropertyRestriction restriction)
 187 {
 188         this->restriction = restriction;
 189 }
 190
 191 void
 192 npw_property_set_string_restriction (NPWProperty* this, const gchar* restriction)
 193 {
 194         npw_property_set_restriction (this, npw_property_restriction_from_string (restriction));
 195 }
 196
 197 NPWPropertyRestriction
 198 npw_property_get_restriction (const NPWProperty* this)
 199 {
 200         return this->restriction;
 201 }
 202
 203 gboolean
 204 npw_property_is_valid_restriction (const NPWProperty* this)
 205 {
 206         const gchar *value;
 207
 208         switch (this->restriction)
 209         {
 210         case NPW_FILENAME_RESTRICTION:
 211                 value = npw_property_get_value (this);
 212
 213                 /* First character should be letters, digit or '_' */
 214                 if (value == NULL) return TRUE;
 215                 if (!isalnum (*value) && (*value != '_'))
 216                         return FALSE;
 217
 218                 /* Following characters should be letters, digit or '_'
 219                  * or '-' or '.' */
 220                 for (value++; *value != '\0'; value++)
 221                 {
 222                         if (!isalnum (*value)
 223                             && (*value != '_')
 224                             && (*value != '-')
 225                             && (*value != '.'))
 226                                 return FALSE;
 227                 }
 228                 break;
 229         default:
 230                 break;
 231         }
 232
 233         return TRUE;
 234 }
 235
 236 void
 237 npw_property_set_name (NPWProperty* this, const gchar* name)
 238 {
 239         this->value = npw_value_heap_find_value (this->owner->value, name);
 240 }
 241
 242 const gchar*
 243 npw_property_get_name (const NPWProperty* this)
 244 {
 245         return npw_value_heap_get_name (this->owner->value, this->value);
 246 }
 247
 248 void
 249 npw_property_set_label (NPWProperty* this, const gchar* label)
 250 {
 251         this->label = g_string_chunk_insert (this->owner->string_pool, label);
 252 }
 253
 254 const gchar*
 255 npw_property_get_label (const NPWProperty* this)
 256 {
 257         return this->label;
 258 }
 259
 260 void
 261 npw_property_set_description (NPWProperty* this, const gchar* description)
 262 {
 263         this->description = g_string_chunk_insert (this->owner->string_pool, description);
 264 }
 265
 266 const gchar*
 267 npw_property_get_description (const NPWProperty* this)
 268 {
 269         return this->description;
 270 }
 271
 272 static void
 273 cb_boolean_button_toggled (GtkButton *button, gpointer data)
 274 {
 275         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
 276                 gtk_button_set_label (button, _("Yes"));
 277         else
 278                 gtk_button_set_label (button, _("No"));
 279 }
 280
 281 GtkWidget*
 282 npw_property_create_widget (NPWProperty* this)
 283 {
 284         GtkWidget* entry;
 285         const gchar* value;
 286
 287         value = npw_property_get_value (this);
 288         switch (this->type)
 289         {
 290         case NPW_BOOLEAN_PROPERTY:
 291                 entry = gtk_toggle_button_new_with_label (_("No"));
 292                 g_signal_connect (G_OBJECT (entry), "toggled",
 293                                                   G_CALLBACK (cb_boolean_button_toggled), NULL);
 294                 if (value)
 295                 {
 296                         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (entry),
 297                                                                                   (gboolean)atoi (value));
 298                 }
 299                 break;
 300         case NPW_INTEGER_PROPERTY:
 301                 entry = gtk_spin_button_new (NULL, 1, 0);
 302                 if (value)
 303                 {
 304                         gtk_spin_button_set_value (GTK_SPIN_BUTTON (entry), atoi (value));
 305                 }
 306                 break;
 307         case NPW_STRING_PROPERTY:
 308                 entry = gtk_entry_new ();
 309                 if (value) gtk_entry_set_text (GTK_ENTRY (entry), value);
 310                 break;
 311         case NPW_DIRECTORY_PROPERTY:
 312                 entry = gtk_file_chooser_button_new (_("Choose directory"),
 313                                                                                          GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
 314                 if (value)
 315                 {
 316                         gchar* uri = gnome_vfs_make_uri_from_input (value);
 317                         gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (entry), uri);
 318                         g_free (uri);
 319                 }
 320                 break;
 321         case NPW_FILE_PROPERTY:
 322                 entry = gtk_file_chooser_button_new (_("Choose file"),
 323                                                                                          GTK_FILE_CHOOSER_ACTION_OPEN);
 324                 if (value)
 325                 {
 326                         gchar* uri = gnome_vfs_make_uri_from_input (value);
 327                         gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (entry), uri);
 328                         g_free (uri);
 329                 }
 330                 break;
 331         case NPW_ICON_PROPERTY:
 332                 entry = gnome_icon_entry_new("icon_choice", _("Icon choice"));
 333                 if (value) gnome_icon_entry_set_filename (GNOME_ICON_ENTRY (entry), value);
 334                 break;
 335         case NPW_LIST_PROPERTY:
 336         {
 337                 GSList* node;
 338                 gboolean get_value = FALSE;
 339
 340                 entry = gtk_combo_box_entry_new_text ();
 341                 for (node = this->item; node != NULL; node = node->next)
 342                 {
 343                         gtk_combo_box_append_text (GTK_COMBO_BOX (entry), _(((NPWItem *)node->data)->label));
 344                         if ((value != NULL) && !get_value && (strcmp (value, ((NPWItem *)node->data)->name) == 0))
 345                         {
 346                                 value = _(((NPWItem *)node->data)->label);
 347                                 get_value = TRUE;
 348                         }
 349                 }
 350                 if (!(this->options & NPW_EDITABLE_OPTION))
 351                 {
 352                         gtk_editable_set_editable (GTK_EDITABLE (GTK_BIN (entry)->child), FALSE);
 353                 }
 354                 if (value) gtk_entry_set_text (GTK_ENTRY (GTK_BIN (entry)->child), value);
 355                 break;
 356         }
 357         default:
 358                 return NULL;
 359         }
 360         this->widget = entry;
 361
 362         return entry;
 363 }
 364
 365 void
 366 npw_property_set_widget (NPWProperty* this, GtkWidget* widget)
 367 {
 368         this->widget = widget;
 369 }
 370
 371 GtkWidget*
 372 npw_property_get_widget (const NPWProperty* this)
 373 {
 374         return this->widget;
 375 }
 376
 377 void
 378 npw_property_set_default (NPWProperty* this, const gchar* value)
 379 {
 380         /* Check if the default property is valid */
 381         if (value && (this->options & NPW_EXIST_SET_OPTION) && !(this->options & NPW_EXIST_OPTION))
 382         {
 383                 /* a file or directory with the same name shouldn't exist */
 384                 if (g_file_test (value, G_FILE_TEST_EXISTS))
 385                 {
 386                         char* buffer;
 387                         guint i;
 388
 389                         /* Allocate memory for the string and a decimal number */
 390                         buffer = g_new (char, strlen(value) + 8);
 391                         /* Give up after 1000000 tries */
 392                         for (i = 1; i < 1000000; i++)
 393                         {
 394                                 sprintf(buffer,"%s%d",value, i);
 395                                 if (!g_file_test (buffer, G_FILE_TEST_EXISTS)) break;
 396                         }
 397                         this->defvalue = g_string_chunk_insert (this->owner->string_pool, buffer);
 398                         g_free (buffer);
 399
 400                         return;
 401                 }
 402         }
 403         /* This function could be used with value = defvalue to only check
 404          * the default property */
 405         if (this->defvalue != value)
 406         {
 407                 this->defvalue = (value == NULL) ? NULL : g_string_chunk_insert (this->owner->string_pool, value);
 408         }
 409 }
 410
 411 static gboolean
 412 npw_property_set_value_from_widget (NPWProperty* this, NPWValueTag tag)
 413 {
 414         gchar* alloc_value = NULL;
 415         const gchar* value = NULL;
 416         gboolean ok;
 417
 418         switch (this->type)
 419         {
 420         case NPW_INTEGER_PROPERTY:
 421                 alloc_value = g_strdup_printf("%d", gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (this->widget)));
 422                 value = alloc_value;
 423                 break;
 424         case NPW_BOOLEAN_PROPERTY:
 425                 alloc_value = g_strdup_printf("%d", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (this->widget)));
 426                 value = alloc_value;
 427                 break;
 428         case NPW_STRING_PROPERTY:
 429                 value = gtk_entry_get_text (GTK_ENTRY (this->widget));
 430                 break;
 431         case NPW_DIRECTORY_PROPERTY:
 432         case NPW_FILE_PROPERTY:
 433                 alloc_value = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (this->widget));
 434                 value = alloc_value;
 435                 break;
 436         case NPW_ICON_PROPERTY:
 437                 alloc_value = gnome_icon_entry_get_filename (GNOME_ICON_ENTRY (this->widget));
 438                 value = alloc_value;
 439                 break;
 440         case NPW_LIST_PROPERTY:
 441         {
 442                 GSList* node;
 443
 444                 value = gtk_entry_get_text (GTK_ENTRY (GTK_BIN (this->widget)->child));
 445                 for (node = this->item; node != NULL; node = node->next)
 446                 {
 447                         if (strcmp (value, _(((NPWItem *)node->data)->label)) == 0)
 448                         {
 449                                 value = ((NPWItem *)node->data)->name;
 450                                 break;
 451                         }
 452                 }
 453                 break;
 454         }
 455         default:
 456                 /* Hidden property */
 457                 value = this->defvalue;
 458                 break;
 459         }
 460
 461         /* Check and mark default value (will not be saved) */
 462         if ((value) && (this->defvalue) && (strcmp (value, this->defvalue) == 0))
 463         {
 464                 tag |= NPW_DEFAULT_VALUE;
 465         }
 466
 467         ok = npw_value_heap_set_value (this->owner->value, this->value, value, tag);
 468         if (alloc_value != NULL) g_free (alloc_value);
 469
 470         return ok;
 471 }
 472
 473 gboolean
 474 npw_property_update_value_from_widget (NPWProperty* this)
 475 {
 476         return npw_property_set_value_from_widget (this, NPW_VALID_VALUE);
 477 }
 478
 479 gboolean
 480 npw_property_save_value_from_widget (NPWProperty* this)
 481 {
 482         return npw_property_set_value_from_widget (this, NPW_OLD_VALUE);
 483 }
 484
 485 gboolean
 486 npw_property_remove_value (NPWProperty* this)
 487 {
 488         return npw_value_heap_set_value (this->owner->value, this->value, NULL, NPW_EMPTY_VALUE);
 489 }
 490
 491 const char*
 492 npw_property_get_value (const NPWProperty* this)
 493 {
 494         NPWValueTag tag;
 495
 496         tag = npw_value_heap_get_tag (this->owner->value, this->value);
 497         if ((tag == NPW_EMPTY_VALUE) || (tag & NPW_DEFAULT_VALUE))
 498         {
 499                 return this->defvalue;
 500         }
 501         else
 502         {
 503                 /* Only value entered by user could replace default value */
 504                 return npw_value_heap_get_value (this->owner->value, this->value);
 505         }
 506 }
 507
 508 gboolean
 509 npw_property_add_list_item (NPWProperty* this, const gchar* name, const gchar* label)
 510 {
 511         NPWItem* item;
 512
 513         item  = g_chunk_new (NPWItem, this->owner->item_pool);
 514         item->name = g_string_chunk_insert (this->owner->string_pool, name);
 515         item->label = g_string_chunk_insert (this->owner->string_pool, label);
 516
 517         this->item = g_slist_append (this->item, item);
 518
 519         return TRUE;
 520 }
 521
 522 void
 523 npw_property_set_mandatory_option (NPWProperty* this, gboolean value)
 524 {
 525         if (value)
 526         {
 527                 this->options |= NPW_MANDATORY_OPTION;
 528         }
 529         else
 530         {
 531                 this->options &= ~NPW_MANDATORY_OPTION;
 532         }
 533 }
 534
 535 void
 536 npw_property_set_summary_option (NPWProperty* this, gboolean value)
 537 {
 538         if (value)
 539         {
 540                 this->options |= NPW_SUMMARY_OPTION;
 541         }
 542         else
 543         {
 544                 this->options &= ~NPW_SUMMARY_OPTION;
 545         }
 546 }
 547
 548 void
 549 npw_property_set_editable_option (NPWProperty* this, gboolean value)
 550 {
 551         if (value)
 552         {
 553                 this->options |= NPW_EDITABLE_OPTION;
 554         }
 555         else
 556         {
 557                 this->options &= ~NPW_EDITABLE_OPTION;
 558         }
 559 }
 560
 561 NPWPropertyOptions
 562 npw_property_get_options (const NPWProperty* this)
 563 {
 564         return this->options;
 565 }
 566
 567 void
 568 npw_property_set_exist_option (NPWProperty* this, NPWPropertyBooleanValue value)
 569 {
 570         switch (value)
 571         {
 572         case NPW_TRUE:
 573                 this->options |= NPW_EXIST_OPTION | NPW_EXIST_SET_OPTION;
 574                 break;
 575         case NPW_FALSE:
 576                 this->options &= ~NPW_EXIST_OPTION;
 577                 this->options |= NPW_EXIST_SET_OPTION;
 578                 npw_property_set_default (this, this->defvalue);
 579                 break;
 580         case NPW_DEFAULT:
 581                 this->options &= ~(NPW_EXIST_OPTION | NPW_EXIST_SET_OPTION);
 582                 break;
 583         }
 584 }
 585
 586 NPWPropertyBooleanValue
 587 npw_property_get_exist_option (const NPWProperty* this)
 588 {
 589         return this->options & NPW_EXIST_SET_OPTION ? (this->options & NPW_EXIST_OPTION ? NPW_TRUE : NPW_FALSE) : NPW_DEFAULT;
 590 }
 591
 592 /* Page object = list of properties
 593  *---------------------------------------------------------------------------*/
 594
 595 NPWPage*
 596 npw_page_new (NPWValueHeap* value)
 597 {
 598         NPWPage* this;
 599
 600         this = g_new0(NPWPage, 1);
 601         this->string_pool = g_string_chunk_new (STRING_CHUNK_SIZE);
 602         this->data_pool = g_mem_chunk_new ("property pool", sizeof (NPWProperty), STRING_CHUNK_SIZE * sizeof (NPWProperty) / 4, G_ALLOC_ONLY);
 603         this->item_pool = g_mem_chunk_new ("item pool", sizeof (NPWItem), STRING_CHUNK_SIZE * sizeof (NPWItem) / 4, G_ALLOC_ONLY);
 604         this->list = g_node_new (NULL);
 605         this->value = value;
 606
 607         return this;
 608 }
 609
 610 void
 611 npw_page_free (NPWPage* this)
 612 {
 613         g_return_if_fail (this != NULL);
 614
 615         g_string_chunk_free (this->string_pool);
 616         g_mem_chunk_destroy (this->data_pool);
 617         g_mem_chunk_destroy (this->item_pool);
 618         g_node_destroy (this->list);
 619         g_free (this);
 620 }
 621
 622 void
 623 npw_page_set_name (NPWPage* this, const gchar* name)
 624 {
 625         this->name = g_string_chunk_insert (this->string_pool, name);
 626 }
 627
 628 const gchar*
 629 npw_page_get_name (const NPWPage* this)
 630 {
 631         return this->name;
 632 }
 633
 634 void
 635 npw_page_set_label (NPWPage* this, const gchar* label)
 636 {
 637         this->label = g_string_chunk_insert (this->string_pool, label);
 638 }
 639
 640 const gchar*
 641 npw_page_get_label (const NPWPage* this)
 642 {
 643         return this->label;
 644 }
 645
 646 void
 647 npw_page_set_description (NPWPage* this, const gchar* description)
 648 {
 649         this->description = g_string_chunk_insert (this->string_pool, description);
 650 }
 651
 652 const gchar*
 653 npw_page_get_description (const NPWPage* this)
 654 {
 655         return this->description;
 656 }
 657
 658 typedef struct _PageForeachPropertyData
 659 {
 660         NPWPropertyForeachFunc func;
 661         gpointer data;
 662 } PageForeachPropertyData;
 663
 664 static void
 665 cb_page_foreach_property (GNode* node, gpointer data)
 666 {
 667         PageForeachPropertyData* d = (PageForeachPropertyData *)data;
 668
 669         (d->func)((NPWProperty*)node->data, d->data);
 670 }
 671
 672 void
 673 npw_page_foreach_property (const NPWPage* this, NPWPropertyForeachFunc func, gpointer data)
 674 {
 675         PageForeachPropertyData d;
 676
 677         d.func = func;
 678         d.data = data;
 679         g_node_children_foreach (this->list, G_TRAVERSE_LEAFS, cb_page_foreach_property, &d);
 680 }