libanjuta/anjuta-utils.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * anjuta-utils.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 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  * SECTION:anjuta-utils
  23  * @title: Utilities
  24  * @short_description: Utility functions
  25  * @see_also:
  26  * @stability: Unstable
  27  * @include: libanjuta/anjuta-utils.h
  28  *
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #  include <config.h>
  33 #endif
  34
  35 #include <errno.h>
  36 #include <ctype.h>
  37 #include <limits.h>
  38 #include <stdlib.h>
  39 #include <sys/stat.h>
  40 #include <sys/types.h>
  41 #include <sys/fcntl.h>
  42 #include <sys/termios.h>
  43 #include <dirent.h>
  44 #include <unistd.h>
  45 #include <stdio.h>
  46 #include <string.h>
  47
  48 #include <glib/gi18n.h>
  49 #include <glib.h>
  50
  51 #include <libgnome/gnome-util.h>
  52
  53 #include <libanjuta/anjuta-utils.h>
  54 #include <libanjuta/anjuta-debug.h>
  55
  56 #include <libgnomevfs/gnome-vfs.h>
  57
  58 #define FILE_BUFFER_SIZE 1024
  59
  60 gboolean
  61 anjuta_util_copy_file (gchar * src, gchar * dest, gboolean show_error)
  62 {
  63         FILE *input_fp, *output_fp;
  64         gchar buffer[FILE_BUFFER_SIZE];
  65         gint bytes_read, bytes_written;
  66         gboolean error;
  67
  68         error = TRUE;
  69
  70         input_fp = fopen (src, "rb");
  71         if (input_fp == NULL)
  72         {
  73                 if( show_error)
  74                         anjuta_util_dialog_error_system (NULL, errno,
  75                                                                                          _("Unable to read file: %s."),
  76                                                                                          src);
  77                 return FALSE;
  78         }
  79
  80         output_fp = fopen (dest, "wb");
  81         if (output_fp == NULL)
  82         {
  83                 if( show_error)
  84                         anjuta_util_dialog_error_system (NULL, errno,
  85                                                                                          _("Unable to create file: %s."),
  86                                                                                          dest);
  87                 fclose (input_fp);
  88                 return TRUE;
  89         }
  90
  91         for (;;)
  92         {
  93                 bytes_read = fread (buffer, 1, FILE_BUFFER_SIZE, input_fp);
  94                 if (bytes_read != FILE_BUFFER_SIZE && ferror (input_fp))
  95                 {
  96                         error = FALSE;
  97                         break;
  98                 }
  99
 100                 if (bytes_read)
 101                 {
 102                         bytes_written = fwrite (buffer, 1, bytes_read, output_fp);
 103                         if (bytes_read != bytes_written)
 104                         {
 105                                 error = FALSE;
 106                                 break;
 107                         }
 108                 }
 109
 110                 if (bytes_read != FILE_BUFFER_SIZE && feof (input_fp))
 111                 {
 112                         break;
 113                 }
 114         }
 115
 116         fclose (input_fp);
 117         fclose (output_fp);
 118
 119         if( show_error && (error == FALSE))
 120                 anjuta_util_dialog_error_system (NULL, errno,
 121                                                                                  _("Unable to complete file copy"));
 122         return error;
 123 }
 124
 125 void
 126 anjuta_util_color_from_string (const gchar * val, guint16 * r, guint16 * g, guint16 * b)
 127 {
 128         GdkColor color;
 129         if (gdk_color_parse(val, &color))
 130         {
 131                 *r = color.red;
 132                 *g = color.green;
 133                 *b =color.blue;
 134         }
 135 }
 136
 137 gchar *
 138 anjuta_util_string_from_color (guint16 r, guint16 g, guint16 b)
 139 {
 140         return g_strdup_printf("#%02x%02x%02x", r >> 8, g >> 8, b >> 8);
 141 }
 142
 143 /* Get a GdkColor from preferences. Free the color with gdk_color_free() */
 144 GdkColor*
 145 anjuta_util_convert_color(AnjutaPreferences* prefs, const gchar* pref_name)
 146 {
 147         GdkColor* color = g_new0(GdkColor, 1);
 148         gchar* color_string = anjuta_preferences_get(prefs, pref_name);
 149         gdk_color_parse(color_string, color);
 150         return color;
 151 }
 152
 153 GtkWidget*
 154 anjuta_util_button_new_with_stock_image (const gchar* text,
 155                                                                                  const gchar* stock_id)
 156 {
 157         GtkWidget *button;
 158         GtkStockItem item;
 159         GtkWidget *label;
 160         GtkWidget *image;
 161         GtkWidget *hbox;
 162         GtkWidget *align;
 163
 164         button = gtk_button_new ();
 165
 166         if (GTK_BIN (button)->child)
 167                 gtk_container_remove (GTK_CONTAINER (button),
 168                                       GTK_BIN (button)->child);
 169
 170         if (gtk_stock_lookup (stock_id, &item))
 171         {
 172                 label = gtk_label_new_with_mnemonic (text);
 173
 174                 gtk_label_set_mnemonic_widget (GTK_LABEL (label), GTK_WIDGET (button));
 175
 176                 image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON);
 177                 hbox = gtk_hbox_new (FALSE, 2);
 178
 179                 align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
 180
 181                 gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
 182                 gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 183
 184                 gtk_container_add (GTK_CONTAINER (button), align);
 185                 gtk_container_add (GTK_CONTAINER (align), hbox);
 186                 gtk_widget_show_all (align);
 187
 188                 return button;
 189         }
 190
 191         label = gtk_label_new_with_mnemonic (text);
 192         gtk_label_set_mnemonic_widget (GTK_LABEL (label), GTK_WIDGET (button));
 193
 194         gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
 195
 196         gtk_widget_show (label);
 197         gtk_container_add (GTK_CONTAINER (button), label);
 198
 199         return button;
 200 }
 201
 202 GtkWidget*
 203 anjuta_util_dialog_add_button (GtkDialog *dialog, const gchar* text,
 204                                                            const gchar* stock_id, gint response_id)
 205 {
 206         GtkWidget *button;
 207
 208         g_return_val_if_fail (GTK_IS_DIALOG (dialog), NULL);
 209         g_return_val_if_fail (text != NULL, NULL);
 210         g_return_val_if_fail (stock_id != NULL, NULL);
 211
 212         button = anjuta_util_button_new_with_stock_image (text, stock_id);
 213         g_return_val_if_fail (button != NULL, NULL);
 214
 215         GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 216
 217         gtk_widget_show (button);
 218
 219         gtk_dialog_add_action_widget (dialog, button, response_id);
 220
 221         return button;
 222 }
 223
 224 void
 225 anjuta_util_dialog_error (GtkWindow *parent, const gchar *mesg, ...)
 226 {
 227         gchar* message;
 228         va_list args;
 229         GtkWidget *dialog;
 230         GtkWindow *real_parent;
 231
 232         va_start (args, mesg);
 233         message = g_strdup_vprintf (mesg, args);
 234         va_end (args);
 235
 236         if (parent && GTK_IS_WINDOW (parent))
 237         {
 238                 real_parent = parent;
 239         }
 240         else
 241         {
 242                 real_parent = NULL;
 243         }
 244
 245         // Dialog to be HIG compliant
 246         dialog = gtk_message_dialog_new (real_parent,
 247                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 248                                                                          GTK_MESSAGE_ERROR,
 249                                                                          GTK_BUTTONS_CLOSE, message);
 250         g_signal_connect (G_OBJECT (dialog), "response",
 251                                           G_CALLBACK (gtk_widget_destroy), NULL);
 252         gtk_widget_show (dialog);
 253         g_free (message);
 254 }
 255
 256 void
 257 anjuta_util_dialog_warning (GtkWindow *parent, const gchar * mesg, ...)
 258 {
 259         gchar* message;
 260         va_list args;
 261         GtkWidget *dialog;
 262         GtkWindow *real_parent;
 263
 264         va_start (args, mesg);
 265         message = g_strdup_vprintf (mesg, args);
 266         va_end (args);
 267
 268         if (parent && GTK_IS_WINDOW (parent))
 269         {
 270                 real_parent = parent;
 271         }
 272         else
 273         {
 274                 real_parent = NULL;
 275         }
 276
 277         // Dialog to be HIG compliant
 278         dialog = gtk_message_dialog_new (real_parent,
 279                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 280                                                                          GTK_MESSAGE_WARNING,
 281                                                                          GTK_BUTTONS_CLOSE, message);
 282         g_signal_connect (G_OBJECT (dialog), "response",
 283                                           G_CALLBACK (gtk_widget_destroy), NULL);
 284         gtk_widget_show (dialog);
 285         g_free (message);
 286 }
 287
 288 void
 289 anjuta_util_dialog_info (GtkWindow *parent, const gchar * mesg, ...)
 290 {
 291         gchar* message;
 292         va_list args;
 293         GtkWidget *dialog;
 294         GtkWindow *real_parent;
 295
 296         va_start (args, mesg);
 297         message = g_strdup_vprintf (mesg, args);
 298         va_end (args);
 299
 300         if (parent && GTK_IS_WINDOW (parent))
 301         {
 302                 real_parent = parent;
 303         }
 304         else
 305         {
 306                 real_parent = NULL;
 307         }
 308         // Dialog to be HIG compliant
 309         dialog = gtk_message_dialog_new (real_parent,
 310                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 311                                                                          GTK_MESSAGE_INFO,
 312                                                                          GTK_BUTTONS_CLOSE, message);
 313         g_signal_connect (G_OBJECT (dialog), "response",
 314                                           G_CALLBACK (gtk_widget_destroy), NULL);
 315         gtk_widget_show (dialog);
 316         g_free (message);
 317 }
 318
 319 void
 320 anjuta_util_dialog_error_system (GtkWindow* parent, gint errnum,
 321                                                                  const gchar * mesg, ... )
 322 {
 323         gchar* message;
 324         gchar* tot_mesg;
 325         va_list args;
 326         GtkWidget *dialog;
 327         GtkWindow *real_parent;
 328
 329         va_start (args, mesg);
 330         message = g_strdup_vprintf (mesg, args);
 331         va_end (args);
 332
 333         if (0 != errnum) {
 334                 tot_mesg = g_strconcat (message, _("\nSystem: "),
 335                                                                 g_strerror(errnum), NULL);
 336                 g_free (message);
 337         } else
 338                 tot_mesg = message;
 339
 340         if (parent && GTK_IS_WINDOW (parent))
 341         {
 342                 real_parent = parent;
 343         }
 344         else
 345         {
 346                 real_parent = NULL;
 347         }
 348         // Dialog to be HIG compliant
 349         dialog = gtk_message_dialog_new (real_parent,
 350                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 351                                                                          GTK_MESSAGE_ERROR,
 352                                                                          GTK_BUTTONS_CLOSE, tot_mesg);
 353         g_signal_connect (G_OBJECT (dialog), "response",
 354                                           G_CALLBACK (gtk_widget_destroy), NULL);
 355         gtk_widget_show (dialog);
 356         g_free (tot_mesg);
 357 }
 358
 359 gboolean
 360 anjuta_util_dialog_boolean_question (GtkWindow *parent, const gchar *mesg, ...)
 361 {
 362         gchar* message;
 363         va_list args;
 364         GtkWidget *dialog;
 365         gint ret;
 366         GtkWindow *real_parent;
 367
 368         va_start (args, mesg);
 369         message = g_strdup_vprintf (mesg, args);
 370         va_end (args);
 371
 372         if (parent && GTK_IS_WINDOW (parent))
 373         {
 374                 real_parent = parent;
 375         }
 376         else
 377         {
 378                 real_parent = NULL;
 379         }
 380
 381         dialog = gtk_message_dialog_new (real_parent,
 382                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 383                                                                          GTK_MESSAGE_QUESTION,
 384                                                                          GTK_BUTTONS_YES_NO, message);
 385
 386         ret = gtk_dialog_run (GTK_DIALOG (dialog));
 387         gtk_widget_destroy (dialog);
 388         g_free (message);
 389
 390         return (ret == GTK_RESPONSE_YES);
 391 }
 392
 393 gboolean
 394 anjuta_util_dialog_input (GtkWindow *parent, const gchar *prompt,
 395                                                   const gchar *default_value, gchar **return_value)
 396 {
 397         GtkWidget *dialog, *label, *frame, *entry, *dialog_vbox, *vbox;
 398         gint res;
 399         gchar *markup;
 400         GtkWindow *real_parent;
 401
 402         if (parent && GTK_IS_WINDOW (parent))
 403         {
 404                 real_parent = parent;
 405         }
 406         else
 407         {
 408                 real_parent = NULL;
 409         }
 410
 411         dialog = gtk_dialog_new_with_buttons (prompt, real_parent,
 412                                                                                   GTK_DIALOG_DESTROY_WITH_PARENT,
 413                                                                                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 414                                                                                   GTK_STOCK_OK, GTK_RESPONSE_OK,
 415                                                                                   NULL);
 416         gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 417         dialog_vbox = GTK_DIALOG (dialog)->vbox;
 418         gtk_window_set_default_size (GTK_WINDOW (dialog), 400, -1);
 419         gtk_widget_show (dialog_vbox);
 420
 421         markup = g_strconcat ("<b>", prompt, "</b>", NULL);
 422         label = gtk_label_new (NULL);
 423         gtk_label_set_markup (GTK_LABEL (label), markup);
 424         gtk_widget_show (label);
 425         g_free (markup);
 426
 427         frame = gtk_frame_new (NULL);
 428         gtk_frame_set_label_widget (GTK_FRAME (frame), label);
 429         gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
 430         gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
 431         gtk_widget_show (frame);
 432         gtk_box_pack_start (GTK_BOX (dialog_vbox), frame, FALSE, FALSE, 0);
 433
 434         vbox = gtk_vbox_new (FALSE, 0);
 435         gtk_widget_show (vbox);
 436         gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
 437         gtk_container_add (GTK_CONTAINER (frame), vbox);
 438
 439         entry = gtk_entry_new ();
 440         gtk_widget_show (entry);
 441         gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
 442         gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
 443         if (default_value)
 444                 gtk_entry_set_text (GTK_ENTRY (entry), default_value);
 445
 446         res = gtk_dialog_run (GTK_DIALOG (dialog));
 447
 448         if (gtk_entry_get_text (GTK_ENTRY (entry)) &&
 449                 strlen (gtk_entry_get_text (GTK_ENTRY (entry))) > 0)
 450         {
 451                 *return_value = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
 452         }
 453         else
 454         {
 455                 *return_value = NULL;
 456         }
 457         gtk_widget_destroy (dialog);
 458         return (res == GTK_RESPONSE_OK);
 459 }
 460
 461 gboolean
 462 anjuta_util_prog_is_installed (gchar * prog, gboolean show)
 463 {
 464         gchar* prog_path = g_find_program_in_path (prog);
 465         if (prog_path)
 466         {
 467                 g_free (prog_path);
 468                 return TRUE;
 469         }
 470         if (show)
 471         {
 472                 anjuta_util_dialog_error (NULL, _("The \"%s\" utility is not installed.\n"
 473                                           "Please install it."), prog);
 474         }
 475         return FALSE;
 476 }
 477
 478 gchar *
 479 anjuta_util_get_a_tmp_file (void)
 480 {
 481         static gint count = 0;
 482         gchar *filename;
 483         const gchar *tmpdir;
 484
 485         tmpdir = g_get_tmp_dir ();
 486         filename =
 487                 g_strdup_printf ("%s/anjuta_%d.%d", tmpdir, count++, getpid ());
 488         return filename;
 489 }
 490
 491 /* GList of strings operations */
 492 GList *
 493 anjuta_util_glist_from_string (const gchar *string)
 494 {
 495         gchar *str, *temp, buff[256];
 496         GList *list;
 497         gchar *word_start, *word_end;
 498         gboolean the_end;
 499
 500         list = NULL;
 501         the_end = FALSE;
 502         temp = g_strdup (string);
 503         str = temp;
 504         if (!str)
 505                 return NULL;
 506
 507         while (1)
 508         {
 509                 gint i;
 510                 gchar *ptr;
 511
 512                 /* Remove leading spaces */
 513                 while (isspace (*str) && *str != '\0')
 514                         str++;
 515                 if (*str == '\0')
 516                         break;
 517
 518                 /* Find start and end of word */
 519                 word_start = str;
 520                 while (!isspace (*str) && *str != '\0')
 521                         str++;
 522                 word_end = str;
 523
 524                 /* Copy the word into the buffer */
 525                 for (ptr = word_start, i = 0; ptr < word_end; ptr++, i++)
 526                         buff[i] = *ptr;
 527                 buff[i] = '\0';
 528                 if (strlen (buff))
 529                         list = g_list_append (list, g_strdup (buff));
 530                 if (*str == '\0')
 531                         break;
 532         }
 533         if (temp)
 534                 g_free (temp);
 535         return list;
 536 }
 537
 538 /* Prefix the strings */
 539 void
 540 anjuta_util_glist_strings_prefix (GList * list, const gchar *prefix)
 541 {
 542         GList *node;
 543         node = list;
 544
 545         g_return_if_fail (prefix != NULL);
 546         while (node)
 547         {
 548                 gchar* tmp;
 549                 tmp = node->data;
 550                 node->data = g_strconcat (prefix, tmp, NULL);
 551                 if (tmp) g_free (tmp);
 552                 node = g_list_next (node);
 553         }
 554 }
 555
 556 /* Suffix the strings */
 557 void
 558 anjuta_util_glist_strings_sufix (GList * list, const gchar *sufix)
 559 {
 560         GList *node;
 561         node = list;
 562
 563         g_return_if_fail (sufix != NULL);
 564         while (node)
 565         {
 566                 gchar* tmp;
 567                 tmp = node->data;
 568                 node->data = g_strconcat (tmp, sufix, NULL);
 569                 if (tmp) g_free (tmp);
 570                 node = g_list_next (node);
 571         }
 572 }
 573
 574 /* Duplicate list of strings */
 575 GList*
 576 anjuta_util_glist_strings_dup (GList * list)
 577 {
 578         GList *node;
 579         GList *new_list;
 580
 581         new_list = NULL;
 582         node = list;
 583         while (node)
 584         {
 585                 if (node->data)
 586                         new_list = g_list_append (new_list, g_strdup(node->data));
 587                 else
 588                         new_list = g_list_append (new_list, NULL);
 589                 node = g_list_next (node);
 590         }
 591         return new_list;
 592 }
 593
 594 gchar*
 595 anjuta_util_get_real_path (const gchar *path)
 596 {
 597         if (path != NULL)
 598         {
 599 #ifdef PATH_MAX
 600                 gchar *result;
 601                 gchar buf[PATH_MAX+1];
 602
 603                 result = realpath (path, buf);
 604                 if (result != NULL)
 605                 {
 606                         *(buf + PATH_MAX) = '\0'; /* ensure a terminator */
 607                         return g_strdup (buf);
 608                 }
 609 #else
 610                 /* strictly, the string returned from this should be cleaned with
 611                    free(), not g_free() */
 612                 return (realpath (path, NULL));
 613 #endif
 614         }
 615         return NULL;
 616 }
 617
 618 /* Dedup a list of paths - duplicates are removed from the tail.
 619 ** Useful for deduping Recent Files and Recent Projects */
 620 GList*
 621 anjuta_util_glist_path_dedup(GList *list)
 622 {
 623         GList *nlist = NULL, *tmp, *tmp1;
 624         gchar *path;
 625         struct stat s;
 626         for (tmp = list; tmp; tmp = g_list_next(tmp))
 627         {
 628                 path = anjuta_util_get_real_path ((const gchar *) tmp->data);
 629                 if (path)
 630                 {
 631                         if (stat (path, &s) != 0)
 632                         {
 633                                 g_free(path);
 634                         }
 635                         else
 636                         {
 637                                 for (tmp1 = nlist; tmp1; tmp1 = g_list_next(tmp1))
 638                                 {
 639                                         if (0 == strcmp((const char *) tmp1->data, path))
 640                                         {
 641                                                 g_free(path);
 642                                                 path = NULL;
 643                                                 break;
 644                                         }
 645                                 }
 646                                 if (path)
 647                                 nlist = g_list_prepend(nlist, path);
 648                         }
 649                 }
 650         }
 651         anjuta_util_glist_strings_free(list);
 652         nlist = g_list_reverse(nlist);
 653         return nlist;
 654 }
 655
 656 static gint
 657 sort_node (gchar* a, gchar *b)
 658 {
 659         if ( !a && !b) return 0;
 660         else if (!a) return -1;
 661         else if (!b) return 1;
 662         return strcmp (a, b);
 663 }
 664
 665 /* Sort the list alphabatically */
 666 GList*
 667 anjuta_util_glist_strings_sort (GList * list)
 668 {
 669         return g_list_sort(list, (GCompareFunc)sort_node);
 670 }
 671
 672 /* Free the strings and GList */
 673 void
 674 anjuta_util_glist_strings_free (GList * list)
 675 {
 676         GList *node;
 677         node = list;
 678         while (node)
 679         {
 680                 if (node->data)
 681                         g_free (node->data);
 682                 node = g_list_next (node);
 683         }
 684         g_list_free (list);
 685 }
 686
 687 int
 688 anjuta_util_type_from_string (AnjutaUtilStringMap *map, const char *str)
 689 {
 690         int i = 0;
 691
 692         while (-1 != map[i].type)
 693         {
 694                 if (0 == strcmp(map[i].name, str))
 695                         return map[i].type;
 696                 ++ i;
 697         }
 698         return -1;
 699 }
 700
 701 const char*
 702 anjuta_util_string_from_type (AnjutaUtilStringMap *map, int type)
 703 {
 704         int i = 0;
 705         while (-1 != map[i].type)
 706         {
 707                 if (map[i].type == type)
 708                         return map[i].name;
 709                 ++ i;
 710         }
 711         return "";
 712 }
 713
 714 GList*
 715 anjuta_util_glist_from_map (AnjutaUtilStringMap *map)
 716 {
 717         GList *out_list = NULL;
 718         int i = 0;
 719         while (-1 != map[i].type)
 720         {
 721                 out_list = g_list_append(out_list, map[i].name);
 722                 ++ i;
 723         }
 724         return out_list;
 725 }
 726
 727
 728 GList *
 729 anjuta_util_update_string_list (GList *p_list, const gchar *p_str, gint length)
 730 {
 731         gint i;
 732         gchar *str;
 733         if (!p_str)
 734                 return p_list;
 735         for (i = 0; i < g_list_length (p_list); i++)
 736         {
 737                 str = (gchar *) g_list_nth_data (p_list, i);
 738                 if (!str)
 739                         continue;
 740                 if (strcmp (p_str, str) == 0)
 741                 {
 742                         p_list = g_list_remove (p_list, str);
 743                         p_list = g_list_prepend (p_list, str);
 744                         return p_list;
 745                 }
 746         }
 747         p_list = g_list_prepend (p_list, g_strdup (p_str));
 748         while (g_list_length (p_list) > length)
 749         {
 750                 str = g_list_nth_data (p_list, g_list_length (p_list) - 1);
 751                 p_list = g_list_remove (p_list, str);
 752                 g_free (str);
 753         }
 754         return p_list;
 755 }
 756
 757 gboolean
 758 anjuta_util_create_dir (const gchar * d)
 759 {
 760         if (g_file_test (d, G_FILE_TEST_IS_DIR))
 761                 return TRUE;
 762         if (mkdir (d, 0755))
 763                 return FALSE;
 764         return TRUE;
 765 }
 766
 767 pid_t
 768 anjuta_util_execute_shell (const gchar *dir, const gchar *command)
 769 {
 770         pid_t pid;
 771         gchar *shell;
 772
 773         g_return_val_if_fail (command != NULL, -1);
 774
 775         shell = gnome_util_user_shell ();
 776         pid = fork();
 777         if (pid == 0)
 778         {
 779                 if(dir)
 780                 {
 781                         anjuta_util_create_dir (dir);
 782                         chdir (dir);
 783                 }
 784                 execlp (shell, shell, "-c", command, NULL);
 785                 g_warning (_("Cannot execute command: %s (using shell %s)\n"), command, shell);
 786                 _exit(1);
 787         }
 788         if (pid < 0)
 789                 g_warning (_("Cannot execute command %s (using shell %s)\n"), command, shell);
 790         g_free (shell);
 791         // Anjuta will take care of child exit automatically.
 792         return pid;
 793 }
 794
 795 gchar *
 796 anjuta_util_convert_to_utf8 (const gchar *str)
 797 {
 798         GError *error = NULL;
 799         gchar *utf8_msg_string = NULL;
 800
 801         g_return_val_if_fail (str != NULL, NULL);
 802         g_return_val_if_fail (strlen (str) > 0, NULL);
 803
 804         if (g_utf8_validate(str, -1, NULL))
 805         {
 806                 utf8_msg_string = g_strdup (str);
 807         }
 808         else
 809         {
 810                 gsize rbytes, wbytes;
 811                 utf8_msg_string = g_locale_to_utf8 (str, -1, &rbytes, &wbytes, &error);
 812                 if (error != NULL) {
 813                         g_warning ("g_locale_to_utf8 failed: %s\n", error->message);
 814                         g_error_free (error);
 815                         /* g_free (utf8_msg_string);
 816                         return NULL; */
 817                 }
 818         }
 819         return utf8_msg_string;
 820 }
 821
 822 GList*
 823 anjuta_util_parse_args_from_string (const gchar* string)
 824 {
 825         gboolean escaped;
 826         gchar    quote = 0;
 827         gboolean is_quote = FALSE;
 828         gchar* buffer = g_new0(gchar, strlen(string) + 1);
 829         const gchar *s;
 830         gint     idx;
 831         GList* args = NULL;
 832
 833         idx = 0;
 834         escaped = FALSE;
 835         s = string;
 836
 837         while (*s) {
 838                 if (!isspace(*s))
 839                         break;
 840                 s++;
 841         }
 842
 843         while (*s) {
 844                 if (escaped) {
 845                         /* The current char was escaped */
 846                         buffer[idx++] = *s;
 847                         escaped = FALSE;
 848                 } else if (*s == '\\') {
 849                         /* Current char is an escape */
 850                         escaped = TRUE;
 851                 } else if (*s == quote) {
 852                         /* Current char ends a quotation */
 853                         is_quote = FALSE;
 854                         if (!isspace(*(s+1)) && (*(s+1) != '\0')) {
 855                                 /* If there is no space after the quotation or it is not
 856                                    the end of the string */
 857                                 g_warning ("Parse error while parsing program arguments");
 858                         }
 859                 } else if ((*s == '\"' || *s == '\'')) {
 860                         if (!is_quote) {
 861                                 /* Current char starts a quotation */
 862                                 quote = *s;
 863                                 is_quote = TRUE;
 864                         } else {
 865                                 /* Just a quote char inside quote */
 866                                 buffer[idx++] = *s;
 867                         }
 868                 } else if (is_quote){
 869                         /* Any other char inside quote */
 870                         buffer[idx++] = *s;
 871                 } else if (isspace(*s)) {
 872                         /* Any white space outside quote */
 873                         if (idx > 0) {
 874                                 buffer[idx++] = '\0';
 875                                 args = g_list_append (args, g_strdup (buffer));
 876                                 idx = 0;
 877                         }
 878                 } else {
 879                         buffer[idx++] = *s;
 880                 }
 881                 s++;
 882         }
 883         if (idx > 0) {
 884                 /* There are chars in the buffer. Flush as the last arg */
 885                 buffer[idx++] = '\0';
 886                 args = g_list_append (args, g_strdup (buffer));
 887                 idx = 0;
 888         }
 889         if (is_quote) {
 890                 g_warning ("Unclosed quotation encountered at the end of parsing");
 891         }
 892         return args;
 893 }
 894
 895 gchar*
 896 anjuta_util_escape_quotes(const gchar* str)
 897 {
 898         gchar *buffer;
 899         gint idx, max_size;
 900         const gchar *s = str;
 901
 902         g_return_val_if_fail(str, NULL);
 903         idx = 0;
 904
 905         /* We are assuming there will be less than 2048 chars to escape */
 906         max_size = strlen(str) + 2048;
 907         buffer = g_new (gchar, max_size);
 908         max_size -= 2;
 909
 910         while(*s) {
 911                 if (idx > max_size)
 912                         break;
 913                 if (*s == '\"' || *s == '\'' || *s == '\\')
 914                         buffer[idx++] = '\\';
 915                 buffer[idx++] = *s;
 916                 s++;
 917         }
 918         buffer[idx] = '\0';
 919         return buffer;
 920 }
 921
 922 /* Diff the text contained in uri with text. Return true if files
 923 differ, FALSE if they are identical.
 924 FIXME: Find a better algorithm, this seems ineffective */
 925
 926 gboolean anjuta_util_diff(const gchar* uri, const gchar* text)
 927 {
 928         GnomeVFSFileSize bytes_read;
 929         gchar* file_text;
 930         GnomeVFSFileInfo info;
 931         GnomeVFSHandle* handle = NULL;
 932
 933         gnome_vfs_get_file_info(uri, &info, GNOME_VFS_FILE_INFO_DEFAULT);
 934
 935         if (info.size == 0 && text == NULL)
 936                 return FALSE;
 937         else if (info.size == 0 || text == NULL)
 938                 return TRUE;
 939
 940         file_text = g_new0(gchar, info.size + 1);
 941
 942         if (gnome_vfs_open(&handle, uri, GNOME_VFS_OPEN_READ != GNOME_VFS_OK))
 943                 return TRUE;
 944
 945         if ((gnome_vfs_read(handle, file_text, info.size, &bytes_read) == GNOME_VFS_OK)
 946                 && (bytes_read == info.size))
 947         {
 948                 gnome_vfs_close(handle);
 949
 950                 if ((g_utf8_strlen(file_text, -1) == g_utf8_strlen(text, -1))
 951                         && strcmp(file_text, text) == 0)
 952                         return FALSE;
 953                 return TRUE;
 954         }
 955         else
 956         {
 957                 gnome_vfs_close(handle);
 958                 return TRUE;
 959         }
 960 }
 961
 962 gboolean
 963 anjuta_util_path_has_extension (const gchar *path, const gchar *ext)
 964 {
 965         if (strlen (path) <= strlen (ext))
 966                 return FALSE;
 967         if ((path[strlen (path) - strlen (ext) - 1] == '.') &&
 968                 (strcmp (&path[strlen (path) - strlen (ext)], ext) == 0))
 969                 return TRUE;
 970         return FALSE;
 971 }
 972
 973 gchar *
 974 anjuta_util_get_uri_mime_type (const gchar *uri)
 975 {
 976         GnomeVFSURI *vfs_uri;
 977         const gchar *path;
 978         gchar *mime_type;
 979
 980         g_return_val_if_fail (uri != NULL, NULL);
 981
 982         vfs_uri = gnome_vfs_uri_new (uri);
 983         if (vfs_uri)
 984                 path = gnome_vfs_uri_get_path (vfs_uri);
 985         else
 986                 path = NULL;
 987
 988         /* If Anjuta is not installed in system gnome prefix, the mime types
 989          * may not have been correctly registed. In that case, we use the
 990          * following mime detection
 991          */
 992         if (!path)
 993         {
 994                 mime_type = gnome_vfs_get_mime_type (uri);
 995         }
 996         else if (anjuta_util_path_has_extension (path, "anjuta"))
 997         {
 998                 mime_type = g_strdup ("application/x-anjuta");
 999         }
1000         else if (anjuta_util_path_has_extension (path, "prj"))
1001         {
1002                 mime_type = g_strdup ("application/x-anjuta-old");
1003         }
1004         else if (anjuta_util_path_has_extension (path, "ui"))
1005         {
1006                 mime_type = g_strdup ("text/xml");
1007         }
1008         else if (anjuta_util_path_has_extension (path, "glade"))
1009         {
1010                 mime_type = g_strdup ("application/x-glade");
1011         }
1012         else
1013         {
1014                 mime_type = gnome_vfs_get_mime_type (uri);
1015         }
1016
1017         if (vfs_uri)
1018                 gnome_vfs_uri_unref (vfs_uri);
1019         return mime_type;
1020 }
1021
1022 #ifndef HAVE_LIBUTIL
1023 #include <grp.h>
1024
1025 static int ptym_open (char *pts_name);
1026 static int ptys_open (int fdm, char * pts_name);
1027
1028 int
1029 login_tty(int ttyfd)
1030 {
1031   int fd;
1032   char *fdname;
1033
1034 #ifdef HAVE_SETSID
1035   setsid();
1036 #endif
1037 #ifdef HAVE_SETPGID
1038   setpgid(0, 0);
1039 #endif
1040
1041   /* First disconnect from the old controlling tty. */
1042 #ifdef TIOCNOTTY
1043   fd = open("/dev/tty", O_RDWR|O_NOCTTY);
1044   if (fd >= 0)
1045     {
1046       ioctl(fd, TIOCNOTTY, NULL);
1047       close(fd);
1048     }
1049   else
1050     //syslog(LOG_WARNING, "NO CTTY");
1051 #endif /* TIOCNOTTY */
1052
1053   /* Verify that we are successfully disconnected from the controlling tty. */
1054   fd = open("/dev/tty", O_RDWR|O_NOCTTY);
1055   if (fd >= 0)
1056     {
1057       //syslog(LOG_WARNING, "Failed to disconnect from controlling tty.");
1058       close(fd);
1059     }
1060
1061   /* Make it our controlling tty. */
1062 #ifdef TIOCSCTTY
1063   ioctl(ttyfd, TIOCSCTTY, NULL);
1064 #endif /* TIOCSCTTY */
1065
1066   fdname = ttyname (ttyfd);
1067   fd = open(fdname, O_RDWR);
1068   if (fd < 0)
1069     ;//syslog(LOG_WARNING, "open %s: %s", fdname, strerror(errno));
1070   else
1071     close(fd);
1072
1073   /* Verify that we now have a controlling tty. */
1074   fd = open("/dev/tty", O_WRONLY);
1075   if (fd < 0)
1076     {
1077       //syslog(LOG_WARNING, "open /dev/tty: %s", strerror(errno));
1078       return 1;
1079     }
1080
1081   close(fd);
1082 #if defined(HAVE_VHANGUP) && !defined(HAVE_REVOKE)
1083   {
1084     RETSIGTYPE (*sig)();
1085     sig = signal(SIGHUP, SIG_IGN);
1086     vhangup();
1087     signal(SIGHUP, sig);
1088   }
1089 #endif
1090   fd = open(fdname, O_RDWR);
1091   if (fd == -1)
1092     {
1093       //syslog(LOG_ERR, "can't reopen ctty %s: %s", fdname, strerror(errno));
1094       return -1;
1095     }
1096
1097   close(ttyfd);
1098
1099   if (fd != 0)
1100     close(0);
1101   if (fd != 1)
1102     close(1);
1103   if (fd != 2)
1104     close(2);
1105
1106   dup2(fd, 0);
1107   dup2(fd, 1);
1108   dup2(fd, 2);
1109   if (fd > 2)
1110     close(fd);
1111   return 0;
1112 }
1113
1114 int
1115 openpty(int *amaster, int *aslave, char *name, struct termios *termp,
1116                 struct winsize *winp)
1117 {
1118         char line[20];
1119         *amaster = ptym_open(line);
1120         if (*amaster < 0)
1121                 return -1;
1122         *aslave = ptys_open(*amaster, line);
1123         if (*aslave < 0) {
1124                 close(*amaster);
1125                 return -1;
1126         }
1127         if (name)
1128                 strcpy(name, line);
1129 #ifndef TCSAFLUSH
1130 #define TCSAFLUSH TCSETAF
1131 #endif
1132         if (termp)
1133                 (void) tcsetattr(*aslave, TCSAFLUSH, termp);
1134 #ifdef TIOCSWINSZ
1135         if (winp)
1136                 (void) ioctl(*aslave, TIOCSWINSZ, (char *)winp);
1137 #endif
1138         return 0;
1139 }
1140
1141 static int
1142 ptym_open(char * pts_name)
1143 {
1144         int fdm;
1145 #ifdef HAVE_PTSNAME
1146         char *ptr;
1147
1148         strcpy(pts_name, "/dev/ptmx");
1149         fdm = open(pts_name, O_RDWR);
1150         if (fdm < 0)
1151                 return -1;
1152         if (grantpt(fdm) < 0) { /* grant access to slave */
1153                 close(fdm);
1154                 return -2;
1155         }
1156         if (unlockpt(fdm) < 0) { /* clear slave's lock flag */
1157                 close(fdm);
1158                 return -3;
1159         }
1160         ptr = ptsname(fdm);
1161         if (ptr == NULL) { /* get slave's name */
1162                 close (fdm);
1163                 return -4;
1164         }
1165         strcpy(pts_name, ptr); /* return name of slave */
1166         return fdm;            /* return fd of master */
1167 #else
1168         char *ptr1, *ptr2;
1169
1170         strcpy(pts_name, "/dev/ptyXY");
1171         /* array index: 012345689 (for references in following code) */
1172         for (ptr1 = "pqrstuvwxyzPQRST"; *ptr1 != 0; ptr1++) {
1173                 pts_name[8] = *ptr1;
1174                 for (ptr2 = "0123456789abcdef"; *ptr2 != 0; ptr2++) {
1175                         pts_name[9] = *ptr2;
1176                         /* try to open master */
1177                         fdm = open(pts_name, O_RDWR);
1178                         if (fdm < 0) {
1179                                 if (errno == ENOENT) /* different from EIO */
1180                                         return -1;  /* out of pty devices */
1181                                 else
1182                                         continue;  /* try next pty device */
1183                         }
1184                         pts_name[5] = 't'; /* chage "pty" to "tty" */
1185                         return fdm;   /* got it, return fd of master */
1186                 }
1187         }
1188         return -1; /* out of pty devices */
1189 #endif
1190 }
1191
1192 static int
1193 ptys_open(int fdm, char * pts_name)
1194 {
1195         int fds;
1196 #ifdef HAVE_PTSNAME
1197         /* following should allocate controlling terminal */
1198         fds = open(pts_name, O_RDWR);
1199         if (fds < 0) {
1200                 close(fdm);
1201                 return -5;
1202         }
1203         if (ioctl(fds, I_PUSH, "ptem") < 0) {
1204                 close(fdm);
1205                 close(fds);
1206                 return -6;
1207         }
1208         if (ioctl(fds, I_PUSH, "ldterm") < 0) {
1209                 close(fdm);
1210                 close(fds);
1211                 return -7;
1212         }
1213         if (ioctl(fds, I_PUSH, "ttcompat") < 0) {
1214                 close(fdm);
1215                 close(fds);
1216                 return -8;
1217         }
1218
1219         if (ioctl(fdm, I_PUSH, "pckt") < 0) {
1220                 close(fdm);
1221                 close(fds);
1222                 return -8;
1223         }
1224
1225         if (ioctl(fdm, I_SRDOPT, RMSGN|RPROTDAT) < 0) {
1226                 close(fdm);
1227                 close(fds);
1228                 return -8;
1229         }
1230
1231         return fds;
1232 #else
1233         int gid;
1234         struct group *grptr;
1235
1236         grptr = getgrnam("tty");
1237         if (grptr != NULL)
1238                 gid = grptr->gr_gid;
1239         else
1240                 gid = -1;  /* group tty is not in the group file */
1241         /* following two functions don't work unless we're root */
1242         chown(pts_name, getuid(), gid);
1243         chmod(pts_name, S_IRUSR | S_IWUSR | S_IWGRP);
1244         fds = open(pts_name, O_RDWR);
1245         if (fds < 0) {
1246                 close(fdm);
1247                 return -1;
1248         }
1249         return fds;
1250 #endif
1251 }
1252
1253 int
1254 forkpty(int *amaster, char *name, struct termios *termp, struct winsize *winp)
1255 {
1256   int master, slave, pid;
1257
1258   if (openpty(&master, &slave, name, termp, winp) == -1)
1259     return (-1);
1260   switch (pid = fork()) {
1261   case -1:
1262     return (-1);
1263   case 0:
1264     /*
1265      * child
1266      */
1267     close(master);
1268     login_tty(slave);
1269     return (0);
1270   }
1271   /*
1272    * parent
1273    */
1274   *amaster = master;
1275   close(slave);
1276   return (pid);
1277 }
1278
1279 int scandir(const char *dir, struct dirent ***namelist,
1280             int (*select)(const struct dirent *),
1281             int (*compar)(const struct dirent **, const struct dirent **))
1282 {
1283   DIR *d;
1284   struct dirent *entry;
1285   register int i=0;
1286   size_t entrysize;
1287
1288   if ((d=opendir(dir)) == NULL)
1289      return(-1);
1290
1291   *namelist=NULL;
1292   while ((entry=readdir(d)) != NULL)
1293   {
1294     if (select == NULL || (select != NULL && (*select)(entry)))
1295     {
1296       *namelist=(struct dirent **)realloc((void *)(*namelist),
1297                  (size_t)((i+1)*sizeof(struct dirent *)));
1298         if (*namelist == NULL) return(-1);
1299         entrysize=sizeof(struct dirent)-sizeof(entry->d_name)+strlen(entry->d_name)+1;
1300         (*namelist)[i]=(struct dirent *)malloc(entrysize);
1301         if ((*namelist)[i] == NULL) return(-1);
1302         memcpy((*namelist)[i], entry, entrysize);
1303         i++;
1304     }
1305   }
1306   if (closedir(d)) return(-1);
1307   if (i == 0) return(-1);
1308   if (compar != NULL)
1309     qsort((void *)(*namelist), (size_t)i, sizeof(struct dirent *), compar);
1310
1311   return(i);
1312 }
1313
1314 #endif /* HAVE_LIBUTIL */