irreco/src/util/irreco_misc.c

   1 /*
   2  * irreco - Ir Remote Control
   3  * Copyright (C) 2007  Arto Karppinen (arto.karppinen@iki.fi),
   4  * Harri Vattulainen (t5vaha01@students.oamk.fi)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (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 Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20
  21
  22
  23 #include "irreco_util.h"
  24 #include <sys/socket.h>
  25 #include <errno.h>
  26
  27 /**
  28  * @addtogroup IrrecoMisc
  29  * @ingroup IrrecoUtil
  30  *
  31  * All kinds of usefull stuff that isnt really part of Irreco. Does not
  32  * pull any other Irreco headers, so it can be safely included inside backends.
  33  *
  34  * @{
  35  */
  36
  37 /**
  38  * @file
  39  * Source file of @ref IrrecoMisc.
  40  */
  41 /*
  42  * Utility functions.
  43  *
  44  * All kinds of usefull stuff that isnt really part of Irreco. Does not pull
  45  * any other Irreco headers, so it can be safely included inside backends.
  46  */
  47
  48 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  49 /* Public Functions                                                           */
  50 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  51
  52
  53
  54 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  55 /* Files and directories.                                                     */
  56 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  57
  58 /**
  59  * @name Files and directories
  60  * @{
  61  */
  62
  63 /**
  64  * Check if the given filename is a directory.
  65  */
  66 int irreco_is_dir(const char *filename)
  67 {
  68         int rval;
  69         struct stat buf;
  70         char *realpath = canonicalize_file_name(filename);
  71         rval = (realpath != NULL) &&
  72                (stat(filename, &buf) == 0) &&
  73                S_ISDIR(buf.st_mode);
  74         free(realpath);
  75         return rval;
  76 }
  77
  78 /**
  79  * Check if a given file is a regular file.
  80  */
  81 int irreco_is_file(const char *filename)
  82 {
  83         int rval;
  84         struct stat buf;
  85         char *realpath = canonicalize_file_name(filename);
  86         rval = (realpath != NULL) &&
  87                (stat(filename, &buf) == 0) &&
  88                S_ISREG(buf.st_mode);
  89         free(realpath);
  90         return rval;
  91 }
  92
  93 /**
  94  * Does the the file or dir exists.
  95  */
  96 int irreco_file_exists(const char *filename)
  97 {
  98         struct stat struct_stat;
  99         if (stat(filename, &struct_stat) == 0) {
 100                 return TRUE;
 101         }
 102         return FALSE;
 103 }
 104
 105 /**
 106  * Return length of file
 107  * Return 0 if file doesn't exist
 108  */
 109 gint irreco_file_length(const gchar *filename)
 110 {
 111         struct stat struct_stat;
 112
 113         if(!irreco_file_exists(filename)) {
 114                 return 0;
 115         }
 116
 117         stat(filename, &struct_stat);
 118         return struct_stat.st_size;
 119 }
 120
 121 /**
 122  * Write data to file.
 123  */
 124 gboolean irreco_write_file(const gchar * file, const gchar * data,
 125                            gsize data_size)
 126 {
 127         FILE *handle;
 128         size_t written;
 129         IRRECO_ENTER
 130
 131         if ((handle = fopen(file, "w")) == NULL) {
 132                 IRRECO_ERROR("Failed to open \"%s\" for writing.\n", file);
 133                 IRRECO_RETURN_BOOL(FALSE);
 134         }
 135
 136         written = fwrite(data, sizeof(gchar), data_size, handle);
 137         fclose(handle);
 138
 139         if (written != data_size) {
 140                 IRRECO_ERROR("Failed to write data to \"%s\". "
 141                              "Data size \"%u\", wrote \"%u\".\n",
 142                              file, data_size, written);
 143                 IRRECO_RETURN_BOOL(FALSE);
 144         }
 145         IRRECO_RETURN_BOOL(TRUE);
 146 }
 147
 148 /**
 149  * Read contents of file into a buffer, or at least as much of the file the
 150  * buffer can contain.
 151  */
 152 gboolean irreco_read_text_file(const gchar * file, gchar *buffer,
 153                                gsize buffer_size)
 154 {
 155         gint count;
 156         FILE *fd;
 157
 158         buffer[0] = '\0';
 159         if ((fd = fopen(file, "r")) == NULL) return FALSE;
 160         count = fread(buffer, 1, buffer_size, fd);
 161         buffer[count] = '\0';
 162         if (count < 1) return FALSE;
 163         return TRUE;
 164 }
 165
 166 /**
 167  * Read contents of binary file into a buffer, or at least as much of the file the
 168  * buffer can contain.
 169  */
 170 gboolean irreco_read_binary_file(const gchar *file, guchar *buffer,
 171                                gsize buffer_size, gint *binlen)
 172 {
 173         gint count;
 174         FILE *fd;
 175
 176         if ((fd = g_fopen(file, "rb")) == NULL) return FALSE;
 177         count = (gint) fread(buffer, 1, buffer_size, fd);
 178         fclose(fd);
 179         if (count < 1) return FALSE;
 180         *binlen = count;
 181         return TRUE;
 182 }
 183
 184 /**
 185  * Read a line of text from file to buffer.
 186  */
 187 gboolean irreco_read_line(const gchar * file, gchar *buffer,
 188                           gsize buffer_size)
 189 {
 190         gint i;
 191
 192         if (!irreco_read_text_file(file, buffer, buffer_size)) return FALSE;
 193         for (i = 0; i < buffer_size; i++) {
 194                 if (buffer[i] == '\0' || buffer[i] == '\n') {
 195                         buffer[i] = '\0';
 196                         return TRUE;
 197                 }
 198         }
 199         return TRUE;
 200 }
 201
 202 /**
 203  * Write GKeyFile contents to file.
 204  */
 205 gboolean irreco_write_keyfile(GKeyFile * keyfile, const gchar * file)
 206 {
 207         gchar *data;
 208         gsize data_size;
 209         GError *error = NULL;
 210         gboolean success;
 211         IRRECO_ENTER
 212
 213         data = g_key_file_to_data(keyfile, &data_size, &error);
 214         if (irreco_gerror_check_print(&error)) {
 215                 IRRECO_RETURN_BOOL(FALSE);
 216         }
 217
 218         success = irreco_write_file(file, data, data_size);
 219         g_free(data);
 220         IRRECO_RETURN_BOOL(success);
 221 }
 222
 223 /**
 224  * Read all filenames that match suffix from directory.
 225  */
 226 gboolean irreco_dir_foreach(IrrecoDirForeachData *dir_data,
 227                             IrrecoDirForeachCallback callback)
 228 {
 229         GError *error = NULL;
 230         GDir* dir = NULL;
 231         IRRECO_ENTER
 232
 233         /* Open Dir. */
 234         dir = g_dir_open(dir_data->directory, 0, &error);
 235         if (irreco_gerror_check_print(&error)) {
 236                 IRRECO_ERROR("Could not read directory: \"%s\"\n",
 237                              dir_data->directory);
 238                 g_dir_close(dir);
 239                 IRRECO_RETURN_BOOL(FALSE);
 240         }
 241
 242         /* Read dir. */
 243         while ((dir_data->filename = g_dir_read_name(dir)) != NULL) {
 244                 if (g_str_has_suffix(dir_data->filename,
 245                                      dir_data->filesuffix)) {
 246                         dir_data->filepath = g_build_path("/",
 247                                 dir_data->directory, dir_data->filename, NULL);
 248                         callback(dir_data);
 249                         g_free((void*)dir_data->filepath);
 250                 }
 251         }
 252         g_dir_close(dir);
 253         IRRECO_RETURN_BOOL(TRUE);
 254 }
 255
 256
 257
 258 /**
 259  * Read all filenames that match suffix.
 260  * Searches ONLY thru subdirectories.
 261  */
 262 gboolean irreco_dir_foreach_subdirectories(IrrecoDirForeachData *dir_data,
 263                             IrrecoDirForeachCallback callback)
 264 {
 265         GError          *error = NULL;
 266         GDir            *dir = NULL;
 267         GDir            *subdir = NULL;
 268         gchar           *subpath = NULL;
 269         const gchar     *buttonsdir;
 270         const gchar     *directorykeeper = dir_data->directory;
 271         IRRECO_ENTER
 272
 273         /* Open Dir. */
 274         dir = g_dir_open(dir_data->directory, 0, &error);
 275         if (irreco_gerror_check_print(&error)) {
 276                 IRRECO_ERROR("Could not read directory: \"%s\"\n",
 277                              dir_data->directory);
 278                 IRRECO_RETURN_BOOL(FALSE);
 279         }
 280
 281         /* Read buttons dir file by file (also directories) */
 282         while ((buttonsdir = g_dir_read_name(dir)) != NULL) {
 283
 284                 /* Create possible subpath from readed files */
 285                 subpath = g_build_path("/", dir_data->directory,
 286                                        buttonsdir, NULL);
 287
 288                 /* Test if subpath is folder */
 289                 if(g_file_test(subpath, G_FILE_TEST_IS_DIR)) {
 290
 291                         /* Create GDir from directory or multifail instantly */
 292                         subdir = g_dir_open(subpath, 0, &error);
 293                         if (irreco_gerror_check_print(&error)) {
 294                                 IRRECO_ERROR("Could not read dir: \"%s\"\n",
 295                                              subpath);
 296                                 g_free(subpath);
 297                                 g_dir_close(dir);
 298                                 IRRECO_RETURN_BOOL(FALSE);
 299                         }
 300
 301                         /* Start reading files from subdirectory */
 302                         while ((dir_data->filename = g_dir_read_name(subdir))
 303                                                                 != NULL) {
 304
 305                                 /* Find files with wanted suffix */
 306                                 if (g_str_has_suffix(dir_data->filename,
 307                                                         dir_data->filesuffix)) {
 308
 309                                         dir_data->filepath = g_build_path("/",
 310                                                         subpath,
 311                                                         dir_data->filename,
 312                                                         NULL);
 313                                         dir_data->directory = subpath;
 314                                         callback(dir_data);
 315                                         dir_data->directory = directorykeeper;
 316                                         g_free((void*)dir_data->filepath);
 317                                 }
 318                         }
 319                 }
 320                 g_free(subpath);
 321                 subpath = NULL;
 322                 g_dir_close(subdir);
 323                 subdir = NULL;
 324         }
 325         if(dir != NULL) g_dir_close(dir);
 326         if(subdir != NULL) g_dir_close(subdir);
 327         if(subpath != NULL) g_free(subpath);
 328         IRRECO_RETURN_BOOL(TRUE);
 329 }
 330
 331 /**
 332  * Create path to directory $HOME/.APP_NAME, and attempt to create the
 333  * directory if it does not exists.
 334  *
 335  * @return Directory path inside a newly allocated string,
 336  *          or NULL if the directory could not be created.
 337  */
 338 gchar * irreco_get_config_dir(const gchar * app_name)
 339 {
 340         GString *app_name_with_dot;
 341         gchar *home;
 342         gchar *apphome;
 343         IRRECO_ENTER
 344
 345         if ((home = getenv("HOME")) == NULL) IRRECO_RETURN_PTR(NULL);
 346
 347         app_name_with_dot = g_string_new(".");
 348         g_string_append(app_name_with_dot, app_name);
 349         apphome = g_build_path("/", home, app_name_with_dot->str, NULL);
 350         g_string_free(app_name_with_dot, TRUE);
 351
 352         if (irreco_is_dir(apphome) == TRUE
 353             || g_mkdir(apphome, 0700) == 0)
 354                 IRRECO_RETURN_PTR(apphome);
 355
 356         g_free(apphome);
 357         IRRECO_RETURN_PTR(NULL);
 358 }
 359
 360 /**
 361  * Get path to $HOME/.APP_NAME/FILE
 362  *
 363  * @return Newly allocated string which contains path to config file or NULL.
 364  */
 365 gchar * irreco_get_config_file(const gchar * app_name, const gchar * file)
 366 {
 367         gchar *config_dir;
 368         gchar *config_file;
 369         IRRECO_ENTER
 370
 371         if ((config_dir = irreco_get_config_dir(app_name)) != NULL) {
 372                 config_file = g_build_path("/", config_dir, file, NULL);
 373                 g_free(config_dir);
 374                 IRRECO_RETURN_PTR(config_file);
 375         }
 376         IRRECO_RETURN_PTR(NULL);
 377 }
 378
 379 /** @} */
 380
 381
 382
 383 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 384 /* Strings.                                                                   */
 385 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 386
 387 /**
 388  * @name Strings
 389  * @{
 390  */
 391
 392 /**
 393  * Replace characters.
 394  */
 395 void irreco_char_replace(gchar * string, gchar what, gchar with)
 396 {
 397         gint i;
 398         IRRECO_ENTER
 399         for (i = 0; string[i] != '\0'; i++) {
 400                 if (string[i] == what) {
 401                         string[i] = with;
 402                 }
 403         }
 404         IRRECO_RETURN
 405 }
 406
 407 /**
 408  * Find first occurrence of character inside string.
 409  *
 410  * @return Position of character or -1.
 411  */
 412 gint irreco_char_pos(const gchar * string, gchar what)
 413 {
 414         gint i;
 415         IRRECO_ENTER
 416
 417         for (i = 0; string[i] != '\0'; i++) {
 418                 if (string[i] == what) {
 419                         IRRECO_RETURN_INT(i);
 420                 }
 421         }
 422         IRRECO_RETURN_INT(-1);
 423 }
 424
 425 /**
 426  * Check if the string is empty.
 427  *
 428  * String is empty if it is:
 429  * @li NULL
 430  * @li ""
 431  * @li Full of space characters.
 432  */
 433 gboolean irreco_str_isempty(const gchar * string)
 434 {
 435         IRRECO_ENTER
 436
 437         if (string == NULL || string[0] == '\0') IRRECO_RETURN_BOOL(TRUE);
 438         do {
 439                 if (g_unichar_isspace(g_utf8_get_char(string)) == FALSE) {
 440                         IRRECO_RETURN_BOOL(FALSE);
 441                 }
 442                 printf("\"%s\" %p\n", string, string);
 443         } while ((string = g_utf8_find_next_char(string, NULL)) != NULL
 444                 && string[0] != '\0');
 445
 446         IRRECO_RETURN_BOOL(TRUE);
 447 }
 448
 449 /**
 450  * Copy C-string into GString.
 451  */
 452 void irreco_gstring_set(GString * g_str, const gchar * c_str)
 453 {
 454         IRRECO_ENTER
 455
 456         if (c_str == NULL) {
 457                 g_string_assign(g_str, "");
 458         } else {
 459                 g_string_assign(g_str, c_str);
 460         }
 461
 462         IRRECO_RETURN
 463 }
 464
 465 /**
 466  * Copy C-string into GString and free C-string.
 467  */
 468 void irreco_gstring_set_and_free(GString * g_str, gchar * c_str)
 469 {
 470         IRRECO_ENTER
 471
 472         if (c_str == NULL) {
 473                 g_string_assign(g_str, "");
 474         } else {
 475                 g_string_assign(g_str, c_str);
 476                 g_free(c_str);
 477         }
 478
 479         IRRECO_RETURN
 480 }
 481
 482 /** @} */
 483
 484
 485 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 486 /* Error handling.                                                            */
 487 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 488
 489 /**
 490  * @name Error handling
 491  * @{
 492  */
 493
 494
 495 /**
 496  * If GError is set, print message, release GError, and return TRUE.
 497  * Otherwise returns FALSE.
 498  */
 499 gboolean irreco_gerror_check_print(GError ** error)
 500 {
 501         if (*error != NULL) {
 502                 IRRECO_PRINTF("GError: %s\n", (*error)->message);
 503                 g_error_free(*error);
 504                 *error = NULL;
 505                 return TRUE;
 506         }
 507         return FALSE;
 508 }
 509
 510 /**
 511  * If GError is set, free it, and return TRUE.
 512  * Otherwise returns FALSE.
 513  */
 514 gboolean irreco_gerror_check_free(GError ** error)
 515 {
 516         if (*error != NULL) {
 517                 g_error_free(*error);
 518                 *error = NULL;
 519                 return TRUE;
 520         }
 521         return FALSE;
 522 }
 523
 524 /** @} */
 525
 526 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 527 /* GTK.                                                                       */
 528 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 529
 530 /**
 531  * @name GTK
 532  * @{
 533  */
 534
 535 /**
 536  * Show info popup.
 537  */
 538 void irreco_info_dlg(GtkWindow * parent_window, const gchar * message)
 539 {
 540         GtkWidget* dialog;
 541         IRRECO_ENTER
 542
 543         dialog = gtk_message_dialog_new(parent_window,
 544                 GTK_DIALOG_DESTROY_WITH_PARENT,
 545                 GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "%s", message);
 546         gtk_dialog_run(GTK_DIALOG(dialog));
 547         gtk_widget_destroy(dialog);
 548
 549         IRRECO_RETURN
 550 }
 551
 552 /**
 553  * Show error popup.
 554  */
 555 void irreco_error_dlg(GtkWindow * parent_window, const gchar * message)
 556 {
 557         GtkWidget* dialog;
 558         IRRECO_ENTER
 559
 560         dialog = gtk_message_dialog_new(parent_window,
 561                 GTK_DIALOG_DESTROY_WITH_PARENT,
 562                 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", message);
 563         gtk_dialog_run(GTK_DIALOG(dialog));
 564         gtk_widget_destroy(dialog);
 565
 566         IRRECO_RETURN
 567 }
 568
 569 /**
 570  * Format message, and show error popup.
 571  */
 572 void irreco_info_dlg_printf(GtkWindow * parent_window,
 573                             const gchar * format, ...)
 574 {
 575         gint rvalue;
 576         va_list args;
 577         gchar *message = NULL;
 578         IRRECO_ENTER
 579
 580         va_start(args, format);
 581         rvalue = g_vasprintf(&message, format, args);
 582         va_end(args);
 583
 584         if (rvalue > 0) {
 585                 irreco_info_dlg(parent_window, message);
 586                 g_free(message);
 587         } else {
 588                 IRRECO_ERROR("Could not format message.\n");
 589         }
 590
 591         IRRECO_RETURN
 592 }
 593
 594 /**
 595  * Format message, and show error popup.
 596  */
 597 void irreco_error_dlg_printf(GtkWindow * parent_window,
 598                              const gchar * format, ...)
 599 {
 600         gint rvalue;
 601         va_list args;
 602         gchar *message = NULL;
 603         IRRECO_ENTER
 604
 605         va_start(args, format);
 606         rvalue = g_vasprintf(&message, format, args);
 607         va_end(args);
 608
 609         if (rvalue > 0) {
 610                 irreco_error_dlg(parent_window, message);
 611                 g_free(message);
 612         } else {
 613                 IRRECO_ERROR("Could not format message.\n");
 614         }
 615
 616         IRRECO_RETURN
 617 }
 618
 619 /**
 620  * Popup yes / no dialog.
 621  *
 622  * Returns: TRUE if user click YES, FALSE otherwise.
 623  */
 624 gboolean irreco_yes_no_dlg(GtkWindow * parent_window, const gchar * message)
 625 {
 626         gint responce;
 627         GtkWidget* dialog;
 628         IRRECO_ENTER
 629
 630         dialog = gtk_message_dialog_new(parent_window,
 631                 GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
 632                 GTK_BUTTONS_YES_NO, "%s", message);
 633         responce = gtk_dialog_run(GTK_DIALOG(dialog));
 634         gtk_widget_destroy(dialog);
 635         IRRECO_RETURN_BOOL(responce == GTK_RESPONSE_YES);
 636 }
 637
 638 /**
 639  * Convenience frapper of gtk_alignment_new().
 640  */
 641 GtkWidget *irreco_gtk_align(GtkWidget *child,
 642                             gfloat xalign,
 643                             gfloat yalign,
 644                             gfloat xscale,
 645                             gfloat yscale,
 646                             guint padding_top,
 647                             guint padding_bottom,
 648                             guint padding_left,
 649                             guint padding_right)
 650 {
 651         GtkWidget *align;
 652         IRRECO_ENTER
 653
 654         align = gtk_alignment_new(xalign, yalign, xscale, yscale);
 655         gtk_alignment_set_padding(GTK_ALIGNMENT(align), padding_top,
 656                                   padding_bottom, padding_left, padding_right);
 657         gtk_container_add(GTK_CONTAINER(align), child);
 658         IRRECO_RETURN_PTR(align);
 659 }
 660
 661 /**
 662  * Create, align, and pad label.
 663  */
 664 GtkWidget *irreco_gtk_label(const gchar * str,
 665                             gfloat xalign,
 666                             gfloat yalign,
 667                             guint padding_top,
 668                             guint padding_bottom,
 669                             guint padding_left,
 670                             guint padding_right)
 671 {
 672         GtkWidget *label;
 673         IRRECO_ENTER
 674
 675         label = gtk_label_new(str);
 676         gtk_misc_set_alignment(GTK_MISC(label), xalign, yalign);
 677         IRRECO_RETURN_PTR(irreco_gtk_pad(label, padding_top, padding_bottom,
 678                                          padding_left, padding_right));
 679 }
 680
 681 /**
 682  * Create, align, and pad a label with bold text.
 683  */
 684 GtkWidget *irreco_gtk_label_bold(const gchar * str,
 685                                  gfloat xalign,
 686                                  gfloat yalign,
 687                                  guint padding_top,
 688                                  guint padding_bottom,
 689                                  guint padding_left,
 690                                  guint padding_right)
 691 {
 692         gchar* markup;
 693         GtkWidget *label;
 694         IRRECO_ENTER
 695
 696         label = irreco_gtk_label(NULL, xalign, yalign, padding_top,
 697                                  padding_bottom, padding_left, padding_right);
 698         markup = g_markup_printf_escaped("<b>%s</b>", str);
 699         gtk_label_set_markup(GTK_LABEL(gtk_bin_get_child(GTK_BIN(label))),
 700                              markup);
 701         g_free(markup);
 702         IRRECO_RETURN_PTR(label);
 703 }
 704
 705 /**
 706  * Get button widget for dialog buttons.
 707  *
 708  * @param dialog        GtkDialog
 709  * @param n             Index of button to get.
 710  */
 711 GtkWidget *irreco_gtk_dialog_get_button(GtkWidget *dialog, guint n)
 712 {
 713
 714         GtkBox *action_area;
 715         GtkBoxChild *box_child;
 716         guint length;
 717         IRRECO_ENTER
 718
 719         action_area = GTK_BOX(GTK_DIALOG(dialog)->action_area);
 720         length = g_list_length(action_area->children);
 721
 722         if (n >= length) {
 723                 IRRECO_ERROR("Cant get button \"%i\". "
 724                              "Dialog has only \"%i\" buttons", n, length);
 725                 IRRECO_RETURN_PTR(NULL);
 726         }
 727
 728         box_child = (GtkBoxChild *) g_list_nth_data(g_list_first(
 729                 action_area->children), n);
 730         IRRECO_RETURN_PTR(box_child->widget);
 731 }
 732
 733 GtkWindow *irreco_gtk_get_parent_window(GtkWidget *widget)
 734 {
 735         GtkWidget *parent;
 736         IRRECO_ENTER
 737
 738         parent = gtk_widget_get_toplevel(widget);
 739         if (GTK_WIDGET_TOPLEVEL(parent) != TRUE
 740             || GTK_IS_WINDOW(parent) != TRUE) {
 741                 IRRECO_RETURN_PTR(GTK_WINDOW(parent));
 742         }
 743         IRRECO_RETURN_PTR(NULL);
 744 }
 745
 746 /**
 747  * This function is a modified version of gtk_dialog_new_empty() from GTK
 748  * sources, which is used to by gtk_dialog_new_with_buttons() to set the
 749  * settings of a dialog.
 750  */
 751 void irreco_gtk_dialog_set(GtkDialog *dialog,
 752                            const gchar *title,
 753                            GtkWindow *parent,
 754                            GtkDialogFlags flags)
 755 {
 756         IRRECO_ENTER
 757
 758         if (title)
 759                 gtk_window_set_title(GTK_WINDOW (dialog), title);
 760
 761         if (parent)
 762                 gtk_window_set_transient_for(GTK_WINDOW (dialog), parent);
 763
 764         if (flags & GTK_DIALOG_MODAL)
 765                 gtk_window_set_modal(GTK_WINDOW (dialog), TRUE);
 766
 767         if (flags & GTK_DIALOG_DESTROY_WITH_PARENT)
 768                 gtk_window_set_destroy_with_parent(GTK_WINDOW (dialog), TRUE);
 769
 770         if (flags & GTK_DIALOG_NO_SEPARATOR)
 771                 gtk_dialog_set_has_separator(dialog, FALSE);
 772
 773         IRRECO_RETURN
 774 }
 775
 776 /** @} */
 777
 778 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 779 /* Time.                                                                      */
 780 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 781
 782 /**
 783  * @name Time
 784  * @{
 785  */
 786
 787
 788 /**
 789  * Do not use, use GTimer instead.
 790  *
 791  * @deprecated
 792  *
 793  * Difference of time in microseconds between two GTimeVals.
 794  * This works fine as long as the difference is no more than 2146 seconds.
 795  */
 796 glong irreco_time_diff(GTimeVal *start, GTimeVal *end)
 797 {
 798         GTimeVal diff;
 799         IRRECO_ENTER
 800
 801         diff.tv_sec = end->tv_sec - start->tv_sec;
 802         diff.tv_usec = end->tv_usec - start->tv_usec;
 803
 804         /* We run out of space in ulong after 2147 seconds. */
 805         if (diff.tv_sec >= G_MAXLONG / IRRECO_SECOND_IN_USEC) {
 806                 IRRECO_RETURN_LONG((G_MAXLONG / IRRECO_SECOND_IN_USEC)
 807                                    * IRRECO_SECOND_IN_USEC);
 808         }
 809
 810         IRRECO_RETURN_LONG(diff.tv_sec * IRRECO_SECOND_IN_USEC + diff.tv_usec);
 811 }
 812
 813 /** @} */
 814
 815 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 816 /* Socket.                                                                    */
 817 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 818
 819 /**
 820  * @name Socket
 821  * @{
 822  */
 823
 824 /**
 825  * Check if the socket is valid.
 826  */
 827 gboolean irreco_is_socket_valid(int socket)
 828 {
 829         gint optval;
 830         socklen_t optlen;
 831         gint rvalue;
 832         IRRECO_ENTER
 833
 834         /* This should succeed if socket is valid. */
 835         rvalue = getsockopt(socket, SOL_SOCKET, SOCK_STREAM, &optval, &optlen);
 836
 837         if (rvalue == 0) {
 838                 IRRECO_RETURN_BOOL(TRUE);
 839         } else {
 840
 841                 /* glibc docs say these are the possible error values. */
 842                 switch (errno) {
 843                 case EBADF: IRRECO_PRINTF("Error: EBADF\n"); break;
 844                 case ENOTSOCK: IRRECO_PRINTF("Error: ENOTSOCK\n"); break;
 845                 case ENOPROTOOPT: IRRECO_PRINTF("Error: ENOPROTOOPT\n"); break;
 846                 default: IRRECO_PRINTF("Error: Unknown\n"); break;
 847                 };
 848
 849                 IRRECO_RETURN_BOOL(FALSE);
 850         }
 851
 852 }
 853 /** @} */
 854
 855 /** @} */
 856