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 <sys/wait.h>
  44 #include <dirent.h>
  45 #include <unistd.h>
  46 #include <stdio.h>
  47 #include <string.h>
  48 #ifndef G_OS_WIN32
  49 #include <pwd.h>
  50 #endif
  51
  52 #include <gio/gio.h>
  53 #include <glib/gi18n.h>
  54 #include <glib.h>
  55 #include <glib/gstdio.h>
  56 #include <gtk/gtk.h>
  57
  58 #include <libanjuta/anjuta-utils.h>
  59 #include <libanjuta/anjuta-debug.h>
  60
  61 #define FILE_BUFFER_SIZE 1024
  62
  63 static void
  64 anjuta_util_from_file_to_file (GInputStream *istream,
  65                                                            GOutputStream *ostream)
  66 {
  67         gsize bytes = 1;
  68         GError *error = NULL;
  69         gchar buffer[FILE_BUFFER_SIZE];
  70
  71         while (bytes != 0 && bytes != -1)
  72         {
  73                 bytes = g_input_stream_read (istream, buffer,
  74                                              sizeof (buffer),
  75                                              NULL, &error);
  76                 if (error)
  77                         break;
  78
  79                 g_output_stream_write (ostream, buffer,
  80                                        bytes,
  81                                        NULL, &error);
  82                 if (error)
  83                         break;
  84         }
  85
  86         if (error)
  87         {
  88                 g_warning ("%s", error->message);
  89                 g_error_free (error);
  90                 error = NULL;
  91         }
  92
  93         if (!g_output_stream_close (ostream, NULL, &error))
  94         {
  95                 g_warning ("%s", error->message);
  96                 g_error_free (error);
  97                 error = NULL;
  98         }
  99         if (!g_input_stream_close (istream, NULL, &error))
 100         {
 101                 g_warning ("%s", error->message);
 102                 g_error_free (error);
 103         }
 104 }
 105
 106 /**
 107  * anjuta_util_copy_file:
 108  * @src: the file where copy
 109  * @dest: the path to copy the @src
 110  * @show_error: TRUE to show a dialog error
 111  *
 112  * Copies @src to @dest and shows a dialog error in case is needed.
 113  *
 114  * Returns: TRUE if there was an error copying the file.
 115  */
 116 gboolean
 117 anjuta_util_copy_file (const gchar * src, const gchar * dest, gboolean show_error)
 118 {
 119         GFile *src_file, *dest_file;
 120         GFileInputStream *istream;
 121         GFileOutputStream *ostream;
 122         GError *error = NULL;
 123         gboolean toret = FALSE;
 124
 125         src_file = g_file_new_for_path (src);
 126         dest_file = g_file_new_for_path (dest);
 127
 128         istream = g_file_read (src_file, NULL, &error);
 129         if (error)
 130                 goto free;
 131
 132         ostream = g_file_create (dest_file, G_FILE_CREATE_NONE,
 133                                                          NULL, &error);
 134         if (error)
 135                 goto free;
 136
 137         anjuta_util_from_file_to_file (G_INPUT_STREAM (istream), G_OUTPUT_STREAM (ostream));
 138
 139 free: if (error)
 140         {
 141                 if (show_error)
 142                         anjuta_util_dialog_error_system (NULL, error->code,
 143                                                                                          error->message);
 144
 145                 g_warning ("%s", error->message);
 146
 147                 toret = TRUE;
 148         }
 149
 150         g_object_unref (src_file);
 151         g_object_unref (dest_file);
 152
 153         return toret;
 154 }
 155
 156 void
 157 anjuta_util_color_from_string (const gchar * val, guint16 * r, guint16 * g, guint16 * b)
 158 {
 159         GdkColor color;
 160         if (gdk_color_parse(val, &color))
 161         {
 162                 *r = color.red;
 163                 *g = color.green;
 164                 *b =color.blue;
 165         }
 166 }
 167
 168 gchar *
 169 anjuta_util_string_from_color (guint16 r, guint16 g, guint16 b)
 170 {
 171         return g_strdup_printf("#%02x%02x%02x", r >> 8, g >> 8, b >> 8);
 172 }
 173
 174 GtkWidget*
 175 anjuta_util_button_new_with_stock_image (const gchar* text,
 176                                                                                  const gchar* stock_id)
 177 {
 178         GtkWidget *button;
 179         GtkWidget *child;
 180         GtkStockItem item;
 181         GtkWidget *label;
 182         GtkWidget *image;
 183         GtkWidget *hbox;
 184         GtkWidget *align;
 185
 186         button = gtk_button_new ();
 187
 188         child = gtk_bin_get_child (GTK_BIN (button));
 189         if (child)
 190                 gtk_container_remove (GTK_CONTAINER (button), child);
 191
 192         if (gtk_stock_lookup (stock_id, &item))
 193         {
 194                 label = gtk_label_new_with_mnemonic (text);
 195
 196                 gtk_label_set_mnemonic_widget (GTK_LABEL (label), GTK_WIDGET (button));
 197
 198                 image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_BUTTON);
 199                 hbox = gtk_hbox_new (FALSE, 2);
 200
 201                 align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
 202
 203                 gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
 204                 gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 205
 206                 gtk_container_add (GTK_CONTAINER (button), align);
 207                 gtk_container_add (GTK_CONTAINER (align), hbox);
 208                 gtk_widget_show_all (align);
 209
 210                 return button;
 211         }
 212
 213         label = gtk_label_new_with_mnemonic (text);
 214         gtk_label_set_mnemonic_widget (GTK_LABEL (label), GTK_WIDGET (button));
 215
 216         gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
 217
 218         gtk_widget_show (label);
 219         gtk_container_add (GTK_CONTAINER (button), label);
 220
 221         return button;
 222 }
 223
 224 GtkWidget*
 225 anjuta_util_dialog_add_button (GtkDialog *dialog, const gchar* text,
 226                                                            const gchar* stock_id, gint response_id)
 227 {
 228         GtkWidget *button;
 229
 230         g_return_val_if_fail (GTK_IS_DIALOG (dialog), NULL);
 231         g_return_val_if_fail (text != NULL, NULL);
 232         g_return_val_if_fail (stock_id != NULL, NULL);
 233
 234         button = anjuta_util_button_new_with_stock_image (text, stock_id);
 235         g_return_val_if_fail (button != NULL, NULL);
 236
 237         gtk_widget_set_can_default (button, TRUE);
 238
 239         gtk_widget_show (button);
 240
 241         gtk_dialog_add_action_widget (dialog, button, response_id);
 242
 243         return button;
 244 }
 245
 246 void
 247 anjuta_util_dialog_error (GtkWindow *parent, const gchar *mesg, ...)
 248 {
 249         gchar* message;
 250         va_list args;
 251         GtkWidget *dialog;
 252         GtkWindow *real_parent;
 253
 254         va_start (args, mesg);
 255         message = g_strdup_vprintf (mesg, args);
 256         va_end (args);
 257
 258         if (parent && GTK_IS_WINDOW (parent))
 259         {
 260                 real_parent = parent;
 261         }
 262         else
 263         {
 264                 real_parent = NULL;
 265         }
 266
 267         // Dialog to be HIG compliant
 268         dialog = gtk_message_dialog_new (real_parent,
 269                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 270                                                                          GTK_MESSAGE_ERROR,
 271                                                                          GTK_BUTTONS_CLOSE, "%s", message);
 272         g_signal_connect (G_OBJECT (dialog), "response",
 273                                           G_CALLBACK (gtk_widget_destroy), NULL);
 274         gtk_widget_show (dialog);
 275         g_free (message);
 276 }
 277
 278 void
 279 anjuta_util_dialog_warning (GtkWindow *parent, const gchar * mesg, ...)
 280 {
 281         gchar* message;
 282         va_list args;
 283         GtkWidget *dialog;
 284         GtkWindow *real_parent;
 285
 286         va_start (args, mesg);
 287         message = g_strdup_vprintf (mesg, args);
 288         va_end (args);
 289
 290         if (parent && GTK_IS_WINDOW (parent))
 291         {
 292                 real_parent = parent;
 293         }
 294         else
 295         {
 296                 real_parent = NULL;
 297         }
 298
 299         // Dialog to be HIG compliant
 300         dialog = gtk_message_dialog_new (real_parent,
 301                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 302                                                                          GTK_MESSAGE_WARNING,
 303                                                                          GTK_BUTTONS_CLOSE, "%s", message);
 304         g_signal_connect (G_OBJECT (dialog), "response",
 305                                           G_CALLBACK (gtk_widget_destroy), NULL);
 306         gtk_widget_show (dialog);
 307         g_free (message);
 308 }
 309
 310 void
 311 anjuta_util_dialog_info (GtkWindow *parent, const gchar * mesg, ...)
 312 {
 313         gchar* message;
 314         va_list args;
 315         GtkWidget *dialog;
 316         GtkWindow *real_parent;
 317
 318         va_start (args, mesg);
 319         message = g_strdup_vprintf (mesg, args);
 320         va_end (args);
 321
 322         if (parent && GTK_IS_WINDOW (parent))
 323         {
 324                 real_parent = parent;
 325         }
 326         else
 327         {
 328                 real_parent = NULL;
 329         }
 330         // Dialog to be HIG compliant
 331         dialog = gtk_message_dialog_new (real_parent,
 332                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 333                                                                          GTK_MESSAGE_INFO,
 334                                                                          GTK_BUTTONS_CLOSE, "%s", message);
 335         g_signal_connect (G_OBJECT (dialog), "response",
 336                                           G_CALLBACK (gtk_widget_destroy), NULL);
 337         gtk_widget_show (dialog);
 338         g_free (message);
 339 }
 340
 341 void
 342 anjuta_util_dialog_error_system (GtkWindow* parent, gint errnum,
 343                                                                  const gchar * mesg, ... )
 344 {
 345         gchar* message;
 346         gchar* tot_mesg;
 347         va_list args;
 348         GtkWidget *dialog;
 349         GtkWindow *real_parent;
 350
 351         va_start (args, mesg);
 352         message = g_strdup_vprintf (mesg, args);
 353         va_end (args);
 354
 355         if (0 != errnum) {
 356                 /* Avoid space in translated string */
 357                 tot_mesg = g_strconcat (message, "\n", _("System:"), " ",
 358                                                                 g_strerror(errnum), NULL);
 359                 g_free (message);
 360         } else
 361                 tot_mesg = message;
 362
 363         if (parent && GTK_IS_WINDOW (parent))
 364         {
 365                 real_parent = parent;
 366         }
 367         else
 368         {
 369                 real_parent = NULL;
 370         }
 371         // Dialog to be HIG compliant
 372         dialog = gtk_message_dialog_new (real_parent,
 373                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 374                                                                          GTK_MESSAGE_ERROR,
 375                                                                          GTK_BUTTONS_CLOSE, "%s", tot_mesg);
 376         g_signal_connect (G_OBJECT (dialog), "response",
 377                                           G_CALLBACK (gtk_widget_destroy), NULL);
 378         gtk_widget_show (dialog);
 379         g_free (tot_mesg);
 380 }
 381
 382 gboolean
 383 anjuta_util_dialog_boolean_question (GtkWindow *parent, const gchar *mesg, ...)
 384 {
 385         gchar* message;
 386         va_list args;
 387         GtkWidget *dialog;
 388         gint ret;
 389         GtkWindow *real_parent;
 390
 391         va_start (args, mesg);
 392         message = g_strdup_vprintf (mesg, args);
 393         va_end (args);
 394
 395         if (parent && GTK_IS_WINDOW (parent))
 396         {
 397                 real_parent = parent;
 398         }
 399         else
 400         {
 401                 real_parent = NULL;
 402         }
 403
 404         dialog = gtk_message_dialog_new (real_parent,
 405                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 406                                                                          GTK_MESSAGE_QUESTION,
 407                                                                          GTK_BUTTONS_YES_NO, "%s", message);
 408
 409         ret = gtk_dialog_run (GTK_DIALOG (dialog));
 410         gtk_widget_destroy (dialog);
 411         g_free (message);
 412
 413         return (ret == GTK_RESPONSE_YES);
 414 }
 415
 416 gboolean
 417 anjuta_util_dialog_input (GtkWindow *parent, const gchar *prompt,
 418                                                   const gchar *default_value, gchar **return_value)
 419 {
 420         GtkWidget *dialog, *label, *frame, *entry, *dialog_vbox, *vbox;
 421         gint res;
 422         gchar *markup;
 423         GtkWindow *real_parent;
 424
 425         if (parent && GTK_IS_WINDOW (parent))
 426         {
 427                 real_parent = parent;
 428         }
 429         else
 430         {
 431                 real_parent = NULL;
 432         }
 433
 434         dialog = gtk_dialog_new_with_buttons (prompt, real_parent,
 435                                                                                   GTK_DIALOG_DESTROY_WITH_PARENT,
 436                                                                                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 437                                                                                   GTK_STOCK_OK, GTK_RESPONSE_OK,
 438                                                                                   NULL);
 439         gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 440         dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
 441         gtk_window_set_default_size (GTK_WINDOW (dialog), 400, -1);
 442         gtk_widget_show (dialog_vbox);
 443
 444         markup = g_strconcat ("<b>", prompt, "</b>", NULL);
 445         label = gtk_label_new (NULL);
 446         gtk_label_set_markup (GTK_LABEL (label), markup);
 447         gtk_widget_show (label);
 448         g_free (markup);
 449
 450         frame = gtk_frame_new (NULL);
 451         gtk_frame_set_label_widget (GTK_FRAME (frame), label);
 452         gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
 453         gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
 454         gtk_widget_show (frame);
 455         gtk_box_pack_start (GTK_BOX (dialog_vbox), frame, FALSE, FALSE, 0);
 456
 457         vbox = gtk_vbox_new (FALSE, 0);
 458         gtk_widget_show (vbox);
 459         gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
 460         gtk_container_add (GTK_CONTAINER (frame), vbox);
 461
 462         entry = gtk_entry_new ();
 463         gtk_widget_show (entry);
 464         gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
 465         gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
 466         if (default_value)
 467                 gtk_entry_set_text (GTK_ENTRY (entry), default_value);
 468
 469         res = gtk_dialog_run (GTK_DIALOG (dialog));
 470
 471         if (gtk_entry_get_text (GTK_ENTRY (entry)) &&
 472                 strlen (gtk_entry_get_text (GTK_ENTRY (entry))) > 0)
 473         {
 474                 *return_value = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
 475         }
 476         else
 477         {
 478                 *return_value = NULL;
 479         }
 480         gtk_widget_destroy (dialog);
 481         return (res == GTK_RESPONSE_OK);
 482 }
 483
 484 static void
 485 on_install_files_done (GObject *proxy, GAsyncResult *result,
 486                                            gpointer user_data)
 487 {
 488         GError *error = NULL;
 489         g_dbus_proxy_call_finish ((GDBusProxy *) proxy, result, &error);
 490         if (error)
 491         {
 492                 /*
 493                   Only dbus error is handled. Rest of the errors are from packagekit
 494                   which have already been notified to user by packagekit.
 495                 */
 496                 if (error->domain == G_DBUS_ERROR)
 497                 {
 498                         const gchar *error_message = NULL;
 499
 500                         /* Service error which implies packagekit is missing */
 501                         if (error->code == G_DBUS_ERROR_SERVICE_UNKNOWN)
 502                         {
 503                                 error_message = _("You do not seem to have PackageKit installed. PackageKit is required for installing missing packages. Please install \"packagekit-gnome\" package from your distribution, or install the missing packages manually.");
 504                         }
 505                         /* General dbus error implies failure to call dbus method */
 506                         else if (error->code != G_DBUS_ERROR_NO_REPLY)
 507                         {
 508                                 error_message = error->message;
 509                         }
 510                         if (error_message)
 511                                 anjuta_util_dialog_error (NULL,
 512                                                                                   _("Installation failed: %s"),
 513                                                                                   error_message);
 514                 }
 515                 g_error_free (error);
 516         }
 517 }
 518
 519 gboolean
 520 anjuta_util_install_files (const gchar * const names)
 521 {
 522         GDBusConnection * connection;
 523         GDBusProxy * proxy;
 524         guint32 xid = 0;
 525         gchar ** pkgv;
 526
 527         if (!names)
 528                 return FALSE;
 529
 530         connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
 531         if (!connection)
 532                 return FALSE;
 533
 534         proxy = g_dbus_proxy_new_sync (connection,
 535                                                                    G_DBUS_PROXY_FLAGS_NONE,
 536                                                                    NULL,
 537                                                                    "org.freedesktop.PackageKit",
 538                                                                    "/org/freedesktop/PackageKit",
 539                                                                    "org.freedesktop.PackageKit.Modify",
 540                                                                    NULL,
 541                                                                    NULL);
 542         if (!proxy)
 543                 return FALSE;
 544
 545         pkgv = g_strsplit (names, ", ", 0);
 546         g_dbus_proxy_call (proxy, "InstallProvideFiles",
 547                                            g_variant_new ("(u^ass)",
 548                                                                           xid,
 549                                                                           pkgv,
 550                                                                           ""),
 551                                            G_DBUS_CALL_FLAGS_NONE,
 552                                            -1,
 553                                            NULL,
 554                                            on_install_files_done,
 555                                            NULL);
 556         g_strfreev (pkgv);
 557         return TRUE;
 558 }
 559
 560 gboolean
 561 anjuta_util_package_is_installed (const gchar * package, gboolean show)
 562 {
 563         gboolean installed = FALSE;
 564         int status;
 565         int exit_status;
 566         pid_t pid;
 567
 568         if ((pid = fork()) == 0)
 569                 execlp ("pkg-config", "pkg-config", "--exists", package, NULL);
 570
 571         waitpid (pid, &status, 0);
 572         exit_status = WEXITSTATUS (status);
 573         installed = (exit_status == 0) ? TRUE : FALSE;
 574         if (installed)
 575                 return TRUE;
 576
 577         if (show)
 578         {
 579                 anjuta_util_dialog_error (NULL,
 580                                                                   _("The \"%s\" package is not installed.\n"
 581                                                                         "Please install it."), package);
 582         }
 583
 584         return FALSE;
 585 }
 586
 587 gboolean
 588 anjuta_util_prog_is_installed (const gchar * prog, gboolean show)
 589 {
 590         gchar* prog_path = g_find_program_in_path (prog);
 591         if (prog_path)
 592         {
 593                 g_free (prog_path);
 594                 return TRUE;
 595         }
 596         if (show)
 597         {
 598                 anjuta_util_dialog_error (NULL, _("The \"%s\" utility is not installed.\n"
 599                                           "Please install it."), prog);
 600         }
 601         return FALSE;
 602 }
 603
 604 gchar *
 605 anjuta_util_get_a_tmp_file (void)
 606 {
 607         static gint count = 0;
 608         gchar *filename;
 609         const gchar *tmpdir;
 610
 611         tmpdir = g_get_tmp_dir ();
 612         filename =
 613                 g_strdup_printf ("%s/anjuta_%d.%d", tmpdir, count++, getpid ());
 614         return filename;
 615 }
 616
 617 /* GList of strings operations */
 618 GList *
 619 anjuta_util_glist_from_string (const gchar *string)
 620 {
 621         gchar *str, *temp, buff[256];
 622         GList *list;
 623         gchar *word_start, *word_end;
 624         gboolean the_end;
 625
 626         list = NULL;
 627         the_end = FALSE;
 628         temp = g_strdup (string);
 629         str = temp;
 630         if (!str)
 631                 return NULL;
 632
 633         while (1)
 634         {
 635                 gint i;
 636                 gchar *ptr;
 637
 638                 /* Remove leading spaces */
 639                 while (isspace (*str) && *str != '\0')
 640                         str++;
 641                 if (*str == '\0')
 642                         break;
 643
 644                 /* Find start and end of word */
 645                 word_start = str;
 646                 while (!isspace (*str) && *str != '\0')
 647                         str++;
 648                 word_end = str;
 649
 650                 /* Copy the word into the buffer */
 651                 for (ptr = word_start, i = 0; ptr < word_end; ptr++, i++)
 652                         buff[i] = *ptr;
 653                 buff[i] = '\0';
 654                 if (strlen (buff))
 655                         list = g_list_append (list, g_strdup (buff));
 656                 if (*str == '\0')
 657                         break;
 658         }
 659         if (temp)
 660                 g_free (temp);
 661         return list;
 662 }
 663
 664 /* Prefix the strings */
 665 void
 666 anjuta_util_glist_strings_prefix (GList * list, const gchar *prefix)
 667 {
 668         GList *node;
 669         node = list;
 670
 671         g_return_if_fail (prefix != NULL);
 672         while (node)
 673         {
 674                 gchar* tmp;
 675                 tmp = node->data;
 676                 node->data = g_strconcat (prefix, tmp, NULL);
 677                 if (tmp) g_free (tmp);
 678                 node = g_list_next (node);
 679         }
 680 }
 681
 682 /* Suffix the strings */
 683 void
 684 anjuta_util_glist_strings_sufix (GList * list, const gchar *sufix)
 685 {
 686         GList *node;
 687         node = list;
 688
 689         g_return_if_fail (sufix != NULL);
 690         while (node)
 691         {
 692                 gchar* tmp;
 693                 tmp = node->data;
 694                 node->data = g_strconcat (tmp, sufix, NULL);
 695                 if (tmp) g_free (tmp);
 696                 node = g_list_next (node);
 697         }
 698 }
 699
 700 /* Duplicate list of strings */
 701 GList*
 702 anjuta_util_glist_strings_dup (GList * list)
 703 {
 704         GList *node;
 705         GList *new_list;
 706
 707         new_list = NULL;
 708         node = list;
 709         while (node)
 710         {
 711                 if (node->data)
 712                         new_list = g_list_append (new_list, g_strdup(node->data));
 713                 else
 714                         new_list = g_list_append (new_list, NULL);
 715                 node = g_list_next (node);
 716         }
 717         return new_list;
 718 }
 719
 720 /* Join list of strings using the given delimiter */
 721 gchar*
 722 anjuta_util_glist_strings_join (GList * list, gchar *delimiter)
 723 {
 724         GString *joined;
 725         gboolean first = TRUE;
 726         GList *node;
 727
 728         joined = g_string_new (NULL);
 729         node = list;
 730         while (node)
 731         {
 732                 if (node->data)
 733                 {
 734                         if (!first)
 735                                 g_string_append (joined, delimiter);
 736                         else
 737                                 first = FALSE;
 738                         g_string_append (joined, node->data);
 739                 }
 740                 node = g_list_next (node);
 741         }
 742         if (joined->len > 0)
 743                 return g_string_free (joined, FALSE);
 744         else
 745                 g_string_free (joined, TRUE);
 746         return NULL;
 747 }
 748
 749 gchar*
 750 anjuta_util_get_real_path (const gchar *path)
 751 {
 752         if (path != NULL)
 753         {
 754                 gchar *result;
 755 #ifdef PATH_MAX
 756                 gchar buf[PATH_MAX+1];
 757
 758                 result = realpath (path, buf);
 759                 if (result != NULL)
 760                 {
 761                         *(buf + PATH_MAX) = '\0'; /* ensure a terminator */
 762                         return g_strdup (buf);
 763                 }
 764 #else
 765                 char *buf;
 766                 /* the string returned by realpath should be cleaned with
 767                    free(), not g_free() */
 768                 buf = realpath (path, NULL);
 769                 if (buf != NULL)
 770                 {
 771                         result = g_strdup (buf);
 772                         free (buf);
 773                         return result;
 774                 }
 775 #endif
 776         }
 777         return NULL;
 778 }
 779
 780 /**
 781  * anjuta_util_get_current_dir:
 782  *
 783  * Get current working directory, unlike g_get_current_dir, keeps symbolic links
 784  * in path name.
 785  *
 786  * Returns: The current working directory.
 787  */
 788 gchar*
 789 anjuta_util_get_current_dir (void)
 790 {
 791         const gchar *pwd;
 792
 793         pwd = g_getenv ("PWD");
 794         if (pwd != NULL)
 795         {
 796                 return g_strdup (pwd);
 797         }
 798         else
 799         {
 800                 return g_get_current_dir ();
 801         }
 802 }
 803
 804 static gboolean
 805 is_valid_scheme_character (char c)
 806 {
 807         return g_ascii_isalnum (c) || c == '+' || c == '-' || c == '.';
 808 }
 809
 810 /* Following RFC 2396, valid schemes are built like:
 811  *       scheme        = alpha *( alpha | digit | "+" | "-" | "." )
 812  */
 813 static gboolean
 814 has_valid_scheme (const char *uri)
 815 {
 816         const char *p;
 817
 818         p = uri;
 819
 820         if (!g_ascii_isalpha (*p))
 821                 return FALSE;
 822
 823         do {
 824                 p++;
 825         } while (is_valid_scheme_character (*p));
 826
 827         return *p == ':';
 828 }
 829
 830 /**
 831  * anjuta_util_file_new_for_commandline_arg:
 832  *
 833  * @arg: URI or relative or absolute file path
 834  *
 835  * Create a new file corresponding to arg, unlike g_file_new_for_commandline_arg,
 836  * keeps symbolic links in path name.
 837  *
 838  * Returns: A new GFile object
 839  */
 840 GFile *
 841 anjuta_util_file_new_for_commandline_arg (const gchar *arg)
 842 {
 843         GFile *file;
 844         char *filename;
 845         char *current_dir;
 846
 847         g_return_val_if_fail (arg != NULL, NULL);
 848
 849         if (g_path_is_absolute (arg))
 850                 return g_file_new_for_path (arg);
 851
 852         if (has_valid_scheme (arg))
 853                 return g_file_new_for_uri (arg);
 854
 855         current_dir = anjuta_util_get_current_dir ();
 856         filename = g_build_filename (current_dir, arg, NULL);
 857         g_free (current_dir);
 858
 859         file = g_file_new_for_path (filename);
 860         g_free (filename);
 861
 862         return file;
 863 }
 864
 865
 866 /* Dedup a list of paths - duplicates are removed from the tail.
 867 ** Useful for deduping Recent Files and Recent Projects */
 868 GList*
 869 anjuta_util_glist_path_dedup(GList *list)
 870 {
 871         GList *nlist = NULL, *tmp, *tmp1;
 872         gchar *path;
 873         struct stat s;
 874         for (tmp = list; tmp; tmp = g_list_next(tmp))
 875         {
 876                 path = anjuta_util_get_real_path ((const gchar *) tmp->data);
 877                 if (path)
 878                 {
 879                         if (stat (path, &s) != 0)
 880                         {
 881                                 g_free(path);
 882                         }
 883                         else
 884                         {
 885                                 for (tmp1 = nlist; tmp1; tmp1 = g_list_next(tmp1))
 886                                 {
 887                                         if (0 == strcmp((const char *) tmp1->data, path))
 888                                         {
 889                                                 g_free(path);
 890                                                 path = NULL;
 891                                                 break;
 892                                         }
 893                                 }
 894                                 if (path)
 895                                 nlist = g_list_prepend(nlist, path);
 896                         }
 897                 }
 898         }
 899         anjuta_util_glist_strings_free(list);
 900         nlist = g_list_reverse(nlist);
 901         return nlist;
 902 }
 903
 904 static gint
 905 sort_node (gchar* a, gchar *b)
 906 {
 907         if ( !a && !b) return 0;
 908         else if (!a) return -1;
 909         else if (!b) return 1;
 910         return strcmp (a, b);
 911 }
 912
 913 /* Sort the list alphabatically */
 914 GList*
 915 anjuta_util_glist_strings_sort (GList * list)
 916 {
 917         return g_list_sort(list, (GCompareFunc)sort_node);
 918 }
 919
 920 /* Free the strings and GList */
 921 void
 922 anjuta_util_glist_strings_free (GList * list)
 923 {
 924         g_list_foreach (list, (GFunc) g_free, NULL);
 925         g_list_free (list);
 926 }
 927
 928 int
 929 anjuta_util_type_from_string (AnjutaUtilStringMap *map, const char *str)
 930 {
 931         int i = 0;
 932
 933         while (-1 != map[i].type)
 934         {
 935                 if (0 == strcmp(map[i].name, str))
 936                         return map[i].type;
 937                 ++ i;
 938         }
 939         return -1;
 940 }
 941
 942 const char*
 943 anjuta_util_string_from_type (AnjutaUtilStringMap *map, int type)
 944 {
 945         int i = 0;
 946         while (-1 != map[i].type)
 947         {
 948                 if (map[i].type == type)
 949                         return map[i].name;
 950                 ++ i;
 951         }
 952         return "";
 953 }
 954
 955 GList*
 956 anjuta_util_glist_from_map (AnjutaUtilStringMap *map)
 957 {
 958         GList *out_list = NULL;
 959         int i = 0;
 960         while (-1 != map[i].type)
 961         {
 962                 out_list = g_list_append(out_list, map[i].name);
 963                 ++ i;
 964         }
 965         return out_list;
 966 }
 967
 968
 969 GList *
 970 anjuta_util_update_string_list (GList *p_list, const gchar *p_str, gint length)
 971 {
 972         gint i;
 973         gchar *str;
 974         if (!p_str)
 975                 return p_list;
 976         for (i = 0; i < g_list_length (p_list); i++)
 977         {
 978                 str = (gchar *) g_list_nth_data (p_list, i);
 979                 if (!str)
 980                         continue;
 981                 if (strcmp (p_str, str) == 0)
 982                 {
 983                         p_list = g_list_remove (p_list, str);
 984                         p_list = g_list_prepend (p_list, str);
 985                         return p_list;
 986                 }
 987         }
 988         p_list = g_list_prepend (p_list, g_strdup (p_str));
 989         while (g_list_length (p_list) > length)
 990         {
 991                 str = g_list_nth_data (p_list, g_list_length (p_list) - 1);
 992                 p_list = g_list_remove (p_list, str);
 993                 g_free (str);
 994         }
 995         return p_list;
 996 }
 997
 998 gboolean
 999 anjuta_util_create_dir (const gchar* path)
1000 {
1001         GFile *dir = g_file_new_for_path (path);
1002         GError *err = NULL;
1003         gchar *parent;
1004
1005         if (g_file_query_exists (dir, NULL))
1006         {
1007                 GFileInfo *info = g_file_query_info (dir,
1008                                 G_FILE_ATTRIBUTE_STANDARD_TYPE,
1009                                 G_FILE_QUERY_INFO_NONE,
1010                                 NULL, NULL);
1011                 if (g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY)
1012                 {
1013                         g_message ("Warning: %s is a file. \n "
1014                                         "It is trying to be treated as a directory.",g_file_get_path (dir));
1015                         g_object_unref (dir);
1016                         return FALSE;
1017                 }
1018                 g_object_unref (info);
1019         }
1020         else
1021         {
1022                 parent = g_path_get_dirname (path);
1023                 if (anjuta_util_create_dir (parent))
1024                 {
1025                         g_free (parent);
1026                         if (!g_file_make_directory (dir, NULL, &err))
1027                         {
1028                                 g_warning ("Error directory:\n %s", err->message);
1029                                 g_object_unref (dir);
1030                                 return FALSE;
1031                         }
1032                 }
1033                 else
1034                 {
1035                         g_free (parent);
1036                         g_object_unref (dir);
1037                         return FALSE;
1038                 }
1039         }
1040         g_object_unref (dir);
1041
1042         return TRUE;
1043 }
1044
1045 /**
1046  * anjuta_util_user_shell:
1047  *
1048  * Retrieves the user's preferred shell.
1049  *
1050  * Returns: A newly allocated string that is the path to the shell.
1051  */
1052 /* copied from deprecated gnome_util_user_shell in libgnome */
1053 gchar *
1054 anjuta_util_user_shell (void)
1055 {
1056 #ifndef G_OS_WIN32
1057         struct passwd *pw;
1058         gint i;
1059         const gchar *shell;
1060         const gchar shells [][14] = {
1061                 /* Note that on some systems shells can also
1062                  * be installed in /usr/bin */
1063                 "/bin/bash", "/usr/bin/bash",
1064                 "/bin/zsh", "/usr/bin/zsh",
1065                 "/bin/tcsh", "/usr/bin/tcsh",
1066                 "/bin/ksh", "/usr/bin/ksh",
1067                 "/bin/csh", "/bin/sh"
1068         };
1069
1070         if (geteuid () == getuid () &&
1071             getegid () == getgid ()) {
1072                 /* only in non-setuid */
1073                 if ((shell = g_getenv ("SHELL"))){
1074                         if (access (shell, X_OK) == 0) {
1075                                 return g_strdup (shell);
1076                         }
1077                 }
1078         }
1079         pw = getpwuid(getuid());
1080         if (pw && pw->pw_shell) {
1081                 if (access (pw->pw_shell, X_OK) == 0) {
1082                         return g_strdup (pw->pw_shell);
1083                 }
1084         }
1085
1086         for (i = 0; i != G_N_ELEMENTS (shells); i++) {
1087                 if (access (shells [i], X_OK) == 0) {
1088                         return g_strdup (shells[i]);
1089                 }
1090         }
1091
1092         /* If /bin/sh doesn't exist, your system is truly broken.  */
1093         abort ();
1094
1095         /* Placate compiler.  */
1096                                                                                         return NULL;
1097 #else
1098         /* g_find_program_in_path() always looks also in the Windows
1099          * and System32 directories, so it should always find either cmd.exe
1100          * or command.com.
1101          */
1102         gchar *retval = g_find_program_in_path ("cmd.exe");
1103
1104         if (retval == NULL)
1105                 retval = g_find_program_in_path ("command.com");
1106
1107         g_assert (retval != NULL);
1108
1109         return retval;
1110 #endif
1111 }
1112
1113 /**
1114  * anjuta_util_user_terminal:
1115  *
1116  * Retrieves the user's preferred terminal.
1117  *
1118  * Returns: A newly allocated strings list. The first argument is the terminal
1119  * program name. The following are the arguments needed to execute
1120  * a command. The list has to be freed with g_strfreev
1121  */
1122 /* copied from deprecated gnome_execute_terminal in libgnome */
1123 gchar **
1124 anjuta_util_user_terminal (void)
1125 {
1126 /* FIXME: GSettings */
1127 #if 0
1128         GConfClient *client;
1129         gchar *terminal = NULL;
1130         gchar **argv = NULL;
1131         static const gchar *terms[] = {
1132                 "xdg-terminal",
1133                 "gnome-terminal",
1134                 "nxterm",
1135                 "color-xterm",
1136                 "rxvt",
1137                 "xterm",
1138                 "dtterm",
1139                 NULL
1140         };
1141         const gchar **term;
1142
1143         client = gconf_client_get_default ();
1144         terminal = gconf_client_get_string (client, "/desktop/gnome/applications/terminal/exec", NULL);
1145         g_object_unref (client);
1146
1147         if (terminal)
1148         {
1149                 gchar *command_line;
1150                 gchar *exec_flag;
1151
1152                 exec_flag = gconf_client_get_string (client, "/desktop/gnome/applications/terminal/exec_arg", NULL);
1153                 command_line = g_strconcat (terminal, " ", exec_flag, NULL);
1154
1155                 g_shell_parse_argv (command_line, NULL, &argv, NULL);
1156                 g_free (terminal);
1157                 g_free (exec_flag);
1158
1159                 return argv;
1160         }
1161
1162
1163         /* Search for common ones */
1164         for (term = terms; *term != NULL; term++)
1165         {
1166                 terminal = g_find_program_in_path (*term);
1167                 if (terminal != NULL) break;
1168         }
1169
1170         /* Try xterm */
1171         g_warning (_("Cannot find a terminal; using "
1172                         "xterm, even if it may not work"));
1173         terminal = g_strdup ("xterm");
1174
1175         argv = g_new0 (char *, 3);
1176         argv[0] = terminal;
1177         /* Note that gnome-terminal takes -x and
1178          * as -e in gnome-terminal is broken we use that. */
1179         argv[1] = g_strdup (term == &terms[2] ? "-x" : "-e");
1180
1181         return argv;
1182 #else
1183         g_warning ("anjuta_util_user_terminal: Not implemented");
1184         return NULL;
1185 #endif
1186 }
1187
1188 pid_t
1189 anjuta_util_execute_shell (const gchar *dir, const gchar *command)
1190 {
1191         pid_t pid;
1192         gchar *shell;
1193         gint err;
1194
1195         g_return_val_if_fail (command != NULL, -1);
1196
1197         shell = anjuta_util_user_shell ();
1198         pid = fork();
1199         if (pid == 0)
1200         {
1201                 if(dir)
1202                 {
1203                         anjuta_util_create_dir (dir);
1204                         err = chdir (dir);
1205                 }
1206                 execlp (shell, shell, "-c", command, NULL);
1207                 g_warning (_("Cannot execute command: %s (using shell %s)\n"), command, shell);
1208                 _exit(1);
1209         }
1210         if (pid < 0)
1211                 g_warning (_("Cannot execute command: %s (using shell %s)\n"), command, shell);
1212         g_free (shell);
1213
1214         // Anjuta will take care of child exit automatically.
1215         return pid;
1216 }
1217
1218 pid_t
1219 anjuta_util_execute_terminal_shell (const gchar *dir, const gchar *command)
1220 {
1221         pid_t pid;
1222         gchar *shell;
1223         gchar **term_argv;
1224         gint err;
1225
1226         g_return_val_if_fail (command != NULL, -1);
1227
1228         shell = anjuta_util_user_shell ();
1229         term_argv = anjuta_util_user_terminal ();
1230         pid = fork();
1231         if (pid == 0)
1232         {
1233                 if(dir)
1234                 {
1235                         anjuta_util_create_dir (dir);
1236                         err = chdir (dir);
1237                 }
1238                 execlp (term_argv[0], term_argv[0], term_argv[1], shell, "-c", command, NULL);
1239                 g_warning (_("Cannot execute command: %s (using shell %s)\n"), command, shell);
1240                 _exit(1);
1241         }
1242         if (pid < 0)
1243                 g_warning (_("Cannot execute command: %s (using shell %s)\n"), command, shell);
1244         g_free (shell);
1245         g_strfreev (term_argv);
1246
1247         // Anjuta will take care of child exit automatically.
1248         return pid;
1249 }
1250
1251 gchar *
1252 anjuta_util_convert_to_utf8 (const gchar *str)
1253 {
1254         GError *error = NULL;
1255         gchar *utf8_msg_string = NULL;
1256
1257         g_return_val_if_fail (str != NULL, NULL);
1258         g_return_val_if_fail (strlen (str) > 0, NULL);
1259
1260         if (g_utf8_validate(str, -1, NULL))
1261         {
1262                 utf8_msg_string = g_strdup (str);
1263         }
1264         else
1265         {
1266                 gsize rbytes, wbytes;
1267                 utf8_msg_string = g_locale_to_utf8 (str, -1, &rbytes, &wbytes, &error);
1268                 if (error != NULL) {
1269                         g_warning ("g_locale_to_utf8 failed: %s\n", error->message);
1270                         g_error_free (error);
1271                         /* g_free (utf8_msg_string);
1272                         return NULL; */
1273                 }
1274         }
1275         return utf8_msg_string;
1276 }
1277
1278 GList*
1279 anjuta_util_parse_args_from_string (const gchar* string)
1280 {
1281         gboolean escaped;
1282         gchar    quote = 0;
1283         gboolean is_quote = FALSE;
1284         gchar* buffer = g_new0(gchar, strlen(string) + 1);
1285         const gchar *s;
1286         gint     idx;
1287         GList* args = NULL;
1288
1289         idx = 0;
1290         escaped = FALSE;
1291         s = string;
1292
1293         while (*s) {
1294                 if (!isspace(*s))
1295                         break;
1296                 s++;
1297         }
1298
1299         while (*s) {
1300                 if (escaped) {
1301                         /* The current char was escaped */
1302                         buffer[idx++] = *s;
1303                         escaped = FALSE;
1304                 } else if (*s == '\\') {
1305                         /* Current char is an escape */
1306                         escaped = TRUE;
1307                 } else if (is_quote && *s == quote) {
1308                         /* Current char ends a quotation */
1309                         is_quote = FALSE;
1310                         if (!isspace(*(s+1)) && (*(s+1) != '\0')) {
1311                                 /* If there is no space after the quotation or it is not
1312                                    the end of the string */
1313                                 g_warning ("Parse error while parsing program arguments");
1314                         }
1315                 } else if ((*s == '\"' || *s == '\'')) {
1316                         if (!is_quote) {
1317                                 /* Current char starts a quotation */
1318                                 quote = *s;
1319                                 is_quote = TRUE;
1320                         } else {
1321                                 /* Just a quote char inside quote */
1322                                 buffer[idx++] = *s;
1323                         }
1324                 } else if (is_quote){
1325                         /* Any other char inside quote */
1326                         buffer[idx++] = *s;
1327                 } else if (isspace(*s)) {
1328                         /* Any white space outside quote */
1329                         if (idx > 0) {
1330                                 buffer[idx++] = '\0';
1331                                 args = g_list_append (args, g_strdup (buffer));
1332                                 idx = 0;
1333                         }
1334                 } else {
1335                         buffer[idx++] = *s;
1336                 }
1337                 s++;
1338         }
1339         if (idx > 0) {
1340                 /* There are chars in the buffer. Flush as the last arg */
1341                 buffer[idx++] = '\0';
1342                 args = g_list_append (args, g_strdup (buffer));
1343                 idx = 0;
1344         }
1345         if (is_quote) {
1346                 g_warning ("Unclosed quotation encountered at the end of parsing");
1347         }
1348         g_free (buffer);
1349         return args;
1350 }
1351
1352 gchar*
1353 anjuta_util_escape_quotes(const gchar* str)
1354 {
1355         gchar *buffer;
1356         gint idx, max_size;
1357         const gchar *s = str;
1358
1359         g_return_val_if_fail(str, NULL);
1360         idx = 0;
1361
1362         /* We are assuming there will be less than 2048 chars to escape */
1363         max_size = strlen(str) + 2048;
1364         buffer = g_new (gchar, max_size);
1365         max_size -= 2;
1366
1367         while(*s) {
1368                 if (idx > max_size)
1369                         break;
1370                 if (*s == '\"' || *s == '\'' || *s == '\\')
1371                         buffer[idx++] = '\\';
1372                 buffer[idx++] = *s;
1373                 s++;
1374         }
1375         buffer[idx] = '\0';
1376         return buffer;
1377 }
1378
1379 /* Diff the text contained in uri with text. Return true if files
1380 differ, FALSE if they are identical.*/
1381
1382 gboolean anjuta_util_diff(const gchar* uri, const gchar* text)
1383 {
1384         GFile *file;
1385         GFileInfo *file_info;
1386         guint64 size;
1387         gchar* file_text = NULL;
1388         gsize bytes_read;
1389
1390         file = g_file_new_for_uri (uri);
1391         file_info = g_file_query_info (file,
1392                         G_FILE_ATTRIBUTE_STANDARD_SIZE,
1393                         G_FILE_QUERY_INFO_NONE,
1394                         NULL,
1395                         NULL);
1396
1397         if (file_info == NULL)
1398         {
1399                 g_object_unref (file);
1400                 return TRUE;
1401         }
1402
1403         size = g_file_info_get_attribute_uint64(file_info,
1404                         G_FILE_ATTRIBUTE_STANDARD_SIZE);
1405         g_object_unref (file_info);
1406
1407         if (size == 0 && text == NULL)
1408         {
1409                 g_object_unref (file);
1410                 return FALSE;
1411         }
1412         else if (size == 0 || text == NULL)
1413         {
1414                 g_object_unref (file);
1415                 return TRUE;
1416         }
1417
1418         if (!g_file_load_contents(file,
1419                                 NULL,
1420                                 &file_text,
1421                                 &bytes_read,
1422                                 NULL,
1423                                 NULL))
1424         {
1425                 g_object_unref (file);
1426                 return TRUE;
1427         }
1428         g_object_unref (file);
1429
1430         if (bytes_read != size)
1431         {
1432                 g_free (file_text);
1433                 return TRUE;
1434         }
1435
1436         /* according to g_file_load_contents's documentation
1437          * file_text is guaranteed to end with \0.
1438          */
1439         if (strcmp (file_text, text) == 0)
1440         {
1441                 g_free (file_text);
1442                 return FALSE;
1443         }
1444
1445         g_free (file_text);
1446         return TRUE;
1447 }
1448
1449 /**
1450  * anjuta_util_is_project_file:
1451  * @filename: the file name
1452  *
1453  * Return TRUE if the file is an anjuta project file. It is implemented by
1454  * checking only the file extension. So it does not check the existence
1455  * of the file. But it is working on an URI if it does not containt a
1456  * fragment.
1457  *
1458  * Returns: TRUE if the file is a project file, else FALSE
1459  */
1460 gboolean
1461 anjuta_util_is_project_file (const gchar *filename)
1462 {
1463         gsize len = strlen (filename);
1464         return ((len > 8) && (strcmp (filename + len - 7, ".anjuta") == 0));
1465 }
1466
1467 /**
1468  * anjuta_util_is_template_file:
1469  * @filename: the file name
1470  *
1471  * Return TRUE if the file is an template project file. It is implemented by
1472  * checking only the file extension. So it does not check the existence
1473  * of the file. But it is working on an URI if it does not containt a
1474  * fragment.
1475  *
1476  * Returns: TRUE if the file is a template file, else FALSE
1477  */
1478 gboolean
1479 anjuta_util_is_template_file (const gchar *filename)
1480 {
1481         gsize len = strlen (filename);
1482         return ((len > 9) && (strcmp (filename + len - 8, ".wiz.tgz") == 0));
1483 }
1484
1485 /**
1486  * anjuta_util_get_file_mine_type:
1487  * @file: the file
1488  *
1489  * Check if a file exists and return its mime type.
1490  *
1491  * Returns: NULL if the corresponding file doesn't exist or the mime type as a newly
1492  * allocated string that must be freed with g_free().
1493  */
1494 gchar *
1495 anjuta_util_get_file_mime_type (GFile *file)
1496 {
1497         GFileInfo *info;
1498         gchar *mime_type = NULL;
1499
1500         g_return_val_if_fail (file != NULL, NULL);
1501
1502         /* Get file information, check that the file exist at the same time */
1503         info = g_file_query_info (file,
1504                                                                                   G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
1505                                                                                   G_FILE_QUERY_INFO_NONE,
1506                                                                                   NULL,
1507                                                                                   NULL);
1508
1509         if (info != NULL)
1510         {
1511                 const gchar *extension;
1512                 gchar *name;
1513
1514                 /* If Anjuta is not installed in system gnome prefix, the mime types
1515                  * may not have been correctly registed. In that case, we use the
1516                  * following mime detection
1517                  */
1518                 name = g_file_get_basename (file);
1519                 extension = strrchr(name, '.');
1520                 if (extension != NULL)
1521                 {
1522                         const static struct {gchar *extension; gchar *type;} anjuta_types[] = {
1523                                                                         {"anjuta", "application/x-anjuta"},
1524                                                                         {"prj", "application/x-anjuta-old"},
1525                                                                         {NULL, NULL}};
1526                         gint i;
1527
1528                         for (i = 0; anjuta_types[i].extension != NULL; i++)
1529                         {
1530                                 if (strcmp(extension + 1, anjuta_types[i].extension) == 0)
1531                                 {
1532                                         mime_type = g_strdup (anjuta_types[i].type);
1533                                         break;
1534                                 }
1535                         }
1536                 }
1537                 g_free (name);
1538
1539                 /* Use mime database if it is not an Anjuta type */
1540                 if (mime_type == NULL)
1541                 {
1542                         mime_type = g_content_type_get_mime_type (g_file_info_get_content_type(info));
1543                 }
1544
1545                 g_object_unref (info);
1546         }
1547
1548         return mime_type;
1549 }
1550
1551 gchar *
1552 anjuta_util_get_local_path_from_uri (const gchar *uri)
1553 {
1554         GFile *file;
1555         gchar *local_path;
1556
1557         file = g_file_new_for_uri (uri);
1558         local_path = g_file_get_path (file);
1559         g_object_unref (file);
1560
1561         return local_path;
1562 }
1563
1564 #ifdef EMULATE_FORKPTY
1565 #include <grp.h>
1566
1567 static int ptym_open (char *pts_name);
1568 static int ptys_open (int fdm, char * pts_name);
1569
1570 int
1571 login_tty(int ttyfd)
1572 {
1573   int fd;
1574   char *fdname;
1575
1576 #ifdef HAVE_SETSID
1577   setsid();
1578 #endif
1579 #ifdef HAVE_SETPGID
1580   setpgid(0, 0);
1581 #endif
1582
1583   /* First disconnect from the old controlling tty. */
1584 #ifdef TIOCNOTTY
1585   fd = open("/dev/tty", O_RDWR|O_NOCTTY);
1586   if (fd >= 0)
1587     {
1588       ioctl(fd, TIOCNOTTY, NULL);
1589       close(fd);
1590     }
1591   else
1592     //syslog(LOG_WARNING, "NO CTTY");
1593 #endif /* TIOCNOTTY */
1594
1595   /* Verify that we are successfully disconnected from the controlling tty. */
1596   fd = open("/dev/tty", O_RDWR|O_NOCTTY);
1597   if (fd >= 0)
1598     {
1599       //syslog(LOG_WARNING, "Failed to disconnect from controlling tty.");
1600       close(fd);
1601     }
1602
1603   /* Make it our controlling tty. */
1604 #ifdef TIOCSCTTY
1605   ioctl(ttyfd, TIOCSCTTY, NULL);
1606 #endif /* TIOCSCTTY */
1607
1608   fdname = ttyname (ttyfd);
1609   fd = open(fdname, O_RDWR);
1610   if (fd < 0)
1611     ;//syslog(LOG_WARNING, "open %s: %s", fdname, strerror(errno));
1612   else
1613     close(fd);
1614
1615   /* Verify that we now have a controlling tty. */
1616   fd = open("/dev/tty", O_WRONLY);
1617   if (fd < 0)
1618     {
1619       //syslog(LOG_WARNING, "open /dev/tty: %s", strerror(errno));
1620       return 1;
1621     }
1622
1623   close(fd);
1624 #if defined(HAVE_VHANGUP) && !defined(HAVE_REVOKE)
1625   {
1626     RETSIGTYPE (*sig)();
1627     sig = signal(SIGHUP, SIG_IGN);
1628     vhangup();
1629     signal(SIGHUP, sig);
1630   }
1631 #endif
1632   fd = open(fdname, O_RDWR);
1633   if (fd == -1)
1634     {
1635       //syslog(LOG_ERR, "can't reopen ctty %s: %s", fdname, strerror(errno));
1636       return -1;
1637     }
1638
1639   close(ttyfd);
1640
1641   if (fd != 0)
1642     close(0);
1643   if (fd != 1)
1644     close(1);
1645   if (fd != 2)
1646     close(2);
1647
1648   dup2(fd, 0);
1649   dup2(fd, 1);
1650   dup2(fd, 2);
1651   if (fd > 2)
1652     close(fd);
1653   return 0;
1654 }
1655
1656 int
1657 openpty(int *amaster, int *aslave, char *name, struct termios *termp,
1658                 struct winsize *winp)
1659 {
1660         char line[20];
1661         *amaster = ptym_open(line);
1662         if (*amaster < 0)
1663                 return -1;
1664         *aslave = ptys_open(*amaster, line);
1665         if (*aslave < 0) {
1666                 close(*amaster);
1667                 return -1;
1668         }
1669         if (name)
1670                 strcpy(name, line);
1671 #ifndef TCSAFLUSH
1672 #define TCSAFLUSH TCSETAF
1673 #endif
1674         if (termp)
1675                 (void) tcsetattr(*aslave, TCSAFLUSH, termp);
1676 #ifdef TIOCSWINSZ
1677         if (winp)
1678                 (void) ioctl(*aslave, TIOCSWINSZ, (char *)winp);
1679 #endif
1680         return 0;
1681 }
1682
1683 static int
1684 ptym_open(char * pts_name)
1685 {
1686         int fdm;
1687 #ifdef HAVE_PTSNAME
1688         char *ptr;
1689
1690         strcpy(pts_name, "/dev/ptmx");
1691         fdm = open(pts_name, O_RDWR);
1692         if (fdm < 0)
1693                 return -1;
1694         if (grantpt(fdm) < 0) { /* grant access to slave */
1695                 close(fdm);
1696                 return -2;
1697         }
1698         if (unlockpt(fdm) < 0) { /* clear slave's lock flag */
1699                 close(fdm);
1700                 return -3;
1701         }
1702         ptr = ptsname(fdm);
1703         if (ptr == NULL) { /* get slave's name */
1704                 close (fdm);
1705                 return -4;
1706         }
1707         strcpy(pts_name, ptr); /* return name of slave */
1708         return fdm;            /* return fd of master */
1709 #else
1710         char *ptr1, *ptr2;
1711
1712         strcpy(pts_name, "/dev/ptyXY");
1713         /* array index: 012345689 (for references in following code) */
1714         for (ptr1 = "pqrstuvwxyzPQRST"; *ptr1 != 0; ptr1++) {
1715                 pts_name[8] = *ptr1;
1716                 for (ptr2 = "0123456789abcdef"; *ptr2 != 0; ptr2++) {
1717                         pts_name[9] = *ptr2;
1718                         /* try to open master */
1719                         fdm = open(pts_name, O_RDWR);
1720                         if (fdm < 0) {
1721                                 if (errno == ENOENT) /* different from EIO */
1722                                         return -1;  /* out of pty devices */
1723                                 else
1724                                         continue;  /* try next pty device */
1725                         }
1726                         pts_name[5] = 't'; /* chage "pty" to "tty" */
1727                         return fdm;   /* got it, return fd of master */
1728                 }
1729         }
1730         return -1; /* out of pty devices */
1731 #endif
1732 }
1733
1734 static int
1735 ptys_open(int fdm, char * pts_name)
1736 {
1737         int fds;
1738 #ifdef HAVE_PTSNAME
1739         /* following should allocate controlling terminal */
1740         fds = open(pts_name, O_RDWR);
1741         if (fds < 0) {
1742                 close(fdm);
1743                 return -5;
1744         }
1745         if (ioctl(fds, I_PUSH, "ptem") < 0) {
1746                 close(fdm);
1747                 close(fds);
1748                 return -6;
1749         }
1750         if (ioctl(fds, I_PUSH, "ldterm") < 0) {
1751                 close(fdm);
1752                 close(fds);
1753                 return -7;
1754         }
1755         if (ioctl(fds, I_PUSH, "ttcompat") < 0) {
1756                 close(fdm);
1757                 close(fds);
1758                 return -8;
1759         }
1760
1761         if (ioctl(fdm, I_PUSH, "pckt") < 0) {
1762                 close(fdm);
1763                 close(fds);
1764                 return -8;
1765         }
1766
1767         if (ioctl(fdm, I_SRDOPT, RMSGN|RPROTDAT) < 0) {
1768                 close(fdm);
1769                 close(fds);
1770                 return -8;
1771         }
1772
1773         return fds;
1774 #else
1775         int gid;
1776         struct group *grptr;
1777
1778         grptr = getgrnam("tty");
1779         if (grptr != NULL)
1780                 gid = grptr->gr_gid;
1781         else
1782                 gid = -1;  /* group tty is not in the group file */
1783         /* following two functions don't work unless we're root */
1784         chown(pts_name, getuid(), gid);
1785         chmod(pts_name, S_IRUSR | S_IWUSR | S_IWGRP);
1786         fds = open(pts_name, O_RDWR);
1787         if (fds < 0) {
1788                 close(fdm);
1789                 return -1;
1790         }
1791         return fds;
1792 #endif
1793 }
1794
1795 int
1796 forkpty(int *amaster, char *name, struct termios *termp, struct winsize *winp)
1797 {
1798   int master, slave, pid;
1799
1800   if (openpty(&master, &slave, name, termp, winp) == -1)
1801     return (-1);
1802   switch (pid = fork()) {
1803   case -1:
1804     return (-1);
1805   case 0:
1806     /*
1807      * child
1808      */
1809     close(master);
1810     login_tty(slave);
1811     return (0);
1812   }
1813   /*
1814    * parent
1815    */
1816   *amaster = master;
1817   close(slave);
1818   return (pid);
1819 }
1820
1821 int scandir(const char *dir, struct dirent ***namelist,
1822             int (*select)(const struct dirent *),
1823             int (*compar)(const struct dirent **, const struct dirent **))
1824 {
1825   DIR *d;
1826   struct dirent *entry;
1827   register int i=0;
1828   size_t entrysize;
1829
1830   if ((d=opendir(dir)) == NULL)
1831      return(-1);
1832
1833   *namelist=NULL;
1834   while ((entry=readdir(d)) != NULL)
1835   {
1836     if (select == NULL || (select != NULL && (*select)(entry)))
1837     {
1838       *namelist=(struct dirent **)realloc((void *)(*namelist),
1839                  (size_t)((i+1)*sizeof(struct dirent *)));
1840         if (*namelist == NULL) return(-1);
1841         entrysize=sizeof(struct dirent)-sizeof(entry->d_name)+strlen(entry->d_name)+1;
1842         (*namelist)[i]=(struct dirent *)malloc(entrysize);
1843         if ((*namelist)[i] == NULL) return(-1);
1844         memcpy((*namelist)[i], entry, entrysize);
1845         i++;
1846     }
1847   }
1848   if (closedir(d)) return(-1);
1849   if (i == 0) return(-1);
1850   if (compar != NULL)
1851     qsort((void *)(*namelist), (size_t)i, sizeof(struct dirent *), compar);
1852
1853   return(i);
1854 }
1855
1856 #endif /* EMULATE_FORKPTY */
1857
1858 void
1859 anjuta_util_help_display (GtkWidget   *parent,
1860                                                   const gchar *doc_id,
1861                                                   const gchar *item)
1862 {
1863         GError *error = NULL;
1864         gchar *command;
1865
1866
1867         command = g_strdup_printf ("yelp ghelp:%s%s%s",
1868                                    doc_id,
1869                                    item == NULL ? "" : "?",
1870                                    item == NULL ? "" : item);
1871
1872         if (!g_spawn_command_line_async (command, &error) &&
1873             (error != NULL))
1874         {
1875                 g_warning ("Error executing help application: %s",
1876                                    error->message);
1877                 g_error_free (error);
1878         }
1879         g_free (command);
1880 }
1881
1882
1883 /* The following functions are taken from gedit */
1884
1885 /* Note that this function replace home dir with ~ */
1886 gchar *
1887 anjuta_util_uri_get_dirname (const gchar *uri)
1888 {
1889         gchar *res;
1890         gchar *str;
1891
1892         // CHECK: does it work with uri chaining? - Paolo
1893         str = g_path_get_dirname (uri);
1894         g_return_val_if_fail (str != NULL, ".");
1895
1896         if ((strlen (str) == 1) && (*str == '.'))
1897         {
1898                 g_free (str);
1899
1900                 return NULL;
1901         }
1902
1903         res = anjuta_util_replace_home_dir_with_tilde (str);
1904
1905         g_free (str);
1906
1907         return res;
1908 }
1909
1910 gchar*
1911 anjuta_util_replace_home_dir_with_tilde (const gchar *uri)
1912 {
1913         gchar *tmp;
1914         gchar *home;
1915
1916         g_return_val_if_fail (uri != NULL, NULL);
1917
1918         /* Note that g_get_home_dir returns a const string */
1919         tmp = (gchar *)g_get_home_dir ();
1920
1921         if (tmp == NULL)
1922                 return g_strdup (uri);
1923
1924         home = g_filename_to_utf8 (tmp, -1, NULL, NULL, NULL);
1925         if (home == NULL)
1926                 return g_strdup (uri);
1927
1928         if (strcmp (uri, home) == 0)
1929         {
1930                 g_free (home);
1931
1932                 return g_strdup ("~");
1933         }
1934
1935         tmp = home;
1936         home = g_strdup_printf ("%s/", tmp);
1937         g_free (tmp);
1938
1939         if (g_str_has_prefix (uri, home))
1940         {
1941                 gchar *res;
1942
1943                 res = g_strdup_printf ("~/%s", uri + strlen (home));
1944
1945                 g_free (home);
1946
1947                 return res;
1948         }
1949
1950         g_free (home);
1951
1952         return g_strdup (uri);
1953 }
1954
1955 /**
1956  * anjuta_util_shell_expand:
1957  * @string: input string
1958  *
1959  * Expand environment variables $(var_name) and tilde (~) in the input string.
1960  *
1961  * Returns: a newly-allocated string that must be freed with g_free().
1962  */
1963 gchar*
1964 anjuta_util_shell_expand (const gchar *string)
1965 {
1966         GString* expand;
1967
1968         if (string == NULL) return NULL;
1969
1970         expand = g_string_sized_new (strlen (string));
1971
1972         for (; *string != '\0'; string++)
1973         {
1974                 switch (*string)
1975                 {
1976                         case '$':
1977                         {
1978                                 /* Variable expansion */
1979                                 const gchar *end;
1980                                 gint var_name_len;
1981
1982                                 end = string + 1;
1983                                 while (isalnum (*end) || (*end == '_')) end++;
1984                                 var_name_len = end - string - 1;
1985                                 if (var_name_len > 0)
1986                                 {
1987                                         const gchar *value;
1988
1989                                         g_string_append_len (expand, string + 1, var_name_len);
1990                                         value = g_getenv (expand->str + expand->len - var_name_len);
1991                                         g_string_truncate (expand, expand->len - var_name_len);
1992                                         g_string_append (expand, value);
1993                                         string = end - 1;
1994                                         continue;
1995                                 }
1996                                 break;
1997                         }
1998                         case '~':
1999                         {
2000                                 /* User home directory expansion */
2001                                 if (isspace(string[1]) || (string[1] == G_DIR_SEPARATOR) || (string[1] == '\0'))
2002                                 {
2003                                         g_string_append (expand, g_get_home_dir());
2004                                         continue;
2005                                 }
2006                                 break;
2007                         }
2008                         default:
2009                                 break;
2010                 }
2011                 g_string_append_c (expand, *string);
2012         }
2013
2014         return g_string_free (expand, FALSE);
2015 }
2016
2017 gchar *
2018 anjuta_util_str_middle_truncate (const gchar *string,
2019                                                                   guint        truncate_length)
2020 {
2021         GString     *truncated;
2022         guint        length;
2023         guint        n_chars;
2024         guint        num_left_chars;
2025         guint        right_offset;
2026         guint        delimiter_length;
2027         const gchar *delimiter = "\342\200\246";
2028
2029         g_return_val_if_fail (string != NULL, NULL);
2030
2031         length = strlen (string);
2032
2033         g_return_val_if_fail (g_utf8_validate (string, length, NULL), NULL);
2034
2035         /* It doesnt make sense to truncate strings to less than
2036          * the size of the delimiter plus 2 characters (one on each
2037          * side)
2038          */
2039         delimiter_length = g_utf8_strlen (delimiter, -1);
2040         if (truncate_length < (delimiter_length + 2)) {
2041                 return g_strdup (string);
2042         }
2043
2044         n_chars = g_utf8_strlen (string, length);
2045
2046         /* Make sure the string is not already small enough. */
2047         if (n_chars <= truncate_length) {
2048                 return g_strdup (string);
2049         }
2050
2051         /* Find the 'middle' where the truncation will occur. */
2052         num_left_chars = (truncate_length - delimiter_length) / 2;
2053         right_offset = n_chars - truncate_length + num_left_chars + delimiter_length;
2054
2055         truncated = g_string_new_len (string,
2056                                       g_utf8_offset_to_pointer (string, num_left_chars) - string);
2057         g_string_append (truncated, delimiter);
2058         g_string_append (truncated, g_utf8_offset_to_pointer (string, right_offset));
2059
2060         return g_string_free (truncated, FALSE);
2061 }
2062
2063 /*
2064  * Functions to implement XDG Base Directory Specification
2065  * http://standards.freedesktop.org/basedir-spec/latest/index.html
2066  * Use this to save any config/cache/data files
2067  *
2068  */
2069
2070 static gchar*
2071 anjuta_util_construct_pathv (const gchar* str, va_list str_list)
2072 {
2073         GPtrArray *str_arr;
2074         const gchar* tmp_str;
2075         gchar* path;
2076
2077         str_arr = g_ptr_array_new();
2078         g_ptr_array_add (str_arr, (gpointer) str);
2079
2080         /* Extract elements from va_list */
2081         if (str != NULL)
2082         {
2083                 while ((tmp_str = va_arg (str_list, const gchar*)) != NULL)
2084                 {
2085                         g_ptr_array_add (str_arr, (gpointer)tmp_str);
2086                 }
2087                 va_end (str_list);
2088         }
2089
2090         /* Terminate the list */
2091         g_ptr_array_add (str_arr, NULL);
2092
2093         path = g_build_filenamev ((gchar **)str_arr->pdata);
2094         g_ptr_array_free (str_arr, TRUE);
2095
2096         return path;
2097 }
2098
2099 static GFile*
2100 anjuta_util_get_user_cache_filev (const gchar* path, va_list list)
2101 {
2102         gchar *uri_str, *base_path, *dir;
2103         GFile *uri;
2104         const gchar anjuta_prefix[] = "anjuta";
2105         base_path = g_build_filename (g_get_user_cache_dir(), anjuta_prefix, path, NULL);
2106
2107         uri_str = anjuta_util_construct_pathv (base_path, list);
2108         g_free (base_path);
2109
2110         uri = g_file_new_for_path (uri_str);
2111         dir = g_path_get_dirname (uri_str);
2112         g_free(uri_str);
2113         if (!anjuta_util_create_dir (dir)) return NULL;
2114
2115         return uri;
2116 }
2117
2118 GFile*
2119 anjuta_util_get_user_cache_file (const gchar* path, ...)
2120 {
2121         va_list list;
2122         va_start (list, path);
2123         return anjuta_util_get_user_cache_filev (path, list);
2124 }
2125
2126 static GFile*
2127 anjuta_util_get_user_config_filev (const gchar* path, va_list list)
2128 {
2129         gchar *uri_str, *base_path, *dir;
2130         GFile *uri;
2131         const gchar anjuta_prefix[] = "anjuta";
2132         base_path = g_build_filename (g_get_user_config_dir(), anjuta_prefix, path, NULL);
2133
2134         uri_str = anjuta_util_construct_pathv (base_path, list);
2135         g_free (base_path);
2136
2137         uri = g_file_new_for_path (uri_str);
2138         dir = g_path_get_dirname (uri_str);
2139         g_free(uri_str);
2140         if (!anjuta_util_create_dir (dir)) return NULL;
2141
2142         return uri;
2143 }
2144
2145 GFile*
2146 anjuta_util_get_user_config_file (const gchar* path, ...)
2147 {
2148         va_list list;
2149         va_start (list, path);
2150         return anjuta_util_get_user_config_filev (path, list);
2151 }
2152
2153 static GFile*
2154 anjuta_util_get_user_data_filev (const gchar* path, va_list list)
2155 {
2156         gchar *uri_str, *base_path, *dir;
2157         GFile *uri;
2158         const gchar anjuta_prefix[] = "anjuta";
2159         base_path = g_build_filename (g_get_user_data_dir(), anjuta_prefix, path, NULL);
2160
2161         uri_str = anjuta_util_construct_pathv (base_path, list);
2162         g_free (base_path);
2163
2164         uri = g_file_new_for_path (uri_str);
2165         dir = g_path_get_dirname (uri_str);
2166         g_free(uri_str);
2167         if (!anjuta_util_create_dir (dir)) return NULL;
2168
2169         return uri;
2170 }
2171
2172 GFile*
2173 anjuta_util_get_user_data_file (const gchar* path, ...)
2174 {
2175         va_list list;
2176         va_start (list, path);
2177         return anjuta_util_get_user_data_filev (path, list);
2178 }
2179
2180 gchar*
2181 anjuta_util_get_user_cache_file_path (const gchar* path, ...)
2182 {
2183         va_list list;
2184         GFile *file;
2185         gchar *file_path;
2186         va_start (list, path);
2187         file = anjuta_util_get_user_cache_filev (path, list);
2188         file_path = g_file_get_path (file);
2189         g_object_unref (file);
2190
2191         return file_path;
2192 }
2193
2194 gchar*
2195 anjuta_util_get_user_config_file_path (const gchar* path, ...)
2196 {
2197         va_list list;
2198         GFile *file;
2199         gchar *file_path;
2200         va_start (list, path);
2201         file = anjuta_util_get_user_config_filev (path, list);
2202         file_path = g_file_get_path (file);
2203         g_object_unref (file);
2204
2205         return file_path;
2206 }
2207
2208 gchar*
2209 anjuta_util_get_user_data_file_path (const gchar* path, ...)
2210 {
2211         va_list list;
2212         GFile *file;
2213         gchar *file_path;;
2214         va_start (list, path);
2215         file = anjuta_util_get_user_data_filev (path, list);
2216         file_path = g_file_get_path (file);
2217         g_object_unref (file);
2218
2219         return file_path;
2220 }
2221
2222 GList *
2223 anjuta_util_convert_gfile_list_to_path_list (GList *list)
2224 {
2225         GList *path_list;
2226         GList *current_file;
2227         gchar *path;
2228
2229         path_list = NULL;
2230
2231         for (current_file = list; current_file != NULL; current_file = g_list_next (current_file))
2232         {
2233                 path = g_file_get_path (current_file->data);
2234
2235                 /* Ignore files with invalid paths */
2236                 if (path)
2237                         path_list = g_list_append (path_list, path);
2238         }
2239
2240         return path_list;
2241 }
2242
2243 GList *
2244 anjuta_util_convert_gfile_list_to_relative_path_list (GList *list,
2245                                                       const gchar *parent)
2246 {
2247         GFile *parent_file;
2248         GList *path_list;
2249         GList *current_file;
2250         gchar *path;
2251
2252         parent_file = g_file_new_for_path (parent);
2253         path_list = NULL;
2254
2255         if (parent_file)
2256         {
2257                 for (current_file = list; current_file != NULL; current_file = g_list_next (current_file))
2258                 {
2259                         path = g_file_get_relative_path (parent_file, current_file->data);
2260
2261                         /* Ignore files with invalid paths */
2262                         if (path)
2263                                 path_list = g_list_append (path_list, path);
2264                 }
2265
2266                 g_object_unref (parent_file);
2267         }
2268
2269         return path_list;
2270 }
2271
2272
2273 /**
2274  * anjuta_util_builder_new:
2275  * @filename: Builder file name to open
2276  * @error: Optional error object, if NULL display a dialog if the file is missing
2277  *
2278  * Create a new GtkBuilder object and load the file in it. Display an error
2279  * if the file is missing. Use a dialog if error is NULL, just a warning
2280  * if the error can be reported.
2281   *
2282  * Returns: The new GtkBuilder object
2283  */
2284 GtkBuilder *
2285 anjuta_util_builder_new (const gchar *filename, GError **error)
2286 {
2287         GtkBuilder *bxml = gtk_builder_new ();
2288         GError *err = NULL;
2289
2290         /* Load glade file */
2291         if (!gtk_builder_add_from_file (bxml, filename, &err))
2292         {
2293                 g_object_unref (bxml);
2294                 bxml = NULL;
2295
2296                 /* Display the error to the user if it cannot be reported to the caller */
2297                 if (error == NULL)
2298                 {
2299                         anjuta_util_dialog_error (NULL, _("Unable to load user interface file: %s"), err->message);
2300                 }
2301                 else
2302                 {
2303                         g_warning ("Couldn't load builder file: %s", err->message);
2304                 }
2305                 g_propagate_error (error, err);
2306         }
2307
2308         /* Tag the builder object with the filename to allow better error message
2309          * with the following function */
2310         if (bxml != NULL)
2311         {
2312                 g_object_set_data_full (G_OBJECT (bxml), "filename", g_strdup (filename), g_free);
2313         }
2314
2315         return bxml;
2316 }
2317
2318 /**
2319  * anjuta_util_builder_get_objects:
2320  * @builder: Builder object
2321  * @first_widget: Name of first widget to get
2322  * ...: Address to store the first widget pointer, followed optionally by
2323  *              more name/pointer pairs, followed by NULL
2324  *
2325  * Create a new GtkBuilder object and load the file in it. Display an error
2326  * if the file is missing. Use a dialog if error is NULL, just a warning
2327  * if the error can be reported.
2328   *
2329  * Returns: TRUE is everything works as expected.
2330  */
2331 gboolean
2332 anjuta_util_builder_get_objects (GtkBuilder *builder, const gchar *first_widget,...)
2333 {
2334         va_list args;
2335         const gchar *name;
2336         GObject **object_ptr;
2337         gboolean missing = FALSE;
2338
2339         va_start (args, first_widget);
2340
2341         for (name = first_widget; name; name = va_arg (args, char *))
2342         {
2343                 object_ptr = va_arg (args, void *);
2344                 *object_ptr = gtk_builder_get_object (builder, name);
2345
2346                 /* Object not found, display a warning */
2347                 if (!*object_ptr)
2348                 {
2349                         const gchar *filename = (const gchar *)g_object_get_data (G_OBJECT (builder), "filename");
2350                         if (filename)
2351                         {
2352                                 g_warning ("Missing widget '%s' in file %s", name, filename);
2353                         }
2354                         else
2355                         {
2356                                 g_warning("Missing widget '%s'", name);
2357                         }
2358                         missing = TRUE;
2359         }
2360         }
2361          va_end (args);
2362
2363         return !missing;
2364 }
2365
2366 /**
2367  * anjuta_utils_drop_get_files:
2368  * @selection_data: the #GtkSelectionData from drag_data_received
2369  * @info: the info from drag_data_received
2370  *
2371  * Create a list of valid uri's from a uri-list drop.
2372  *
2373  * Return value: a list of GFiles
2374  */
2375 GSList*
2376 anjuta_utils_drop_get_files (GtkSelectionData *selection_data)
2377 {
2378         gchar **uris;
2379         gint i;
2380         GSList* files = NULL;
2381
2382         uris = g_uri_list_extract_uris ((gchar *) gtk_selection_data_get_data (selection_data));
2383
2384         for (i = 0; uris[i] != NULL; i++)
2385         {
2386                 GFile* file = g_file_new_for_uri (uris[i]);
2387                 files = g_slist_append(files, file);
2388         }
2389
2390         return files;
2391 }
2392
2393 /*
2394  * anjuta_util_get_user_mail:
2395  *
2396  * Returns: The e-mail Address of the logged-in user. The resulting string
2397  * must be free'd after use.
2398  */
2399 gchar*
2400 anjuta_util_get_user_mail()
2401 {
2402         /* FIXME: Use libfolks or something like it to query the mail address */
2403         return g_strconcat(g_get_user_name (), "@", g_get_host_name (), NULL);
2404 }
2405
2406 /**
2407  * anjuta_utils_clone_string_gptrarray:
2408  * @source: The source GPtrArray containing items representing strings
2409  *
2410  * Clones the contents of source GPtrArray into a new allocated GPtrArray.
2411  *
2412  * Return a new allocated GPtrArray with strings g_strdup (), NULL on error.
2413  * The returned array has set g_free as GDestroyNotity function, so that user
2414  * should only care to g_ptr_array_unref () without freeing the strings.
2415  */
2416 GPtrArray *
2417 anjuta_util_clone_string_gptrarray (const GPtrArray* source)
2418 {
2419         gint i;
2420         GPtrArray *dest;
2421
2422         g_return_val_if_fail (source != NULL, NULL);
2423
2424         dest = g_ptr_array_sized_new (source->len);
2425         g_ptr_array_set_free_func (dest, g_free);
2426
2427         for (i = 0; i < source->len; i++)
2428         {
2429                 g_ptr_array_add (dest, g_strdup (g_ptr_array_index (source, i)));
2430         }
2431
2432         return dest;
2433 }
2434
2435 void
2436 anjuta_util_list_all_dir_children (GList **children, GFile *dir)
2437 {
2438         GFileEnumerator *list;
2439
2440         list = g_file_enumerate_children (dir,
2441             G_FILE_ATTRIBUTE_STANDARD_NAME,
2442             G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
2443             NULL,
2444             NULL);
2445
2446         if (list != NULL)
2447         {
2448                 GFileInfo *info;
2449
2450                 while ((info = g_file_enumerator_next_file (list, NULL, NULL)) != NULL)
2451                 {
2452                         const gchar *name;
2453                         GFile *file;
2454
2455                         name = g_file_info_get_name (info);
2456                         file = g_file_get_child (dir, name);
2457                         g_object_unref (info);
2458
2459                         if (g_file_query_file_type (file, G_FILE_QUERY_INFO_NONE, NULL) == G_FILE_TYPE_DIRECTORY)
2460                         {
2461                                 anjuta_util_list_all_dir_children (children, file);
2462                                 g_object_unref (file);
2463                         }
2464                         else
2465                         {
2466                                 *children = g_list_prepend (*children, file);
2467                         }
2468                 }
2469                 g_file_enumerator_close (list, NULL, NULL);
2470                 g_object_unref (list);
2471         }
2472 }
2473
2474 GPtrArray *
2475 anjuta_util_convert_string_list_to_array (GList *list)
2476 {
2477         GList *node;
2478         GPtrArray *res;
2479
2480         g_return_val_if_fail (list != NULL, NULL);
2481
2482         res = g_ptr_array_new_with_free_func (g_free);
2483
2484         node = list;
2485         while (node != NULL)
2486         {
2487                 g_ptr_array_add (res, g_strdup (node->data));
2488
2489                 node = g_list_next (node);
2490         }
2491
2492         return res;
2493 }
2494
2495