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 static gchar*
 595 get_real_path(const gchar *file_name)
 596 {
 597         if (file_name)
 598         {
 599                 gchar path[PATH_MAX+1];
 600                 memset(path, '\0', PATH_MAX+1);
 601                 realpath(file_name, path);
 602                 return g_strdup(path);
 603         }
 604         else
 605                 return NULL;
 606 }
 607
 608 /* Dedup a list of paths - duplicates are removed from the tail.
 609 ** Useful for deduping Recent Files and Recent Projects */
 610 GList*
 611 anjuta_util_glist_path_dedup(GList *list)
 612 {
 613         GList *nlist = NULL, *tmp, *tmp1;
 614         gchar *path;
 615         struct stat s;
 616         for (tmp = list; tmp; tmp = g_list_next(tmp))
 617         {
 618                 path = get_real_path((const gchar *) tmp->data);
 619                 if (0 != stat(path, &s))
 620                 {
 621                         g_free(path);
 622                 }
 623                 else
 624                 {
 625                         for (tmp1 = nlist; tmp1; tmp1 = g_list_next(tmp1))
 626                         {
 627                                 if (0 == strcmp((const char *) tmp1->data, path))
 628                                 {
 629                                         g_free(path);
 630                                         path = NULL;
 631                                         break;
 632                                 }
 633                         }
 634                         if (path)
 635                         nlist = g_list_prepend(nlist, path);
 636                 }
 637         }
 638         anjuta_util_glist_strings_free(list);
 639         nlist = g_list_reverse(nlist);
 640         return nlist;
 641 }
 642
 643 static gint
 644 sort_node (gchar* a, gchar *b)
 645 {
 646         if ( !a && !b) return 0;
 647         else if (!a) return -1;
 648         else if (!b) return 1;
 649         return strcmp (a, b);
 650 }
 651
 652 /* Sort the list alphabatically */
 653 GList*
 654 anjuta_util_glist_strings_sort (GList * list)
 655 {
 656         return g_list_sort(list, (GCompareFunc)sort_node);
 657 }
 658
 659 /* Free the strings and GList */
 660 void
 661 anjuta_util_glist_strings_free (GList * list)
 662 {
 663         GList *node;
 664         node = list;
 665         while (node)
 666         {
 667                 if (node->data)
 668                         g_free (node->data);
 669                 node = g_list_next (node);
 670         }
 671         g_list_free (list);
 672 }
 673
 674 int
 675 anjuta_util_type_from_string (AnjutaUtilStringMap *map, const char *str)
 676 {
 677         int i = 0;
 678
 679         while (-1 != map[i].type)
 680         {
 681                 if (0 == strcmp(map[i].name, str))
 682                         return map[i].type;
 683                 ++ i;
 684         }
 685         return -1;
 686 }
 687
 688 const char*
 689 anjuta_util_string_from_type (AnjutaUtilStringMap *map, int type)
 690 {
 691         int i = 0;
 692         while (-1 != map[i].type)
 693         {
 694                 if (map[i].type == type)
 695                         return map[i].name;
 696                 ++ i;
 697         }
 698         return "";
 699 }
 700
 701 GList*
 702 anjuta_util_glist_from_map (AnjutaUtilStringMap *map)
 703 {
 704         GList *out_list = NULL;
 705         int i = 0;
 706         while (-1 != map[i].type)
 707         {
 708                 out_list = g_list_append(out_list, map[i].name);
 709                 ++ i;
 710         }
 711         return out_list;
 712 }
 713
 714
 715 GList *
 716 anjuta_util_update_string_list (GList *p_list, const gchar *p_str, gint length)
 717 {
 718         gint i;
 719         gchar *str;
 720         if (!p_str)
 721                 return p_list;
 722         for (i = 0; i < g_list_length (p_list); i++)
 723         {
 724                 str = (gchar *) g_list_nth_data (p_list, i);
 725                 if (!str)
 726                         continue;
 727                 if (strcmp (p_str, str) == 0)
 728                 {
 729                         p_list = g_list_remove (p_list, str);
 730                         p_list = g_list_prepend (p_list, str);
 731                         return p_list;
 732                 }
 733         }
 734         p_list = g_list_prepend (p_list, g_strdup (p_str));
 735         while (g_list_length (p_list) > length)
 736         {
 737                 str = g_list_nth_data (p_list, g_list_length (p_list) - 1);
 738                 p_list = g_list_remove (p_list, str);
 739                 g_free (str);
 740         }
 741         return p_list;
 742 }
 743
 744 gboolean
 745 anjuta_util_create_dir (const gchar * d)
 746 {
 747         if (g_file_test (d, G_FILE_TEST_IS_DIR))
 748                 return TRUE;
 749         if (mkdir (d, 0755))
 750                 return FALSE;
 751         return TRUE;
 752 }
 753
 754 pid_t
 755 anjuta_util_execute_shell (const gchar *dir, const gchar *command)
 756 {
 757         pid_t pid;
 758         gchar *shell;
 759
 760         g_return_val_if_fail (command != NULL, -1);
 761
 762         shell = gnome_util_user_shell ();
 763         pid = fork();
 764         if (pid == 0)
 765         {
 766                 if(dir)
 767                 {
 768                         anjuta_util_create_dir (dir);
 769                         chdir (dir);
 770                 }
 771                 execlp (shell, shell, "-c", command, NULL);
 772                 g_warning (_("Cannot execute command: %s (using shell %s)\n"), command, shell);
 773                 _exit(1);
 774         }
 775         if (pid < 0)
 776                 g_warning (_("Cannot execute command %s (using shell %s)\n"), command, shell);
 777         g_free (shell);
 778         // Anjuta will take care of child exit automatically.
 779         return pid;
 780 }
 781
 782 gchar *
 783 anjuta_util_convert_to_utf8 (const gchar *str)
 784 {
 785         GError *error = NULL;
 786         gchar *utf8_msg_string = NULL;
 787
 788         g_return_val_if_fail (str != NULL, NULL);
 789         g_return_val_if_fail (strlen (str) > 0, NULL);
 790
 791         if (g_utf8_validate(str, -1, NULL))
 792         {
 793                 utf8_msg_string = g_strdup (str);
 794         }
 795         else
 796         {
 797                 gsize rbytes, wbytes;
 798                 utf8_msg_string = g_locale_to_utf8 (str, -1, &rbytes, &wbytes, &error);
 799                 if (error != NULL) {
 800                         g_warning ("g_locale_to_utf8 failed: %s\n", error->message);
 801                         g_error_free (error);
 802                         /* g_free (utf8_msg_string);
 803                         return NULL; */
 804                 }
 805         }
 806         return utf8_msg_string;
 807 }
 808
 809 GList*
 810 anjuta_util_parse_args_from_string (const gchar* string)
 811 {
 812         gboolean escaped;
 813         gchar    quote = 0;
 814         gboolean is_quote = FALSE;
 815         gchar* buffer = g_new0(gchar, strlen(string) + 1);
 816         const gchar *s;
 817         gint     idx;
 818         GList* args = NULL;
 819
 820         idx = 0;
 821         escaped = FALSE;
 822         s = string;
 823
 824         while (*s) {
 825                 if (!isspace(*s))
 826                         break;
 827                 s++;
 828         }
 829
 830         while (*s) {
 831                 if (escaped) {
 832                         /* The current char was escaped */
 833                         buffer[idx++] = *s;
 834                         escaped = FALSE;
 835                 } else if (*s == '\\') {
 836                         /* Current char is an escape */
 837                         escaped = TRUE;
 838                 } else if (*s == quote) {
 839                         /* Current char ends a quotation */
 840                         is_quote = FALSE;
 841                         if (!isspace(*(s+1)) && (*(s+1) != '\0')) {
 842                                 /* If there is no space after the quotation or it is not
 843                                    the end of the string */
 844                                 g_warning ("Parse error while parsing program arguments");
 845                         }
 846                 } else if ((*s == '\"' || *s == '\'')) {
 847                         if (!is_quote) {
 848                                 /* Current char starts a quotation */
 849                                 quote = *s;
 850                                 is_quote = TRUE;
 851                         } else {
 852                                 /* Just a quote char inside quote */
 853                                 buffer[idx++] = *s;
 854                         }
 855                 } else if (is_quote){
 856                         /* Any other char inside quote */
 857                         buffer[idx++] = *s;
 858                 } else if (isspace(*s)) {
 859                         /* Any white space outside quote */
 860                         if (idx > 0) {
 861                                 buffer[idx++] = '\0';
 862                                 args = g_list_append (args, g_strdup (buffer));
 863                                 idx = 0;
 864                         }
 865                 } else {
 866                         buffer[idx++] = *s;
 867                 }
 868                 s++;
 869         }
 870         if (idx > 0) {
 871                 /* There are chars in the buffer. Flush as the last arg */
 872                 buffer[idx++] = '\0';
 873                 args = g_list_append (args, g_strdup (buffer));
 874                 idx = 0;
 875         }
 876         if (is_quote) {
 877                 g_warning ("Unclosed quotation encountered at the end of parsing");
 878         }
 879         return args;
 880 }
 881
 882 gchar*
 883 anjuta_util_escape_quotes(const gchar* str)
 884 {
 885         gchar *buffer;
 886         gint idx, max_size;
 887         const gchar *s = str;
 888
 889         g_return_val_if_fail(str, NULL);
 890         idx = 0;
 891
 892         /* We are assuming there will be less than 2048 chars to escape */
 893         max_size = strlen(str) + 2048;
 894         buffer = g_new (gchar, max_size);
 895         max_size -= 2;
 896
 897         while(*s) {
 898                 if (idx > max_size)
 899                         break;
 900                 if (*s == '\"' || *s == '\'' || *s == '\\')
 901                         buffer[idx++] = '\\';
 902                 buffer[idx++] = *s;
 903                 s++;
 904         }
 905         buffer[idx] = '\0';
 906         return buffer;
 907 }
 908
 909 /* Diff the text contained in uri with text. Return true if files
 910 differ, FALSE if they are identical.
 911 FIXME: Find a better algorithm, this seems ineffective */
 912
 913 gboolean anjuta_util_diff(const gchar* uri, const gchar* text)
 914 {
 915         GnomeVFSFileSize bytes_read;
 916         gchar* file_text;
 917         GnomeVFSFileInfo info;
 918         GnomeVFSHandle* handle = NULL;
 919
 920         gnome_vfs_get_file_info(uri, &info, GNOME_VFS_FILE_INFO_DEFAULT);
 921
 922         if (info.size == 0 && text == NULL)
 923                 return FALSE;
 924         else if (info.size == 0 || text == NULL)
 925                 return TRUE;
 926
 927         file_text = g_new0(gchar, info.size + 1);
 928
 929         if (gnome_vfs_open(&handle, uri, GNOME_VFS_OPEN_READ != GNOME_VFS_OK))
 930                 return TRUE;
 931
 932         if ((gnome_vfs_read(handle, file_text, info.size, &bytes_read) == GNOME_VFS_OK)
 933                 && (bytes_read == info.size))
 934         {
 935                 gnome_vfs_close(handle);
 936
 937                 if ((g_utf8_strlen(file_text, -1) == g_utf8_strlen(text, -1))
 938                         && strcmp(file_text, text) == 0)
 939                         return FALSE;
 940                 return TRUE;
 941         }
 942         else
 943         {
 944                 gnome_vfs_close(handle);
 945                 return TRUE;
 946         }
 947 }
 948
 949 gboolean
 950 anjuta_util_path_has_extension (const gchar *path, const gchar *ext)
 951 {
 952         if (strlen (path) <= strlen (ext))
 953                 return FALSE;
 954         if ((path[strlen (path) - strlen (ext) - 1] == '.') &&
 955                 (strcmp (&path[strlen (path) - strlen (ext)], ext) == 0))
 956                 return TRUE;
 957         return FALSE;
 958 }
 959
 960 gchar *
 961 anjuta_util_get_uri_mime_type (const gchar *uri)
 962 {
 963         GnomeVFSURI *vfs_uri;
 964         const gchar *path;
 965         gchar *mime_type;
 966
 967         g_return_val_if_fail (uri != NULL, NULL);
 968
 969         vfs_uri = gnome_vfs_uri_new (uri);
 970         if (vfs_uri)
 971                 path = gnome_vfs_uri_get_path (vfs_uri);
 972         else
 973                 path = NULL;
 974
 975         /* If Anjuta is not installed in system gnome prefix, the mime types
 976          * may not have been correctly registed. In that case, we use the
 977          * following mime detection
 978          */
 979         if (!path)
 980         {
 981                 mime_type = gnome_vfs_get_mime_type (uri);
 982         }
 983         else if (anjuta_util_path_has_extension (path, "anjuta"))
 984         {
 985                 mime_type = g_strdup ("application/x-anjuta");
 986         }
 987         else if (anjuta_util_path_has_extension (path, "prj"))
 988         {
 989                 mime_type = g_strdup ("application/x-anjuta-old");
 990         }
 991         else if (anjuta_util_path_has_extension (path, "ui"))
 992         {
 993                 mime_type = g_strdup ("text/xml");
 994         }
 995         else if (anjuta_util_path_has_extension (path, "glade"))
 996         {
 997                 mime_type = g_strdup ("application/x-glade");
 998         }
 999         else
1000         {
1001                 mime_type = gnome_vfs_get_mime_type (uri);
1002         }
1003
1004         if (vfs_uri)
1005                 gnome_vfs_uri_unref (vfs_uri);
1006         return mime_type;
1007 }
1008
1009 #ifndef HAVE_LIBUTIL
1010 #include <grp.h>
1011
1012 static int ptym_open (char *pts_name);
1013 static int ptys_open (int fdm, char * pts_name);
1014
1015 int
1016 login_tty(int ttyfd)
1017 {
1018   int fd;
1019   char *fdname;
1020
1021 #ifdef HAVE_SETSID
1022   setsid();
1023 #endif
1024 #ifdef HAVE_SETPGID
1025   setpgid(0, 0);
1026 #endif
1027
1028   /* First disconnect from the old controlling tty. */
1029 #ifdef TIOCNOTTY
1030   fd = open("/dev/tty", O_RDWR|O_NOCTTY);
1031   if (fd >= 0)
1032     {
1033       ioctl(fd, TIOCNOTTY, NULL);
1034       close(fd);
1035     }
1036   else
1037     //syslog(LOG_WARNING, "NO CTTY");
1038 #endif /* TIOCNOTTY */
1039
1040   /* Verify that we are successfully disconnected from the controlling tty. */
1041   fd = open("/dev/tty", O_RDWR|O_NOCTTY);
1042   if (fd >= 0)
1043     {
1044       //syslog(LOG_WARNING, "Failed to disconnect from controlling tty.");
1045       close(fd);
1046     }
1047
1048   /* Make it our controlling tty. */
1049 #ifdef TIOCSCTTY
1050   ioctl(ttyfd, TIOCSCTTY, NULL);
1051 #endif /* TIOCSCTTY */
1052
1053   fdname = ttyname (ttyfd);
1054   fd = open(fdname, O_RDWR);
1055   if (fd < 0)
1056     ;//syslog(LOG_WARNING, "open %s: %s", fdname, strerror(errno));
1057   else
1058     close(fd);
1059
1060   /* Verify that we now have a controlling tty. */
1061   fd = open("/dev/tty", O_WRONLY);
1062   if (fd < 0)
1063     {
1064       //syslog(LOG_WARNING, "open /dev/tty: %s", strerror(errno));
1065       return 1;
1066     }
1067
1068   close(fd);
1069 #if defined(HAVE_VHANGUP) && !defined(HAVE_REVOKE)
1070   {
1071     RETSIGTYPE (*sig)();
1072     sig = signal(SIGHUP, SIG_IGN);
1073     vhangup();
1074     signal(SIGHUP, sig);
1075   }
1076 #endif
1077   fd = open(fdname, O_RDWR);
1078   if (fd == -1)
1079     {
1080       //syslog(LOG_ERR, "can't reopen ctty %s: %s", fdname, strerror(errno));
1081       return -1;
1082     }
1083
1084   close(ttyfd);
1085
1086   if (fd != 0)
1087     close(0);
1088   if (fd != 1)
1089     close(1);
1090   if (fd != 2)
1091     close(2);
1092
1093   dup2(fd, 0);
1094   dup2(fd, 1);
1095   dup2(fd, 2);
1096   if (fd > 2)
1097     close(fd);
1098   return 0;
1099 }
1100
1101 int
1102 openpty(int *amaster, int *aslave, char *name, struct termios *termp,
1103                 struct winsize *winp)
1104 {
1105         char line[20];
1106         *amaster = ptym_open(line);
1107         if (*amaster < 0)
1108                 return -1;
1109         *aslave = ptys_open(*amaster, line);
1110         if (*aslave < 0) {
1111                 close(*amaster);
1112                 return -1;
1113         }
1114         if (name)
1115                 strcpy(name, line);
1116 #ifndef TCSAFLUSH
1117 #define TCSAFLUSH TCSETAF
1118 #endif
1119         if (termp)
1120                 (void) tcsetattr(*aslave, TCSAFLUSH, termp);
1121 #ifdef TIOCSWINSZ
1122         if (winp)
1123                 (void) ioctl(*aslave, TIOCSWINSZ, (char *)winp);
1124 #endif
1125         return 0;
1126 }
1127
1128 static int
1129 ptym_open(char * pts_name)
1130 {
1131         int fdm;
1132 #ifdef HAVE_PTSNAME
1133         char *ptr;
1134
1135         strcpy(pts_name, "/dev/ptmx");
1136         fdm = open(pts_name, O_RDWR);
1137         if (fdm < 0)
1138                 return -1;
1139         if (grantpt(fdm) < 0) { /* grant access to slave */
1140                 close(fdm);
1141                 return -2;
1142         }
1143         if (unlockpt(fdm) < 0) { /* clear slave's lock flag */
1144                 close(fdm);
1145                 return -3;
1146         }
1147         ptr = ptsname(fdm);
1148         if (ptr == NULL) { /* get slave's name */
1149                 close (fdm);
1150                 return -4;
1151         }
1152         strcpy(pts_name, ptr); /* return name of slave */
1153         return fdm;            /* return fd of master */
1154 #else
1155         char *ptr1, *ptr2;
1156
1157         strcpy(pts_name, "/dev/ptyXY");
1158         /* array index: 012345689 (for references in following code) */
1159         for (ptr1 = "pqrstuvwxyzPQRST"; *ptr1 != 0; ptr1++) {
1160                 pts_name[8] = *ptr1;
1161                 for (ptr2 = "0123456789abcdef"; *ptr2 != 0; ptr2++) {
1162                         pts_name[9] = *ptr2;
1163                         /* try to open master */
1164                         fdm = open(pts_name, O_RDWR);
1165                         if (fdm < 0) {
1166                                 if (errno == ENOENT) /* different from EIO */
1167                                         return -1;  /* out of pty devices */
1168                                 else
1169                                         continue;  /* try next pty device */
1170                         }
1171                         pts_name[5] = 't'; /* chage "pty" to "tty" */
1172                         return fdm;   /* got it, return fd of master */
1173                 }
1174         }
1175         return -1; /* out of pty devices */
1176 #endif
1177 }
1178
1179 static int
1180 ptys_open(int fdm, char * pts_name)
1181 {
1182         int fds;
1183 #ifdef HAVE_PTSNAME
1184         /* following should allocate controlling terminal */
1185         fds = open(pts_name, O_RDWR);
1186         if (fds < 0) {
1187                 close(fdm);
1188                 return -5;
1189         }
1190         if (ioctl(fds, I_PUSH, "ptem") < 0) {
1191                 close(fdm);
1192                 close(fds);
1193                 return -6;
1194         }
1195         if (ioctl(fds, I_PUSH, "ldterm") < 0) {
1196                 close(fdm);
1197                 close(fds);
1198                 return -7;
1199         }
1200         if (ioctl(fds, I_PUSH, "ttcompat") < 0) {
1201                 close(fdm);
1202                 close(fds);
1203                 return -8;
1204         }
1205
1206         if (ioctl(fdm, I_PUSH, "pckt") < 0) {
1207                 close(fdm);
1208                 close(fds);
1209                 return -8;
1210         }
1211
1212         if (ioctl(fdm, I_SRDOPT, RMSGN|RPROTDAT) < 0) {
1213                 close(fdm);
1214                 close(fds);
1215                 return -8;
1216         }
1217
1218         return fds;
1219 #else
1220         int gid;
1221         struct group *grptr;
1222
1223         grptr = getgrnam("tty");
1224         if (grptr != NULL)
1225                 gid = grptr->gr_gid;
1226         else
1227                 gid = -1;  /* group tty is not in the group file */
1228         /* following two functions don't work unless we're root */
1229         chown(pts_name, getuid(), gid);
1230         chmod(pts_name, S_IRUSR | S_IWUSR | S_IWGRP);
1231         fds = open(pts_name, O_RDWR);
1232         if (fds < 0) {
1233                 close(fdm);
1234                 return -1;
1235         }
1236         return fds;
1237 #endif
1238 }
1239
1240 int
1241 forkpty(int *amaster, char *name, struct termios *termp, struct winsize *winp)
1242 {
1243   int master, slave, pid;
1244
1245   if (openpty(&master, &slave, name, termp, winp) == -1)
1246     return (-1);
1247   switch (pid = fork()) {
1248   case -1:
1249     return (-1);
1250   case 0:
1251     /*
1252      * child
1253      */
1254     close(master);
1255     login_tty(slave);
1256     return (0);
1257   }
1258   /*
1259    * parent
1260    */
1261   *amaster = master;
1262   close(slave);
1263   return (pid);
1264 }
1265
1266 int scandir(const char *dir, struct dirent ***namelist,
1267             int (*select)(const struct dirent *),
1268             int (*compar)(const struct dirent **, const struct dirent **))
1269 {
1270   DIR *d;
1271   struct dirent *entry;
1272   register int i=0;
1273   size_t entrysize;
1274
1275   if ((d=opendir(dir)) == NULL)
1276      return(-1);
1277
1278   *namelist=NULL;
1279   while ((entry=readdir(d)) != NULL)
1280   {
1281     if (select == NULL || (select != NULL && (*select)(entry)))
1282     {
1283       *namelist=(struct dirent **)realloc((void *)(*namelist),
1284                  (size_t)((i+1)*sizeof(struct dirent *)));
1285         if (*namelist == NULL) return(-1);
1286         entrysize=sizeof(struct dirent)-sizeof(entry->d_name)+strlen(entry->d_name)+1;
1287         (*namelist)[i]=(struct dirent *)malloc(entrysize);
1288         if ((*namelist)[i] == NULL) return(-1);
1289         memcpy((*namelist)[i], entry, entrysize);
1290         i++;
1291     }
1292   }
1293   if (closedir(d)) return(-1);
1294   if (i == 0) return(-1);
1295   if (compar != NULL)
1296     qsort((void *)(*namelist), (size_t)i, sizeof(struct dirent *), compar);
1297
1298   return(i);
1299 }
1300
1301 #endif /* HAVE_LIBUTIL */