src/bar_exif.c

   1 /*
   2  * Geeqie
   3  * (C) 2004 John Ellis
   4  * Copyright (C) 2008 - 2009 The Geeqie Team
   5  *
   6  * Author: Vladimir Nadvornik
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13
  14 #include "main.h"
  15 #include "bar_exif.h"
  16
  17 #include "exif.h"
  18 #include "metadata.h"
  19 #include "filedata.h"
  20 #include "history_list.h"
  21 #include "misc.h"
  22 #include "ui_misc.h"
  23 #include "ui_menu.h"
  24 #include "bar.h"
  25 #include "rcfile.h"
  26 #include "dnd.h"
  27 #include "ui_utildlg.h"
  28
  29
  30 #include <math.h>
  31
  32 #define MIN_HEIGHT 25
  33 /*
  34  *-------------------------------------------------------------------
  35  * EXIF widget
  36  *-------------------------------------------------------------------
  37  */
  38
  39 typedef struct _ExifEntry ExifEntry;
  40 struct _ExifEntry
  41 {
  42         GtkWidget *ebox;
  43         GtkWidget *hbox;
  44         GtkWidget *title_label;
  45         GtkWidget *value_label;
  46
  47         gchar *key;
  48         gchar *title;
  49         gboolean if_set;
  50         gboolean auto_title;
  51 };
  52
  53
  54 typedef struct _PaneExifData PaneExifData;
  55 struct _PaneExifData
  56 {
  57         PaneData pane;
  58         GtkWidget *vbox;
  59         GtkWidget *widget;
  60         GtkSizeGroup *size_group;
  61
  62         gint min_height;
  63
  64         gboolean all_hidden;
  65         gboolean show_all;
  66
  67         FileData *fd;
  68 };
  69
  70 typedef struct _ConfDialogData ConfDialogData;
  71 struct _ConfDialogData
  72 {
  73         GtkWidget *widget; /* pane or entry, devidet by presenceof "pane_data" or "entry_data" */
  74
  75         /* dialog parts */
  76         GtkWidget *key_entry;
  77         GtkWidget *title_entry;
  78         gboolean if_set;
  79 };
  80
  81 static void bar_pane_exif_entry_dnd_init(GtkWidget *entry);
  82 static void bar_pane_exif_entry_update_title(ExifEntry *ee);
  83 static void bar_pane_exif_update(PaneExifData *ped);
  84 static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data);
  85
  86 static void bar_pane_exif_entry_destroy(GtkWidget *widget, gpointer data)
  87 {
  88         ExifEntry *ee = data;
  89
  90         g_free(ee->key);
  91         g_free(ee->title);
  92         g_free(ee);
  93 }
  94
  95
  96 static GtkWidget *bar_pane_exif_add_entry(PaneExifData *ped, const gchar *key, const gchar *title, gint if_set)
  97 {
  98         ExifEntry *ee = g_new0(ExifEntry, 1);
  99
 100         ee->key = g_strdup(key);
 101         if (title && title[0])
 102                 {
 103                 ee->title = g_strdup(title);
 104                 }
 105         else
 106                 {
 107                 ee->title = exif_get_description_by_key(key);
 108                 ee->auto_title = TRUE;
 109                 }
 110
 111         ee->if_set = if_set;
 112
 113         ee->ebox = gtk_event_box_new();
 114         g_object_set_data(G_OBJECT(ee->ebox), "entry_data", ee);
 115         g_signal_connect_after(G_OBJECT(ee->ebox), "destroy",
 116                                G_CALLBACK(bar_pane_exif_entry_destroy), ee);
 117
 118         ee->hbox = gtk_hbox_new(FALSE, 0);
 119         gtk_container_add(GTK_CONTAINER(ee->ebox), ee->hbox);
 120         gtk_widget_show(ee->hbox);
 121
 122         ee->title_label = gtk_label_new(NULL);
 123         gtk_misc_set_alignment(GTK_MISC(ee->title_label), 1.0, 0.5);
 124         gtk_size_group_add_widget(ped->size_group, ee->title_label);
 125         gtk_box_pack_start(GTK_BOX(ee->hbox), ee->title_label, FALSE, TRUE, 0);
 126         gtk_widget_show(ee->title_label);
 127
 128         ee->value_label = gtk_label_new(NULL);
 129 //      gtk_label_set_width_chars(GTK_LABEL(ee->value_label), 20);
 130         gtk_label_set_ellipsize(GTK_LABEL(ee->value_label), PANGO_ELLIPSIZE_END);
 131 //      gtk_widget_set_size_request(ee->value_label, 100, -1);
 132         gtk_misc_set_alignment(GTK_MISC(ee->value_label), 0.0, 0.5);
 133         gtk_box_pack_start(GTK_BOX(ee->hbox), ee->value_label, TRUE, TRUE, 1);
 134         gtk_widget_show(ee->value_label);
 135         gtk_box_pack_start(GTK_BOX(ped->vbox), ee->ebox, FALSE, FALSE, 0);
 136
 137         bar_pane_exif_entry_dnd_init(ee->ebox);
 138         g_signal_connect(ee->ebox, "button_press_event", G_CALLBACK(bar_pane_exif_menu_cb), ped);
 139
 140         bar_pane_exif_entry_update_title(ee);
 141         bar_pane_exif_update(ped);
 142
 143         return ee->ebox;
 144 }
 145
 146 static void bar_pane_exif_reparent_entry(GtkWidget *entry, GtkWidget *pane)
 147 {
 148         GtkWidget *old_pane = entry->parent;
 149         PaneExifData *ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 150         PaneExifData *old_ped = g_object_get_data(G_OBJECT(old_pane), "pane_data");
 151         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 152         if (!ped || !old_ped || !ee) return;
 153
 154         g_object_ref(entry);
 155
 156         gtk_size_group_remove_widget(old_ped->size_group, ee->title_label);
 157         gtk_container_remove(GTK_CONTAINER(old_ped->vbox), entry);
 158
 159         gtk_size_group_add_widget(ped->size_group, ee->title_label);
 160         gtk_box_pack_start(GTK_BOX(ped->vbox), entry, FALSE, FALSE, 0);
 161 }
 162
 163 static void bar_pane_exif_entry_update_title(ExifEntry *ee)
 164 {
 165         gchar *markup;
 166
 167         markup = g_markup_printf_escaped("<span size='small'>%s:</span>", (ee->title) ? ee->title : "fixme");
 168         gtk_label_set_markup(GTK_LABEL(ee->title_label), markup);
 169         g_free(markup);
 170 }
 171
 172 static void bar_pane_exif_update_entry(PaneExifData *ped, GtkWidget *entry, gboolean update_title)
 173 {
 174         gchar *text;
 175         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 176         if (!ee) return;
 177         text = metadata_read_string(ped->fd, ee->key, METADATA_FORMATTED);
 178
 179         if (!ped->show_all && ee->if_set && (!text || !*text))
 180                 {
 181                 gtk_label_set_text(GTK_LABEL(ee->value_label), NULL);
 182                 gtk_widget_hide(entry);
 183                 }
 184         else
 185                 {
 186                 gtk_label_set_text(GTK_LABEL(ee->value_label), text);
 187 #if GTK_CHECK_VERSION(2,12,0)
 188                 gtk_widget_set_tooltip_text(ee->hbox, text);
 189 #endif
 190                 gtk_widget_show(entry);
 191                 ped->all_hidden = FALSE;
 192                 }
 193
 194         g_free(text);
 195
 196         if (update_title) bar_pane_exif_entry_update_title(ee);
 197 }
 198
 199 static void bar_pane_exif_update(PaneExifData *ped)
 200 {
 201         GList *list, *work;
 202
 203         ped->all_hidden = TRUE;
 204
 205         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 206         work = list;
 207         while (work)
 208                 {
 209                 GtkWidget *entry = work->data;
 210                 work = work->next;
 211
 212
 213                 bar_pane_exif_update_entry(ped, entry, FALSE);
 214                 }
 215         g_list_free(list);
 216
 217         gtk_widget_set_sensitive(ped->pane.title, !ped->all_hidden);
 218 }
 219
 220 void bar_pane_exif_set_fd(GtkWidget *widget, FileData *fd)
 221 {
 222         PaneExifData *ped;
 223
 224         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 225         if (!ped) return;
 226
 227         file_data_unref(ped->fd);
 228         ped->fd = file_data_ref(fd);
 229
 230         bar_pane_exif_update(ped);
 231 }
 232
 233 /*
 234  *-------------------------------------------------------------------
 235  * dnd
 236  *-------------------------------------------------------------------
 237  */
 238
 239 static GtkTargetEntry bar_pane_exif_drag_types[] = {
 240         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 241         { "text/plain", 0, TARGET_TEXT_PLAIN }
 242 };
 243 static gint n_exif_entry_drag_types = 2;
 244
 245 static GtkTargetEntry bar_pane_exif_drop_types[] = {
 246         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 247         { "text/plain", 0, TARGET_TEXT_PLAIN }
 248 };
 249 static gint n_exif_entry_drop_types = 2;
 250
 251
 252 static void bar_pane_exif_entry_dnd_get(GtkWidget *entry, GdkDragContext *context,
 253                                      GtkSelectionData *selection_data, guint info,
 254                                      guint time, gpointer data)
 255 {
 256         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 257
 258         switch (info)
 259                 {
 260
 261                 case TARGET_APP_EXIF_ENTRY:
 262                         gtk_selection_data_set(selection_data, selection_data->target,
 263                                                8, (gpointer) &entry, sizeof(entry));
 264                         break;
 265
 266                 case TARGET_TEXT_PLAIN:
 267                 default:
 268                         gtk_selection_data_set_text(selection_data, ee->key, -1);
 269                         break;
 270                 }
 271
 272 }
 273
 274 static void bar_pane_exif_dnd_receive(GtkWidget *pane, GdkDragContext *context,
 275                                           gint x, gint y,
 276                                           GtkSelectionData *selection_data, guint info,
 277                                           guint time, gpointer data)
 278 {
 279         PaneExifData *ped;
 280         GList *work, *list;
 281         gint pos;
 282         GtkWidget *new_entry = NULL;
 283         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 284         if (!ped) return;
 285
 286         switch (info)
 287                 {
 288                 case TARGET_APP_EXIF_ENTRY:
 289                         new_entry = *(gpointer *)selection_data->data;
 290
 291                         if (new_entry->parent && new_entry->parent != ped->vbox) bar_pane_exif_reparent_entry(new_entry, pane);
 292
 293                         break;
 294                 default:
 295                         /* FIXME: this needs a check for valid exif keys */
 296                         new_entry = bar_pane_exif_add_entry(ped, (gchar *)selection_data->data, NULL, TRUE);
 297                         break;
 298                 }
 299
 300
 301         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 302         work = list;
 303         pos = 0;
 304         while (work)
 305                 {
 306                 gint nx, ny;
 307                 GtkWidget *entry = work->data;
 308                 work = work->next;
 309
 310                 if (entry == new_entry) continue;
 311
 312                 if (GTK_WIDGET_DRAWABLE(entry) &&
 313                     gtk_widget_translate_coordinates(pane, entry, x, y, &nx, &ny) &&
 314                     ny < entry->allocation.height / 2) break;
 315                 pos++;
 316                 }
 317         g_list_free(list);
 318
 319         gtk_box_reorder_child(GTK_BOX(ped->vbox), new_entry, pos);
 320 }
 321
 322 static void bar_pane_exif_entry_dnd_begin(GtkWidget *widget, GdkDragContext *context, gpointer data)
 323 {
 324 //      gtk_drag_set_icon_default(context);
 325 }
 326
 327 static void bar_pane_exif_entry_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
 328 {
 329 }
 330
 331 static void bar_pane_exif_entry_dnd_init(GtkWidget *entry)
 332 {
 333         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 334
 335         gtk_drag_source_set(entry, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
 336                             bar_pane_exif_drag_types, n_exif_entry_drag_types,
 337                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
 338         g_signal_connect(G_OBJECT(entry), "drag_data_get",
 339                          G_CALLBACK(bar_pane_exif_entry_dnd_get), ee);
 340
 341         g_signal_connect(G_OBJECT(entry), "drag_begin",
 342                          G_CALLBACK(bar_pane_exif_entry_dnd_begin), ee);
 343         g_signal_connect(G_OBJECT(entry), "drag_end",
 344                          G_CALLBACK(bar_pane_exif_entry_dnd_end), ee);
 345 }
 346
 347 static void bar_pane_exif_dnd_init(GtkWidget *pane)
 348 {
 349         gtk_drag_dest_set(pane,
 350                           GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
 351                           bar_pane_exif_drop_types, n_exif_entry_drop_types,
 352                           GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_ASK);
 353         g_signal_connect(G_OBJECT(pane), "drag_data_received",
 354                          G_CALLBACK(bar_pane_exif_dnd_receive), NULL);
 355 }
 356
 357
 358 static void bar_pane_exif_edit_destroy_cb(GtkWidget *widget, gpointer data)
 359 {
 360         ConfDialogData *cdd = data;
 361         g_free(cdd);
 362 }
 363
 364 static void bar_pane_exif_edit_cancel_cb(GenericDialog *gd, gpointer data)
 365 {
 366 }
 367
 368 static void bar_pane_exif_edit_ok_cb(GenericDialog *gd, gpointer data)
 369 {
 370         ConfDialogData *cdd = data;
 371
 372         /* either one or the other */
 373         PaneExifData *ped = g_object_get_data(G_OBJECT(cdd->widget), "pane_data");
 374         ExifEntry *ee = g_object_get_data(G_OBJECT(cdd->widget), "entry_data");
 375
 376         if (ped)
 377                 {
 378                 bar_pane_exif_add_entry(ped,
 379                                         gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)),
 380                                         gtk_entry_get_text(GTK_ENTRY(cdd->title_entry)),
 381                                         cdd->if_set);
 382                 }
 383         if (ee)
 384                 {
 385                 const gchar *title;
 386                 GtkWidget *pane = cdd->widget->parent;
 387                 while (pane)
 388                         {
 389                         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 390                         if (ped) break;
 391                         pane = pane->parent;
 392                         }
 393
 394                 if (!pane) return;
 395
 396                 g_free(ee->key);
 397                 ee->key = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)));
 398                 title = gtk_entry_get_text(GTK_ENTRY(cdd->title_entry));
 399                 if (strcmp(ee->title, title) != 0)
 400                         {
 401                         g_free(ee->title);
 402                         ee->title = g_strdup(title);
 403                         ee->auto_title = FALSE;
 404                         }
 405
 406                 ee->if_set = cdd->if_set;
 407
 408                 bar_pane_exif_entry_update_title(ee);
 409                 bar_pane_exif_update(ped);
 410                 }
 411 }
 412
 413 static void bar_pane_exif_conf_dialog(GtkWidget *widget)
 414 {
 415         ConfDialogData *cdd;
 416         GenericDialog *gd;
 417         GtkWidget *table;
 418
 419         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 420            we can decide it by the attached data */
 421         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 422
 423         cdd = g_new0(ConfDialogData, 1);
 424
 425         cdd->widget = widget;
 426
 427
 428         cdd->if_set = ee ? ee->if_set : TRUE;
 429
 430         gd = generic_dialog_new(ee ? _("Configure entry") : _("Add entry"), "exif_entry_edit",
 431                                 widget, TRUE,
 432                                 bar_pane_exif_edit_cancel_cb, cdd);
 433         g_signal_connect(G_OBJECT(gd->dialog), "destroy",
 434                          G_CALLBACK(bar_pane_exif_edit_destroy_cb), cdd);
 435
 436         generic_dialog_add_message(gd, NULL, ee ? _("Configure entry") : _("Add entry"), NULL);
 437
 438         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
 439                                   bar_pane_exif_edit_ok_cb, TRUE);
 440
 441         table = pref_table_new(gd->vbox, 3, 2, FALSE, TRUE);
 442         pref_table_label(table, 0, 0, _("Key:"), 1.0);
 443
 444         cdd->key_entry = gtk_entry_new();
 445         gtk_widget_set_size_request(cdd->key_entry, 300, -1);
 446         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->key_entry), ee->key);
 447         gtk_table_attach_defaults(GTK_TABLE(table), cdd->key_entry, 1, 2, 0, 1);
 448         generic_dialog_attach_default(gd, cdd->key_entry);
 449         gtk_widget_show(cdd->key_entry);
 450
 451         pref_table_label(table, 0, 1, _("Title:"), 1.0);
 452
 453         cdd->title_entry = gtk_entry_new();
 454         gtk_widget_set_size_request(cdd->title_entry, 300, -1);
 455         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->title_entry), ee->title);
 456         gtk_table_attach_defaults(GTK_TABLE(table), cdd->title_entry, 1, 2, 1, 2);
 457         generic_dialog_attach_default(gd, cdd->title_entry);
 458         gtk_widget_show(cdd->title_entry);
 459
 460         pref_checkbox_new_int(gd->vbox, _("Show only if set"), cdd->if_set, &cdd->if_set);
 461
 462         gtk_widget_show(gd->dialog);
 463 }
 464
 465 static void bar_pane_exif_conf_dialog_cb(GtkWidget *menu_widget, gpointer data)
 466 {
 467         GtkWidget *widget = data;
 468         bar_pane_exif_conf_dialog(widget);
 469 }
 470
 471 static void bar_pane_exif_delete_entry_cb(GtkWidget *menu_widget, gpointer data)
 472 {
 473         GtkWidget *entry = data;
 474         gtk_widget_destroy(entry);
 475 }
 476
 477 static void bar_pane_exif_toggle_show_all_cb(GtkWidget *menu_widget, gpointer data)
 478 {
 479         PaneExifData *ped = data;
 480         ped->show_all = !ped->show_all;
 481         bar_pane_exif_update(ped);
 482 }
 483
 484 static void bar_pane_exif_menu_popup(GtkWidget *widget, PaneExifData *ped)
 485 {
 486         GtkWidget *menu;
 487         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 488            we can decide it by the attached data */
 489         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 490
 491         menu = popup_menu_short_lived();
 492
 493         if (ee)
 494                 {
 495                 /* for the entry */
 496                 gchar *conf = g_strdup_printf(_("Configure \"%s\""), ee->title);
 497                 gchar *del = g_strdup_printf(_("Delete \"%s\""), ee->title);
 498                 menu_item_add_stock(menu, conf, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_exif_conf_dialog_cb), widget);
 499                 menu_item_add_stock(menu, del, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_exif_delete_entry_cb), widget);
 500                 menu_item_add_divider(menu);
 501                 g_free(conf);
 502                 g_free(del);
 503                 }
 504         /* for the pane */
 505         menu_item_add_stock(menu, _("Add entry"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_exif_conf_dialog_cb), ped->widget);
 506         menu_item_add_check(menu, _("Show hidden entries"), ped->show_all, G_CALLBACK(bar_pane_exif_toggle_show_all_cb), ped);
 507
 508         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
 509 }
 510
 511
 512 static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
 513 {
 514         PaneExifData *ped = data;
 515         if (bevent->button == MOUSE_BUTTON_RIGHT)
 516                 {
 517                 bar_pane_exif_menu_popup(widget, ped);
 518                 return TRUE;
 519                 }
 520         return FALSE;
 521 }
 522
 523
 524
 525
 526 static void bar_pane_exif_entry_write_config(GtkWidget *entry, GString *outstr, gint indent)
 527 {
 528         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 529         if (!ee) return;
 530
 531         WRITE_STRING("<entry\n");
 532         indent++;
 533         WRITE_CHAR(*ee, key);
 534         if (!ee->auto_title) WRITE_CHAR(*ee, title);
 535         WRITE_BOOL(*ee, if_set);
 536         indent--;
 537         WRITE_STRING("/>\n");
 538 }
 539
 540 static void bar_pane_exif_write_config(GtkWidget *pane, GString *outstr, gint indent)
 541 {
 542         PaneExifData *ped;
 543         GList *work, *list;
 544
 545         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 546         if (!ped) return;
 547
 548         WRITE_STRING("<pane_exif\n");
 549         indent++;
 550         write_char_option(outstr, indent, "pane.title", gtk_label_get_text(GTK_LABEL(ped->pane.title)));
 551         WRITE_BOOL(*ped, pane.expanded);
 552         indent--;
 553         WRITE_STRING(">\n");
 554         indent++;
 555
 556         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 557         work = list;
 558         while (work)
 559                 {
 560                 GtkWidget *entry = work->data;
 561                 work = work->next;
 562
 563                 bar_pane_exif_entry_write_config(entry, outstr, indent);
 564                 }
 565         g_list_free(list);
 566         indent--;
 567         WRITE_STRING("</pane_exif>\n");
 568 }
 569
 570
 571 void bar_pane_exif_close(GtkWidget *widget)
 572 {
 573         PaneExifData *ped;
 574
 575         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 576         if (!ped) return;
 577
 578         gtk_widget_destroy(ped->vbox);
 579 }
 580
 581 static void bar_pane_exif_destroy(GtkWidget *widget, gpointer data)
 582 {
 583         PaneExifData *ped = data;
 584
 585         g_object_unref(ped->size_group);
 586         file_data_unref(ped->fd);
 587         g_free(ped);
 588 }
 589
 590 static void bar_pane_exif_size_request(GtkWidget *pane, GtkRequisition *requisition, gpointer data)
 591 {
 592         PaneExifData *ped = data;
 593         if (requisition->height < ped->min_height)
 594                 {
 595                 requisition->height = ped->min_height;
 596                 }
 597 }
 598
 599 static void bar_pane_exif_size_allocate(GtkWidget *pane, GtkAllocation *alloc, gpointer data)
 600 {
 601         PaneExifData *ped = data;
 602         ped->min_height = alloc->height;
 603 }
 604
 605 GtkWidget *bar_pane_exif_new(const gchar *title, gboolean expanded, gboolean populate)
 606 {
 607         PaneExifData *ped;
 608
 609         ped = g_new0(PaneExifData, 1);
 610
 611         ped->pane.pane_set_fd = bar_pane_exif_set_fd;
 612         ped->pane.pane_write_config = bar_pane_exif_write_config;
 613         ped->pane.title = gtk_label_new(title);
 614         ped->pane.expanded = expanded;
 615
 616         ped->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 617         ped->widget = gtk_event_box_new();;
 618         ped->vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
 619         gtk_container_add(GTK_CONTAINER(ped->widget), ped->vbox);
 620         gtk_widget_show(ped->vbox);
 621
 622         ped->min_height = MIN_HEIGHT;
 623         g_object_set_data(G_OBJECT(ped->widget), "pane_data", ped);
 624         g_signal_connect_after(G_OBJECT(ped->widget), "destroy",
 625                                G_CALLBACK(bar_pane_exif_destroy), ped);
 626         g_signal_connect(G_OBJECT(ped->widget), "size-request",
 627                          G_CALLBACK(bar_pane_exif_size_request), ped);
 628         g_signal_connect(G_OBJECT(ped->widget), "size-allocate",
 629                          G_CALLBACK(bar_pane_exif_size_allocate), ped);
 630
 631         bar_pane_exif_dnd_init(ped->widget);
 632         g_signal_connect(ped->widget, "button_press_event", G_CALLBACK(bar_pane_exif_menu_cb), ped);
 633
 634         if (populate)
 635                 {
 636                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Camera"), NULL, TRUE);
 637                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("DateTime"), NULL, TRUE);
 638                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ShutterSpeed"), NULL, TRUE);
 639                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Aperture"), NULL, TRUE);
 640                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ExposureBias"), NULL, TRUE);
 641                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ISOSpeedRating"), NULL, TRUE);
 642                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("FocalLength"), NULL, TRUE);
 643                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("FocalLength35mmFilm"), NULL, TRUE);
 644                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Flash"), NULL, TRUE);
 645                 bar_pane_exif_add_entry(ped, "Exif.Photo.ExposureProgram", NULL, TRUE);
 646                 bar_pane_exif_add_entry(ped, "Exif.Photo.MeteringMode", NULL, TRUE);
 647                 bar_pane_exif_add_entry(ped, "Exif.Photo.LightSource", NULL, TRUE);
 648                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("ColorProfile"), NULL, TRUE);
 649                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("SubjectDistance"), NULL, TRUE);
 650                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("Resolution"), NULL, TRUE);
 651                 bar_pane_exif_add_entry(ped, "Exif.Image.Orientation", NULL, TRUE);
 652                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("GPSPosition"), NULL, TRUE);
 653                 bar_pane_exif_add_entry(ped, EXIF_FORMATTED("GPSAltitude"), NULL, TRUE);
 654                 bar_pane_exif_add_entry(ped, "Exif.Image.ImageDescription", NULL, TRUE);
 655                 bar_pane_exif_add_entry(ped, "Exif.Image.Copyright", NULL, TRUE);
 656                 }
 657
 658         gtk_widget_show(ped->widget);
 659
 660         return ped->widget;
 661 }
 662
 663 GtkWidget *bar_pane_exif_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
 664 {
 665         gchar *title = g_strdup(_("NoName"));
 666         gboolean expanded = TRUE;
 667
 668         while (*attribute_names)
 669                 {
 670                 const gchar *option = *attribute_names++;
 671                 const gchar *value = *attribute_values++;
 672
 673                 if (READ_CHAR_FULL("pane.title", title)) continue;
 674                 if (READ_BOOL_FULL("pane.expanded", expanded)) continue;
 675
 676
 677                 DEBUG_1("unknown attribute %s = %s", option, value);
 678                 }
 679
 680         return bar_pane_exif_new(title, expanded, FALSE);
 681 }
 682
 683 void bar_pane_exif_entry_add_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
 684 {
 685         PaneExifData *ped;
 686         gchar *key = NULL;
 687         gchar *title = NULL;
 688         gboolean if_set = TRUE;
 689
 690         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 691         if (!ped) return;
 692
 693         while (*attribute_names)
 694                 {
 695                 const gchar *option = *attribute_names++;
 696                 const gchar *value = *attribute_values++;
 697
 698                 if (READ_CHAR_FULL("key", key)) continue;
 699                 if (READ_CHAR_FULL("title", title)) continue;
 700                 if (READ_BOOL_FULL("if_set", if_set)) continue;
 701
 702
 703                 DEBUG_1("unknown attribute %s = %s", option, value);
 704                 }
 705         if (key && key[0]) bar_pane_exif_add_entry(ped, key, title, if_set);
 706 }
 707
 708
 709 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */