src/bar_exif.c

   1 /*
   2  * Copyright (C) 2004 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: Vladimir Nadvornik
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "main.h"
  23 #include "bar_exif.h"
  24
  25 #include "exif.h"
  26 #include "metadata.h"
  27 #include "filedata.h"
  28 #include "history_list.h"
  29 #include "misc.h"
  30 #include "ui_misc.h"
  31 #include "ui_menu.h"
  32 #include "bar.h"
  33 #include "rcfile.h"
  34 #include "dnd.h"
  35 #include "ui_utildlg.h"
  36
  37
  38 #include <math.h>
  39
  40 #define MIN_HEIGHT 25
  41 /*
  42  *-------------------------------------------------------------------
  43  * EXIF widget
  44  *-------------------------------------------------------------------
  45  */
  46
  47 typedef struct _ExifEntry ExifEntry;
  48 typedef struct _PaneExifData PaneExifData;
  49
  50 struct _ExifEntry
  51 {
  52         GtkWidget *ebox;
  53         GtkWidget *box;
  54         GtkWidget *title_label;
  55         GtkWidget *value_widget;
  56
  57         gchar *key;
  58         gchar *title;
  59         gboolean if_set;
  60         gboolean auto_title;
  61         gboolean editable;
  62
  63         PaneExifData *ped;
  64 };
  65
  66
  67 struct _PaneExifData
  68 {
  69         PaneData pane;
  70         GtkWidget *vbox;
  71         GtkWidget *widget;
  72         GtkSizeGroup *size_group;
  73
  74         gint min_height;
  75
  76         gboolean all_hidden;
  77         gboolean show_all;
  78
  79         FileData *fd;
  80 };
  81
  82 typedef struct _ConfDialogData ConfDialogData;
  83 struct _ConfDialogData
  84 {
  85         GtkWidget *widget; /* pane or entry, devidet by presenceof "pane_data" or "entry_data" */
  86
  87         /* dialog parts */
  88         GenericDialog *gd;
  89         GtkWidget *key_entry;
  90         GtkWidget *title_entry;
  91         gboolean if_set;
  92         gboolean editable;
  93 };
  94
  95 static void bar_pane_exif_entry_dnd_init(GtkWidget *entry);
  96 static void bar_pane_exif_entry_update_title(ExifEntry *ee);
  97 static void bar_pane_exif_update(PaneExifData *ped);
  98 static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data);
  99 static void bar_pane_exif_notify_cb(FileData *fd, NotifyType type, gpointer data);
 100
 101
 102 static void bar_pane_exif_entry_changed(GtkEntry *text_entry, gpointer data)
 103 {
 104         ExifEntry *ee = data;
 105         gchar *text;
 106         if (!ee->ped->fd) return;
 107
 108         text = text_widget_text_pull(ee->value_widget);
 109         metadata_write_string(ee->ped->fd, ee->key, text);
 110         g_free(text);
 111 }
 112
 113 static void bar_pane_exif_entry_destroy(GtkWidget *widget, gpointer data)
 114 {
 115         ExifEntry *ee = data;
 116
 117         g_free(ee->key);
 118         g_free(ee->title);
 119         g_free(ee);
 120 }
 121
 122 static void bar_pane_exif_setup_entry_box(PaneExifData *ped, ExifEntry *ee)
 123 {
 124         gboolean horizontal = !ee->editable;
 125         gboolean editable = ee->editable;
 126
 127         if (ee->box) gtk_widget_destroy(ee->box);
 128
 129         ee->box = horizontal ? gtk_hbox_new(FALSE, 0) : gtk_vbox_new(FALSE, 0);
 130         gtk_container_add(GTK_CONTAINER(ee->ebox), ee->box);
 131         gtk_widget_show(ee->box);
 132
 133         ee->title_label = gtk_label_new(NULL);
 134         gtk_misc_set_alignment(GTK_MISC(ee->title_label), horizontal ? 1.0 : 0.0, 0.5);
 135         gtk_size_group_add_widget(ped->size_group, ee->title_label);
 136         gtk_box_pack_start(GTK_BOX(ee->box), ee->title_label, FALSE, TRUE, 0);
 137         gtk_widget_show(ee->title_label);
 138
 139         if (editable)
 140                 {
 141                 ee->value_widget = gtk_entry_new();
 142                 g_signal_connect(G_OBJECT(ee->value_widget), "changed",
 143                          G_CALLBACK(bar_pane_exif_entry_changed), ee);
 144
 145                 }
 146         else
 147                 {
 148                 ee->value_widget = gtk_label_new(NULL);
 149 //              gtk_label_set_width_chars(GTK_LABEL(ee->value_widget), 20);
 150                 gtk_label_set_ellipsize(GTK_LABEL(ee->value_widget), PANGO_ELLIPSIZE_END);
 151 //              gtk_widget_set_size_request(ee->value_widget, 100, -1);
 152                 gtk_misc_set_alignment(GTK_MISC(ee->value_widget), 0.0, 0.5);
 153                 }
 154
 155         gtk_box_pack_start(GTK_BOX(ee->box), ee->value_widget, TRUE, TRUE, 1);
 156         gtk_widget_show(ee->value_widget);
 157 }
 158
 159 static GtkWidget *bar_pane_exif_add_entry(PaneExifData *ped, const gchar *key, const gchar *title, gboolean if_set, gboolean editable)
 160 {
 161         ExifEntry *ee = g_new0(ExifEntry, 1);
 162
 163         ee->key = g_strdup(key);
 164         if (title && title[0])
 165                 {
 166                 ee->title = g_strdup(title);
 167                 }
 168         else
 169                 {
 170                 ee->title = exif_get_description_by_key(key);
 171                 ee->auto_title = TRUE;
 172                 }
 173
 174         ee->if_set = if_set;
 175         ee->editable = editable;
 176
 177         ee->ped = ped;
 178
 179         ee->ebox = gtk_event_box_new();
 180         g_object_set_data(G_OBJECT(ee->ebox), "entry_data", ee);
 181         g_signal_connect_after(G_OBJECT(ee->ebox), "destroy",
 182                                G_CALLBACK(bar_pane_exif_entry_destroy), ee);
 183
 184         gtk_box_pack_start(GTK_BOX(ped->vbox), ee->ebox, FALSE, FALSE, 0);
 185
 186         bar_pane_exif_entry_dnd_init(ee->ebox);
 187         g_signal_connect(ee->ebox, "button_release_event", G_CALLBACK(bar_pane_exif_menu_cb), ped);
 188
 189         bar_pane_exif_setup_entry_box(ped, ee);
 190
 191         bar_pane_exif_entry_update_title(ee);
 192         bar_pane_exif_update(ped);
 193
 194         return ee->ebox;
 195 }
 196
 197 static void bar_pane_exif_reparent_entry(GtkWidget *entry, GtkWidget *pane)
 198 {
 199         PaneExifData *ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 200         PaneExifData *old_ped;
 201         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 202
 203         if (!ped || !ee) return;
 204
 205         old_ped = ee->ped;
 206
 207         g_object_ref(entry);
 208
 209         gtk_size_group_remove_widget(old_ped->size_group, ee->title_label);
 210         gtk_container_remove(GTK_CONTAINER(old_ped->vbox), entry);
 211
 212         ee->ped = ped;
 213         gtk_size_group_add_widget(ped->size_group, ee->title_label);
 214         gtk_box_pack_start(GTK_BOX(ped->vbox), entry, FALSE, FALSE, 0);
 215 }
 216
 217 static void bar_pane_exif_entry_update_title(ExifEntry *ee)
 218 {
 219         gchar *markup;
 220
 221         markup = g_markup_printf_escaped("<span size='small'>%s:</span>", (ee->title) ? ee->title : _("<empty label, fixme>"));
 222         gtk_label_set_markup(GTK_LABEL(ee->title_label), markup);
 223         g_free(markup);
 224 }
 225
 226 static void bar_pane_exif_update_entry(PaneExifData *ped, GtkWidget *entry, gboolean update_title)
 227 {
 228         gchar *text;
 229         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 230
 231         if (!ee) return;
 232         text = metadata_read_string(ped->fd, ee->key, ee->editable ? METADATA_PLAIN : METADATA_FORMATTED);
 233
 234         if (!ped->show_all && ee->if_set && !ee->editable && (!text || !*text))
 235                 {
 236                 gtk_label_set_text(GTK_LABEL(ee->value_widget), NULL);
 237                 gtk_widget_hide(entry);
 238                 }
 239         else
 240                 {
 241                 if (ee->editable)
 242                         {
 243                         g_signal_handlers_block_by_func(ee->value_widget, bar_pane_exif_entry_changed, ee);
 244                         gtk_entry_set_text(GTK_ENTRY(ee->value_widget), text ? text : "");
 245                         g_signal_handlers_unblock_by_func(ee->value_widget, bar_pane_exif_entry_changed, ee);
 246                         gtk_widget_set_tooltip_text(ee->box, NULL);
 247                         }
 248                 else
 249                         {
 250                         gtk_label_set_text(GTK_LABEL(ee->value_widget), text);
 251                         gtk_widget_set_tooltip_text(ee->box, text);
 252                         }
 253                 gtk_widget_show(entry);
 254                 ped->all_hidden = FALSE;
 255                 }
 256
 257         g_free(text);
 258
 259         if (update_title) bar_pane_exif_entry_update_title(ee);
 260 }
 261
 262 static void bar_pane_exif_update(PaneExifData *ped)
 263 {
 264         GList *list, *work;
 265
 266         ped->all_hidden = TRUE;
 267
 268         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 269         work = list;
 270         while (work)
 271                 {
 272                 GtkWidget *entry = work->data;
 273                 work = work->next;
 274
 275                 bar_pane_exif_update_entry(ped, entry, FALSE);
 276                 }
 277         g_list_free(list);
 278
 279         gtk_widget_set_sensitive(ped->pane.title, !ped->all_hidden);
 280 }
 281
 282 void bar_pane_exif_set_fd(GtkWidget *widget, FileData *fd)
 283 {
 284         PaneExifData *ped;
 285
 286         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 287         if (!ped) return;
 288
 289         file_data_unref(ped->fd);
 290         ped->fd = file_data_ref(fd);
 291
 292         bar_pane_exif_update(ped);
 293 }
 294
 295 gint bar_pane_exif_event(GtkWidget *bar, GdkEvent *event)
 296 {
 297         PaneExifData *ped;
 298         gboolean ret = FALSE;
 299         GList *list, *work;
 300
 301         ped = g_object_get_data(G_OBJECT(bar), "pane_data");
 302         if (!ped) return FALSE;
 303
 304         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 305         work = list;
 306         while (!ret && work)
 307                 {
 308                 GtkWidget *entry = work->data;
 309                 ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 310                 work = work->next;
 311
 312                 if (ee->editable && gtk_widget_has_focus(ee->value_widget)) ret = gtk_widget_event(ee->value_widget, event);
 313                 }
 314         g_list_free(list);
 315         return ret;
 316 }
 317
 318 static void bar_pane_exif_notify_cb(FileData *fd, NotifyType type, gpointer data)
 319 {
 320         PaneExifData *ped = data;
 321         if ((type & (NOTIFY_REREAD | NOTIFY_CHANGE | NOTIFY_METADATA)) && fd == ped->fd)
 322                 {
 323                 DEBUG_1("Notify pane_exif: %s %04x", fd->path, type);
 324                 bar_pane_exif_update(ped);
 325                 }
 326 }
 327
 328
 329 /*
 330  *-------------------------------------------------------------------
 331  * dnd
 332  *-------------------------------------------------------------------
 333  */
 334
 335 static GtkTargetEntry bar_pane_exif_drag_types[] = {
 336         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 337         { "text/plain", 0, TARGET_TEXT_PLAIN }
 338 };
 339 static gint n_exif_entry_drag_types = 2;
 340
 341 static GtkTargetEntry bar_pane_exif_drop_types[] = {
 342         { TARGET_APP_EXIF_ENTRY_STRING, GTK_TARGET_SAME_APP, TARGET_APP_EXIF_ENTRY },
 343         { "text/plain", 0, TARGET_TEXT_PLAIN }
 344 };
 345 static gint n_exif_entry_drop_types = 2;
 346
 347
 348 static void bar_pane_exif_entry_dnd_get(GtkWidget *entry, GdkDragContext *context,
 349                                      GtkSelectionData *selection_data, guint info,
 350                                      guint time, gpointer data)
 351 {
 352         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 353
 354         switch (info)
 355                 {
 356                 case TARGET_APP_EXIF_ENTRY:
 357                         gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
 358                                                8, (gpointer) &entry, sizeof(entry));
 359                         break;
 360
 361                 case TARGET_TEXT_PLAIN:
 362                 default:
 363                         gtk_selection_data_set_text(selection_data, ee->key, -1);
 364                         break;
 365                 }
 366
 367 }
 368
 369 static void bar_pane_exif_dnd_receive(GtkWidget *pane, GdkDragContext *context,
 370                                           gint x, gint y,
 371                                           GtkSelectionData *selection_data, guint info,
 372                                           guint time, gpointer data)
 373 {
 374         PaneExifData *ped;
 375         GList *work, *list;
 376         gint pos;
 377         GtkWidget *new_entry = NULL;
 378
 379         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 380         if (!ped) return;
 381
 382         switch (info)
 383                 {
 384                 case TARGET_APP_EXIF_ENTRY:
 385                         new_entry = *(gpointer *)gtk_selection_data_get_data(selection_data);
 386
 387                         if (gtk_widget_get_parent(new_entry) && gtk_widget_get_parent(new_entry) != ped->vbox) bar_pane_exif_reparent_entry(new_entry, pane);
 388
 389                         break;
 390                 default:
 391                         /* FIXME: this needs a check for valid exif keys */
 392                         new_entry = bar_pane_exif_add_entry(ped, (gchar *)gtk_selection_data_get_data(selection_data), NULL, TRUE, FALSE);
 393                         break;
 394                 }
 395
 396         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 397         work = list;
 398         pos = 0;
 399         while (work)
 400                 {
 401                 gint nx, ny;
 402                 GtkWidget *entry = work->data;
 403                 GtkAllocation allocation;
 404                 work = work->next;
 405
 406                 if (entry == new_entry) continue;
 407
 408                 gtk_widget_get_allocation(entry, &allocation);
 409
 410                 if (gtk_widget_is_drawable(entry) &&
 411                     gtk_widget_translate_coordinates(pane, entry, x, y, &nx, &ny) &&
 412                     ny < allocation.height / 2) break;
 413                 pos++;
 414                 }
 415         g_list_free(list);
 416
 417         gtk_box_reorder_child(GTK_BOX(ped->vbox), new_entry, pos);
 418 }
 419
 420 static void bar_pane_exif_entry_dnd_begin(GtkWidget *entry, GdkDragContext *context, gpointer data)
 421 {
 422         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 423
 424         if (!ee) return;
 425         dnd_set_drag_label(entry, context, ee->key);
 426 }
 427
 428 static void bar_pane_exif_entry_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
 429 {
 430 }
 431
 432 static void bar_pane_exif_entry_dnd_init(GtkWidget *entry)
 433 {
 434         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 435
 436         gtk_drag_source_set(entry, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
 437                             bar_pane_exif_drag_types, n_exif_entry_drag_types,
 438                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
 439         g_signal_connect(G_OBJECT(entry), "drag_data_get",
 440                          G_CALLBACK(bar_pane_exif_entry_dnd_get), ee);
 441
 442         g_signal_connect(G_OBJECT(entry), "drag_begin",
 443                          G_CALLBACK(bar_pane_exif_entry_dnd_begin), ee);
 444         g_signal_connect(G_OBJECT(entry), "drag_end",
 445                          G_CALLBACK(bar_pane_exif_entry_dnd_end), ee);
 446 }
 447
 448 static void bar_pane_exif_dnd_init(GtkWidget *pane)
 449 {
 450         gtk_drag_dest_set(pane,
 451                           GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
 452                           bar_pane_exif_drop_types, n_exif_entry_drop_types,
 453                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
 454         g_signal_connect(G_OBJECT(pane), "drag_data_received",
 455                          G_CALLBACK(bar_pane_exif_dnd_receive), NULL);
 456 }
 457
 458 static void bar_pane_exif_edit_close_cb(GtkWidget *widget, gpointer data)
 459 {
 460         GenericDialog *gd = data;
 461         generic_dialog_close(gd);
 462 }
 463
 464 static void bar_pane_exif_edit_destroy_cb(GtkWidget *widget, gpointer data)
 465 {
 466         ConfDialogData *cdd = data;
 467         g_signal_handlers_disconnect_by_func(cdd->widget, G_CALLBACK(bar_pane_exif_edit_close_cb), cdd->gd);
 468         g_free(cdd);
 469 }
 470
 471 static void bar_pane_exif_edit_cancel_cb(GenericDialog *gd, gpointer data)
 472 {
 473 }
 474
 475 static void bar_pane_exif_edit_ok_cb(GenericDialog *gd, gpointer data)
 476 {
 477         ConfDialogData *cdd = data;
 478
 479         /* either one or the other */
 480         PaneExifData *ped = g_object_get_data(G_OBJECT(cdd->widget), "pane_data");
 481         ExifEntry *ee = g_object_get_data(G_OBJECT(cdd->widget), "entry_data");
 482
 483         if (ped)
 484                 {
 485                 bar_pane_exif_add_entry(ped,
 486                                         gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)),
 487                                         gtk_entry_get_text(GTK_ENTRY(cdd->title_entry)),
 488                                         cdd->if_set, cdd->editable);
 489                 }
 490
 491         if (ee)
 492                 {
 493                 const gchar *title;
 494                 GtkWidget *pane = gtk_widget_get_parent(cdd->widget);
 495
 496                 while (pane)
 497                         {
 498                         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 499                         if (ped) break;
 500                         pane = gtk_widget_get_parent(pane);
 501                         }
 502
 503                 if (!pane) return;
 504
 505                 g_free(ee->key);
 506                 ee->key = g_strdup(gtk_entry_get_text(GTK_ENTRY(cdd->key_entry)));
 507                 title = gtk_entry_get_text(GTK_ENTRY(cdd->title_entry));
 508                 if (!title || strlen(title) == 0)
 509                         {
 510                         g_free(ee->title);
 511                         ee->title = exif_get_description_by_key(ee->key);
 512                         ee->auto_title = TRUE;
 513                         }
 514                 else if (!ee->title || strcmp(ee->title, title) != 0)
 515                         {
 516                         g_free(ee->title);
 517                         ee->title = g_strdup(title);
 518                         ee->auto_title = FALSE;
 519                         }
 520
 521                 ee->if_set = cdd->if_set;
 522                 ee->editable = cdd->editable;
 523
 524                 bar_pane_exif_setup_entry_box(ped, ee);
 525
 526                 bar_pane_exif_entry_update_title(ee);
 527                 bar_pane_exif_update(ped);
 528                 }
 529 }
 530
 531 static void bar_pane_exif_conf_dialog(GtkWidget *widget)
 532 {
 533         ConfDialogData *cdd;
 534         GenericDialog *gd;
 535         GtkWidget *table;
 536
 537         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 538            we can decide it by the attached data */
 539         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 540
 541         cdd = g_new0(ConfDialogData, 1);
 542
 543         cdd->widget = widget;
 544
 545
 546         cdd->if_set = ee ? ee->if_set : TRUE;
 547         cdd->editable = ee ? ee->editable : FALSE;
 548
 549         cdd->gd = gd = generic_dialog_new(ee ? _("Configure entry") : _("Add entry"), "exif_entry_edit",
 550                                 widget, TRUE,
 551                                 bar_pane_exif_edit_cancel_cb, cdd);
 552         g_signal_connect(G_OBJECT(gd->dialog), "destroy",
 553                          G_CALLBACK(bar_pane_exif_edit_destroy_cb), cdd);
 554
 555         /* in case the entry is deleted during editing */
 556         g_signal_connect(G_OBJECT(widget), "destroy",
 557                          G_CALLBACK(bar_pane_exif_edit_close_cb), gd);
 558
 559         generic_dialog_add_message(gd, NULL, ee ? _("Configure entry") : _("Add entry"), NULL);
 560
 561         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
 562                                   bar_pane_exif_edit_ok_cb, TRUE);
 563
 564         table = pref_table_new(gd->vbox, 3, 2, FALSE, TRUE);
 565         pref_table_label(table, 0, 0, _("Key:"), 1.0);
 566
 567         cdd->key_entry = gtk_entry_new();
 568         gtk_widget_set_size_request(cdd->key_entry, 300, -1);
 569         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->key_entry), ee->key);
 570         gtk_table_attach_defaults(GTK_TABLE(table), cdd->key_entry, 1, 2, 0, 1);
 571         generic_dialog_attach_default(gd, cdd->key_entry);
 572         gtk_widget_show(cdd->key_entry);
 573
 574         pref_table_label(table, 0, 1, _("Title:"), 1.0);
 575
 576         cdd->title_entry = gtk_entry_new();
 577         gtk_widget_set_size_request(cdd->title_entry, 300, -1);
 578         if (ee) gtk_entry_set_text(GTK_ENTRY(cdd->title_entry), ee->title);
 579         gtk_table_attach_defaults(GTK_TABLE(table), cdd->title_entry, 1, 2, 1, 2);
 580         generic_dialog_attach_default(gd, cdd->title_entry);
 581         gtk_widget_show(cdd->title_entry);
 582
 583         pref_checkbox_new_int(gd->vbox, _("Show only if set"), cdd->if_set, &cdd->if_set);
 584         pref_checkbox_new_int(gd->vbox, _("Editable (supported only for XMP)"), cdd->editable, &cdd->editable);
 585
 586         gtk_widget_show(gd->dialog);
 587 }
 588
 589 static void bar_pane_exif_conf_dialog_cb(GtkWidget *menu_widget, gpointer data)
 590 {
 591         GtkWidget *widget = data;
 592         bar_pane_exif_conf_dialog(widget);
 593 }
 594
 595 static void bar_pane_exif_delete_entry_cb(GtkWidget *menu_widget, gpointer data)
 596 {
 597         GtkWidget *entry = data;
 598         gtk_widget_destroy(entry);
 599 }
 600
 601 static void bar_pane_exif_toggle_show_all_cb(GtkWidget *menu_widget, gpointer data)
 602 {
 603         PaneExifData *ped = data;
 604         ped->show_all = !ped->show_all;
 605         bar_pane_exif_update(ped);
 606 }
 607
 608 static void bar_pane_exif_menu_popup(GtkWidget *widget, PaneExifData *ped)
 609 {
 610         GtkWidget *menu;
 611         /* the widget can be either ExifEntry (for editing) or Pane (for new entry)
 612            we can decide it by the attached data */
 613         ExifEntry *ee = g_object_get_data(G_OBJECT(widget), "entry_data");
 614
 615         menu = popup_menu_short_lived();
 616
 617         if (ee)
 618                 {
 619                 /* for the entry */
 620                 gchar *conf = g_strdup_printf(_("Configure \"%s\""), ee->title);
 621                 gchar *del = g_strdup_printf(_("Remove \"%s\""), ee->title);
 622
 623                 menu_item_add_stock(menu, conf, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_exif_conf_dialog_cb), widget);
 624                 menu_item_add_stock(menu, del, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_exif_delete_entry_cb), widget);
 625                 menu_item_add_divider(menu);
 626
 627                 g_free(conf);
 628                 g_free(del);
 629                 }
 630
 631         /* for the pane */
 632         menu_item_add_stock(menu, _("Add entry"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_exif_conf_dialog_cb), ped->widget);
 633         menu_item_add_check(menu, _("Show hidden entries"), ped->show_all, G_CALLBACK(bar_pane_exif_toggle_show_all_cb), ped);
 634
 635         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
 636 }
 637
 638 static gboolean bar_pane_exif_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
 639 {
 640         PaneExifData *ped = data;
 641         if (bevent->button == MOUSE_BUTTON_RIGHT)
 642                 {
 643                 bar_pane_exif_menu_popup(widget, ped);
 644                 return TRUE;
 645                 }
 646         return FALSE;
 647 }
 648
 649
 650
 651 static void bar_pane_exif_entry_write_config(GtkWidget *entry, GString *outstr, gint indent)
 652 {
 653         ExifEntry *ee = g_object_get_data(G_OBJECT(entry), "entry_data");
 654         if (!ee) return;
 655
 656         WRITE_NL(); WRITE_STRING("<entry ");
 657         WRITE_CHAR(*ee, key);
 658         if (!ee->auto_title) WRITE_CHAR(*ee, title);
 659         WRITE_BOOL(*ee, if_set);
 660         WRITE_BOOL(*ee, editable);
 661         WRITE_STRING("/>");
 662 }
 663
 664 static void bar_pane_exif_write_config(GtkWidget *pane, GString *outstr, gint indent)
 665 {
 666         PaneExifData *ped;
 667         GList *work, *list;
 668
 669         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 670         if (!ped) return;
 671
 672         WRITE_NL(); WRITE_STRING("<pane_exif ");
 673         write_char_option(outstr, indent, "id", ped->pane.id);
 674         write_char_option(outstr, indent, "title", gtk_label_get_text(GTK_LABEL(ped->pane.title)));
 675         WRITE_BOOL(ped->pane, expanded);
 676         WRITE_STRING(">");
 677         indent++;
 678
 679         list = gtk_container_get_children(GTK_CONTAINER(ped->vbox));
 680         work = list;
 681         while (work)
 682                 {
 683                 GtkWidget *entry = work->data;
 684                 work = work->next;
 685
 686                 bar_pane_exif_entry_write_config(entry, outstr, indent);
 687                 }
 688         g_list_free(list);
 689         indent--;
 690         WRITE_NL(); WRITE_STRING("</pane_exif>");
 691 }
 692
 693
 694 void bar_pane_exif_close(GtkWidget *widget)
 695 {
 696         PaneExifData *ped;
 697
 698         ped = g_object_get_data(G_OBJECT(widget), "pane_data");
 699         if (!ped) return;
 700
 701         gtk_widget_destroy(ped->vbox);
 702 }
 703
 704 static void bar_pane_exif_destroy(GtkWidget *widget, gpointer data)
 705 {
 706         PaneExifData *ped = data;
 707
 708         file_data_unregister_notify_func(bar_pane_exif_notify_cb, ped);
 709         g_object_unref(ped->size_group);
 710         file_data_unref(ped->fd);
 711         g_free(ped->pane.id);
 712         g_free(ped);
 713 }
 714
 715 #if !GTK_CHECK_VERSION(3,0,0)
 716 static void bar_pane_exif_size_request(GtkWidget *pane, GtkRequisition *requisition, gpointer data)
 717 {
 718         PaneExifData *ped = data;
 719         if (requisition->height < ped->min_height)
 720                 {
 721                 requisition->height = ped->min_height;
 722                 }
 723 }
 724 #endif
 725
 726 static void bar_pane_exif_size_allocate(GtkWidget *pane, GtkAllocation *alloc, gpointer data)
 727 {
 728         PaneExifData *ped = data;
 729         ped->min_height = alloc->height;
 730 #if GTK_CHECK_VERSION(3,0,0)
 731         gtk_widget_set_size_request(ped->widget, -1, ped->min_height);
 732 #endif
 733 }
 734
 735 static GtkWidget *bar_pane_exif_new(const gchar *id, const gchar *title, gboolean expanded)
 736 {
 737         PaneExifData *ped;
 738
 739         ped = g_new0(PaneExifData, 1);
 740
 741         ped->pane.pane_set_fd = bar_pane_exif_set_fd;
 742         ped->pane.pane_write_config = bar_pane_exif_write_config;
 743         ped->pane.pane_event = bar_pane_exif_event;
 744         ped->pane.title = bar_pane_expander_title(title);
 745         ped->pane.id = g_strdup(id);
 746         ped->pane.expanded = expanded;
 747         ped->pane.type = PANE_EXIF;
 748
 749         ped->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 750         ped->widget = gtk_event_box_new();
 751         ped->vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
 752         gtk_container_add(GTK_CONTAINER(ped->widget), ped->vbox);
 753         gtk_widget_show(ped->vbox);
 754
 755         ped->min_height = MIN_HEIGHT;
 756         g_object_set_data(G_OBJECT(ped->widget), "pane_data", ped);
 757         g_signal_connect_after(G_OBJECT(ped->widget), "destroy",
 758                                G_CALLBACK(bar_pane_exif_destroy), ped);
 759 #if GTK_CHECK_VERSION(3,0,0)
 760         gtk_widget_set_size_request(ped->widget, -1, ped->min_height);
 761 #else
 762         g_signal_connect(G_OBJECT(ped->widget), "size-request",
 763                          G_CALLBACK(bar_pane_exif_size_request), ped);
 764 #endif
 765         g_signal_connect(G_OBJECT(ped->widget), "size-allocate",
 766                          G_CALLBACK(bar_pane_exif_size_allocate), ped);
 767
 768         bar_pane_exif_dnd_init(ped->widget);
 769         g_signal_connect(ped->widget, "button_release_event", G_CALLBACK(bar_pane_exif_menu_cb), ped);
 770
 771         file_data_register_notify_func(bar_pane_exif_notify_cb, ped, NOTIFY_PRIORITY_LOW);
 772
 773         gtk_widget_show(ped->widget);
 774
 775         return ped->widget;
 776 }
 777
 778 GtkWidget *bar_pane_exif_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
 779 {
 780         gchar *title = NULL;
 781         gchar *id = g_strdup("exif");
 782         gboolean expanded = TRUE;
 783         GtkWidget *ret;
 784
 785         while (*attribute_names)
 786                 {
 787                 const gchar *option = *attribute_names++;
 788                 const gchar *value = *attribute_values++;
 789
 790                 if (READ_CHAR_FULL("id", id)) continue;
 791                 if (READ_CHAR_FULL("title", title)) continue;
 792                 if (READ_BOOL_FULL("expanded", expanded)) continue;
 793
 794                 log_printf("unknown attribute %s = %s\n", option, value);
 795                 }
 796
 797         bar_pane_translate_title(PANE_EXIF, id, &title);
 798         ret = bar_pane_exif_new(id, title, expanded);
 799         g_free(title);
 800         g_free(id);
 801         return ret;
 802 }
 803
 804 void bar_pane_exif_update_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
 805 {
 806         PaneExifData *ped;
 807         gchar *title = NULL;
 808
 809         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 810         if (!ped) return;
 811
 812         while (*attribute_names)
 813                 {
 814                 const gchar *option = *attribute_names++;
 815                 const gchar *value = *attribute_values++;
 816
 817                 if (READ_CHAR_FULL("title", title)) continue;
 818                 if (READ_BOOL_FULL("expanded", ped->pane.expanded)) continue;
 819                 if (READ_CHAR_FULL("id", ped->pane.id)) continue;
 820
 821
 822                 log_printf("unknown attribute %s = %s\n", option, value);
 823                 }
 824
 825         if (title)
 826                 {
 827                 bar_pane_translate_title(PANE_EXIF, ped->pane.id, &title);
 828                 gtk_label_set_text(GTK_LABEL(ped->pane.title), title);
 829                 g_free(title);
 830                 }
 831
 832         bar_update_expander(pane);
 833         bar_pane_exif_update(ped);
 834 }
 835
 836
 837 void bar_pane_exif_entry_add_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
 838 {
 839         PaneExifData *ped;
 840         gchar *key = NULL;
 841         gchar *title = NULL;
 842         gboolean if_set = TRUE;
 843         gboolean editable = FALSE;
 844
 845         ped = g_object_get_data(G_OBJECT(pane), "pane_data");
 846         if (!ped) return;
 847
 848         while (*attribute_names)
 849                 {
 850                 const gchar *option = *attribute_names++;
 851                 const gchar *value = *attribute_values++;
 852
 853                 if (READ_CHAR_FULL("key", key)) continue;
 854                 if (READ_CHAR_FULL("title", title)) continue;
 855                 if (READ_BOOL_FULL("if_set", if_set)) continue;
 856                 if (READ_BOOL_FULL("editable", editable)) continue;
 857
 858                 log_printf("unknown attribute %s = %s\n", option, value);
 859                 }
 860
 861         if (key && key[0]) bar_pane_exif_add_entry(ped, key, title, if_set, editable);
 862 }
 863
 864
 865 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */