src/display.c

   1 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 c-style: "K&R" -*- */
   2
   3 /*----------------------------------------------------------------------
   4
   5 gpiv - Graphic program for Particle Image Velocimetry, based on gtk/gnome
   6   libraries.
   7
   8 Copyright (C) 2002, 2003, 2004 Gerber van der Graaf
   9
  10 This file is part of gpiv.
  11
  12 Gpiv is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 2, or (at your option)
  15 any later version.
  16
  17 This program is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with this program; if not, write to the Free Software Foundation,
  24 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25
  26 ----------------------------------------------------------------------*/
  27
  28 /*
  29 * (callback) functions for the display
  30 * $Log: display.c,v $
  31 * Revision 1.24  2007-12-19 08:42:35  gerber
  32 * debugged
  33 *
  34 * Revision 1.23  2007-11-23 16:24:07  gerber
  35 * release 0.5.0: Kafka
  36 *
  37 * Revision 1.22  2007-03-22 16:00:32  gerber
  38 * Added image processing tabulator
  39 *
  40 * Revision 1.21  2007/02/05 15:17:09  gerber
  41 * auto stretching, broadcast display settings to buffers from preferences
  42 *
  43 * Revision 1.20  2007-01-29 11:27:43  gerber
  44 * added image formats png, gif, tif png, bmp, improved buffer display
  45 *
  46 * Revision 1.19  2006/01/31 14:28:12  gerber
  47 * version 0.3.0
  48 *
  49 * Revision 1.18  2005/06/15 15:03:54  gerber
  50 * Optional Anti Aliased canvas for viewer
  51 *
  52 * Revision 1.17  2005/06/15 09:40:40  gerber
  53 * debugged, optimized
  54 *
  55 * Revision 1.16  2005/02/26 09:17:13  gerber
  56 * structured of interrogate function by using gpiv_piv_isiadapt
  57 *
  58 * Revision 1.15  2005/01/19 15:53:41  gerber
  59 * Initiation of Data Acquisition (DAC); trigerring of lasers and camera
  60 * by using RTAI and Realtime Linux, recording images from IEEE1394
  61 * (Firewire) IIDC compliant camera's
  62 *
  63 * Revision 1.14  2004/10/15 19:24:05  gerber
  64 * GPIV_ and Gpiv prefix to defines and structure names of libgpiv
  65 *
  66 * Revision 1.13  2004/06/14 21:19:23  gerber
  67 * Image depth up to 16 bits.
  68 * Improvement "single int" and "drag int" in Eval tab.
  69 * Viewer's pop-up menu.
  70 * Adaption for gpiv_matrix_* and gpiv_vector_*.
  71 * Resizing console.
  72 * See Changelog for further info.
  73 *
  74 * Revision 1.12  2003/09/01 11:17:14  gerber
  75 * improved monitoring of interrogation process
  76 *
  77 * Revision 1.11  2003/08/22 15:24:52  gerber
  78 * interactive spatial scaling
  79 *
  80 * Revision 1.10  2003/07/31 11:43:26  gerber
  81 * display images in gnome canvas (HOERAreset)
  82 *
  83 * Revision 1.9  2003/07/13 14:38:18  gerber
  84 * changed error handling of libgpiv
  85 *
  86 * Revision 1.8  2003/07/12 21:21:15  gerber
  87 * changed error handling libgpiv
  88 *
  89 * Revision 1.6  2003/07/10 11:56:07  gerber
  90 * added man page
  91 *
  92 * Revision 1.5  2003/07/05 13:14:57  gerber
  93 * drag and drop of a _series_ of filenames from NAUTILUS
  94 *
  95 * Revision 1.4  2003/07/04 10:47:00  gerber
  96 * cleaning up
  97 *
  98 * Revision 1.3  2003/07/03 17:08:02  gerber
  99 * display ruler adjusted for scaled data
 100 *
 101 * Revision 1.2  2003/06/27 13:47:26  gerber
 102 * display ruler, line/point evaluation
 103 *
 104 * Revision 1.1.1.1  2003/06/17 17:10:52  gerber
 105 * Imported gpiv
 106 *
 107 */
 108
 109 #include "gpiv_gui.h"
 110 #include "utils.h"
 111 #include "display_interface.h"
 112 #include "display.h"
 113 #include "display_event.h"
 114 #include "display_zoom.h"
 115 #include "piveval.h"
 116 #include "dialog_interface.h"
 117 #include "console.h"
 118
 119
 120 static void
 121 on_adj_changed__adapt_hcanvas (Display *disp
 122                                );
 123 static void
 124 on_adj_changed__adapt_vcanvas (Display *disp
 125                                );
 126 static void
 127 on_adj_changed__adapt_hruler (Display *disp
 128                               );
 129 static void
 130 on_adj_changed__adapt_vruler (Display *disp
 131                               );
 132
 133 static void
 134 synchronize_menu (GtkWidget *menu_src,
 135                   gboolean active,
 136                   GtkWidget *menu_dest
 137                   );
 138
 139 /*
 140  * Callback display functions
 141  */
 142 gint
 143 on_button_display_origin_press_event (GtkWidget *widget,
 144                                       GdkEventButton *event,
 145                                       gpointer data
 146                                       )
 147 /*-----------------------------------------------------------------------------
 148  */
 149 {
 150     gtk_menu_popup (GTK_MENU (display_act->display_popupmenu), NULL, NULL,
 151                     NULL, NULL, event->button, event->time);
 152     return FALSE;
 153 }
 154
 155
 156 void
 157 on_display_set_focus (GtkWidget *widget,
 158                       gpointer data
 159                       )
 160 /*-----------------------------------------------------------------------------
 161  */
 162 {
 163     Display *disp = gtk_object_get_data(GTK_OBJECT (widget), "disp");
 164     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 165     gint i = 0, row_selected = 0;
 166     gchar *text, labelno[GPIV_MAX_CHARS];
 167     gtk_clist_set_selection_mode (GTK_CLIST (gpiv->clist_buf),
 168                                   GTK_SELECTION_SINGLE);
 169
 170     g_snprintf (labelno, GPIV_MAX_CHARS,"%d", disp->id);
 171
 172
 173     for (i = 0; i < nbufs; i++) {
 174         gtk_clist_get_text (GTK_CLIST (gpiv->clist_buf), i, 0, &text);
 175
 176         if (strcmp(labelno, text) == 0) {
 177             row_selected = i;
 178         }
 179     }
 180
 181
 182     gtk_clist_select_row (GTK_CLIST (gpiv->clist_buf), row_selected, 0);
 183
 184 /* g_warning("on_display_set_focus:: disp->id=%d row_selected=%d",  */
 185 /* disp->id, row_selected); */
 186
 187     gtk_clist_set_selection_mode (GTK_CLIST (gpiv->clist_buf),
 188                                   GTK_SELECTION_EXTENDED);
 189 }
 190
 191
 192
 193 void
 194 delete_display (GtkWidget *widget,
 195                 GdkEvent  *event,
 196                 gpointer   data
 197                 )
 198 /*-----------------------------------------------------------------------------
 199  */
 200 {
 201     GpivConsole *gpiv = gtk_object_get_data (GTK_OBJECT (widget), "gpiv");
 202     Display *disp = gtk_object_get_data (GTK_OBJECT (widget), "disp");
 203
 204
 205     close_buffer__check_saved (gpiv, disp);
 206 }
 207
 208
 209
 210 void
 211 on_adj_changed (GtkAdjustment *adj,
 212                 gpointer data
 213                 )
 214 /*-----------------------------------------------------------------------------
 215  */
 216 {
 217     Display *disp = gtk_object_get_data (GTK_OBJECT (adj), "disp");
 218
 219     enum variable_type {
 220         X_ADJ = 0,
 221         Y_ADJ = 1
 222     } var_type;
 223
 224     var_type = atoi (gtk_object_get_data (GTK_OBJECT (adj), "var_type"));
 225 /*         g_message ("ON_ADJ_CHANGED:: " */
 226 /*                    "value = %f lower = %f upper = %f page_size = %f", */
 227 /*                    adj->value, adj->lower, adj->upper, adj->page_size); */
 228
 229     if (var_type == X_ADJ) {
 230         disp->x_adj_value = (gdouble) adj->value;
 231         disp->x_adj_upper = (gdouble) adj->upper;
 232         disp->x_adj_lower = (gdouble) adj->lower;
 233         disp->x_page_size = (gdouble) adj->page_size;
 234
 235         on_adj_changed__adapt_hcanvas (disp);
 236         on_adj_changed__adapt_hruler (disp);
 237     }
 238
 239     if (var_type == Y_ADJ) {
 240         disp->y_adj_value = (gdouble) adj->value;
 241         disp->y_adj_upper = (gdouble) adj->upper;
 242         disp->y_adj_lower = (gdouble) adj->lower;
 243         disp->y_page_size = (gdouble) adj->page_size;
 244
 245         on_adj_changed__adapt_vcanvas (disp);
 246         on_adj_changed__adapt_vruler (disp);
 247     }
 248 /*     g_message ("N_SCROLLEDWINDOW_DISPLAY_ADJ_CHANGED:: x_adj_value = %f" */
 249 /* " x_adj_lower = %f x_adj_upper = %f x_page_size = %f", */
 250 /*                disp->x_adj_value, disp->x_adj_lower, disp->x_adj_upper, */
 251 /*                disp->x_page_size); */
 252 }
 253
 254
 255 /*
 256  * Callbacks for menus
 257  */
 258 void
 259 on_menu_synchronize_popup (GtkMenuItem *menuitem,
 260                            gpointer user_data)
 261 /*-----------------------------------------------------------------------------
 262  * Synchronizing with popup menu item, which will actually change the
 263  * displaying of the menubar.
 264  */
 265 {
 266     Display *disp = display_act;
 267     gint menu_id = (int) user_data;
 268     GtkWidget *popupmenu;
 269
 270
 271     if (menu_id == VIEW_MENUBAR) {
 272         popupmenu = gtk_object_get_data(GTK_OBJECT(disp->mwin),
 273                                         "view_menubar_popup_menu");
 274         if (GTK_CHECK_MENU_ITEM(menuitem)->active == TRUE) {
 275             synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 276         } else {
 277             synchronize_menu (GTK_WIDGET (menuitem), FALSE, popupmenu);
 278         }
 279
 280
 281     } else if (menu_id == VIEW_RULERS) {
 282         popupmenu = gtk_object_get_data( GTK_OBJECT (disp->mwin),
 283                                          "view_rulers_popup_menu");
 284         if (GTK_CHECK_MENU_ITEM (menuitem)->active == TRUE) {
 285             synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 286         } else {
 287             synchronize_menu (GTK_WIDGET (menuitem), FALSE, popupmenu);
 288         }
 289
 290
 291     } else if (menu_id == STRETCH_AUTO) {
 292         popupmenu = gtk_object_get_data( GTK_OBJECT (disp->mwin),
 293                                          "stretch_auto_popup_menu");
 294         if (GTK_CHECK_MENU_ITEM (menuitem)->active == TRUE) {
 295             synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 296         } else {
 297             synchronize_menu (GTK_WIDGET (menuitem), FALSE, popupmenu);
 298         }
 299
 300
 301     } else if (menu_id == VIEW_BLUE) {
 302         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 303                                          "view_background_display0");
 304         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 305
 306
 307     } else if (menu_id == VIEW_BLACK) {
 308         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 309                                          "view_background_display1");
 310         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 311
 312
 313     } else if (menu_id == VIEW_IMAGE_A) {
 314         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 315                                          "view_background_display2");
 316         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 317
 318
 319     } else if (menu_id == VIEW_IMAGE_B) {
 320         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 321                                          "view_background_display3");
 322         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 323
 324
 325     } else if (menu_id == VIEW_INTERROGATION_AREAS) {
 326         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 327                                          "view_piv_display0");
 328         if (GTK_CHECK_MENU_ITEM(menuitem)->active == TRUE) {
 329             synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 330         } else {
 331             synchronize_menu (GTK_WIDGET (menuitem), FALSE, popupmenu);
 332         }
 333
 334
 335     } else if (menu_id == VIEW_VELOCITY_VECTORS) {
 336         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 337                                          "view_piv_display1");
 338         if (GTK_CHECK_MENU_ITEM (menuitem)->active == TRUE) {
 339             synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 340         } else {
 341             synchronize_menu (GTK_WIDGET (menuitem), FALSE, popupmenu);
 342         }
 343
 344
 345     } else if (menu_id == VIEW_NONE_SCALARS) {
 346         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 347                                          "view_scalardata_display0");
 348         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 349
 350
 351     } else if (menu_id == VIEW_VORTICITY) {
 352         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 353                                          "view_scalardata_display1");
 354         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 355
 356
 357     } else if (menu_id == VIEW_SHEAR_STRAIN) {
 358         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 359                                          "view_scalardata_display2");
 360         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 361
 362
 363     } else if (menu_id == VIEW_NORMAL_STRAIN) {
 364         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 365                                          "view_scalardata_display3");
 366         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 367
 368
 369     } else if (menu_id == VECTOR_COLOR_PEAK) {
 370         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 371                                          "vectorcolor_menu_display0");
 372         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 373
 374
 375     } else if (menu_id == VECTOR_COLOR_SNR) {
 376         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 377                                          "vectorcolor_menu_display1");
 378         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 379
 380
 381     } else if (menu_id == VECTOR_COLOR_MAGNGRAY) {
 382         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 383                                          "vectorcolor_menu_display2");
 384         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 385
 386
 387     } else if (menu_id == VECTOR_COLOR_MAGNCOLOR) {
 388         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 389                                          "vectorcolor_menu_display3");
 390         synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 391     }
 392 }
 393
 394
 395
 396 void
 397 on_stretch_activate (GtkMenuItem *menuitem,
 398                      gpointer user_data)
 399 /*-----------------------------------------------------------------------------
 400  */
 401 {
 402     Display *disp = display_act;
 403     GtkAdjustment *hadj = GTK_ADJUSTMENT (disp->hadj);
 404         (disp->vadj) ;
 405     GtkAdjustment *vadj = GTK_ADJUSTMENT (disp->vadj) ;
 406
 407     check__zoom_factor (&disp->zoom_factor);
 408     stretch_window (disp);
 409
 410     vadj->lower = 0.0;
 411     vadj->upper = (gdouble)  disp->img->image->header->nrows * disp->zoom_factor;
 412     vadj->page_size = (gdouble) (disp->img->image->header->nrows
 413                                  * disp->zoom_factor);
 414     hadj->lower = 0.0;
 415     hadj->upper = (gdouble) disp->img->image->header->ncolumns * disp->zoom_factor;
 416     hadj->page_size = (gdouble) (disp->img->image->header->ncolumns
 417                                  * disp->zoom_factor);
 418 }
 419
 420
 421 void
 422 on_zoom_activate (GtkMenuItem *menuitem,
 423                   gpointer user_data)
 424 /*-----------------------------------------------------------------------------
 425  */
 426 {
 427     Display *disp = display_act;
 428     gint zoom_index = (int) user_data;
 429     gchar *key = NULL;
 430     GtkWidget *popupmenu;
 431
 432
 433     key = g_strdup_printf ("zmv_%d", (int) zoom_index);
 434     popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin), key);
 435
 436     synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 437     g_free (key);
 438 }
 439
 440
 441 void
 442 on_vector_scale_activate (GtkMenuItem *menuitem,
 443                           gpointer user_data)
 444 /*-----------------------------------------------------------------------------
 445  */
 446 {
 447     Display *disp = display_act;
 448     gchar *key = NULL;
 449     GtkWidget *popupmenu;
 450     guint16 fact = 1;
 451
 452     fact = fact << (int) user_data;
 453     gpiv_par->display__vector_scale = fact;
 454
 455     key = g_strdup_printf ("vs_mv_%d", (int) user_data);
 456     popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin), key);
 457     synchronize_menu (GTK_WIDGET (menuitem), TRUE, popupmenu);
 458     g_free (key);
 459 }
 460
 461
 462 /*
 463  * Callbacks for popup menus
 464  */
 465 void
 466 view_toggle_menubar (GtkWidget *widget,
 467                      gpointer data
 468                      )
 469 /*-----------------------------------------------------------------------------
 470  */
 471 {
 472     Display *disp = display_act;
 473     GtkWidget *menu =
 474         gtk_object_get_data (GTK_OBJECT(disp->mwin),
 475                              "view_menubar");
 476
 477 /*
 478  * Synchronizing menu item from menu bar.
 479  */
 480     if (GTK_CHECK_MENU_ITEM (widget)->active == TRUE) {
 481         synchronize_menu (widget, TRUE, menu);
 482     } else {
 483         synchronize_menu (widget, FALSE, menu);
 484     }
 485
 486 /*
 487  * Changing the displaying of menubar
 488  */
 489     if (GTK_CHECK_MENU_ITEM (widget)->active == TRUE) {
 490         gtk_widget_show (GTK_WIDGET (disp->menubar));
 491     } else {
 492         gtk_widget_hide (GTK_WIDGET (disp->menubar));
 493     }
 494 }
 495
 496
 497
 498 void
 499 view_toggle_rulers (GtkWidget *widget,
 500                     gpointer data
 501                     )
 502 /*-----------------------------------------------------------------------------
 503  */
 504 {
 505     Display *disp = display_act;
 506
 507
 508 /*
 509  * Synchronizing menu item from menu bar.
 510  */
 511     if (GTK_CHECK_MENU_ITEM (widget)->active == TRUE) {
 512         synchronize_menu (widget, TRUE, disp->view_rulers);
 513     } else {
 514         synchronize_menu (widget, FALSE, disp->view_rulers);
 515     }
 516
 517 /*
 518  * Changing the displaying of rulers
 519  */
 520     if (GTK_CHECK_MENU_ITEM (widget)->active == TRUE) {
 521         gtk_widget_show (GTK_WIDGET (disp->hruler));
 522         gtk_widget_show (GTK_WIDGET (disp->vruler));
 523     } else {
 524         gtk_widget_hide (GTK_WIDGET (disp->hruler));
 525         gtk_widget_hide (GTK_WIDGET (disp->vruler));
 526     }
 527 }
 528
 529
 530
 531 void
 532 view_toggle_stretch_display_auto (GtkWidget *widget,
 533                                   gpointer data
 534                                   )
 535 /*-----------------------------------------------------------------------------
 536  */
 537 {
 538     Display *disp = display_act;
 539
 540
 541 /*
 542  * Synchronizing menu item from menu bar.
 543  */
 544     if (GTK_CHECK_MENU_ITEM (widget)->active == TRUE) {
 545         synchronize_menu (widget, TRUE, disp->stretch_auto);
 546     } else {
 547         synchronize_menu (widget, FALSE, disp->stretch_auto);
 548     }
 549
 550 /*
 551  * Changing the displaying of rulers
 552  */
 553     if (GTK_CHECK_MENU_ITEM (widget)->active == TRUE) {
 554         gpiv_par->display__stretch_auto = TRUE;
 555         check__zoom_factor (&disp->zoom_factor);
 556         stretch_window (disp);
 557     } else {
 558         gpiv_par->display__stretch_auto = FALSE;
 559     }
 560 }
 561
 562
 563
 564 void
 565 view_toggle_stretch_display (GtkWidget *widget,
 566                              gpointer data
 567                              )
 568 /*-----------------------------------------------------------------------------
 569  */
 570 {
 571     Display *disp = display_act;
 572     gint screen_width = gdk_screen_width ();
 573     gint screen_height = gdk_screen_height ();
 574
 575
 576     check__zoom_factor (&disp->zoom_factor);
 577     stretch_window (disp);
 578 }
 579
 580
 581 void
 582 select_zoomscale (gpointer data,
 583                   guint action,
 584                   GtkWidget *widget
 585                   )
 586 /*-----------------------------------------------------------------------------
 587  */
 588 {
 589     Display *disp = display_act;
 590     gint zoom_index = action;
 591     gchar *key1 = NULL, *key2 = NULL;
 592     GtkWidget *popupmenu, *menu;
 593
 594
 595     key1 = g_strdup_printf ("zmv_%d", (int) zoom_index);
 596     popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin), key1);
 597
 598     key2 = g_strdup_printf ("zoom_menu_%d", (int) zoom_index);
 599     menu = gtk_object_get_data (GTK_OBJECT (disp->mwin), key2);
 600
 601     synchronize_menu (popupmenu, TRUE, menu);
 602
 603     zoom_display (disp, zoom_index);
 604     g_free (key1);
 605     g_free (key2);
 606 }
 607
 608
 609
 610 void
 611 select_view_background (gpointer data,
 612                         guint action,
 613                         GtkWidget *widget)
 614 /*-----------------------------------------------------------------------------
 615  */
 616 {
 617     gchar *color = NULL;
 618     Display *disp = display_act;
 619     GtkWidget *menu = NULL, *popupmenu = NULL;
 620
 621     gpiv_par->display__backgrnd = action;
 622     hide_img1 (disp);
 623     hide_img2 (disp);
 624
 625 /*
 626  * Select menu and popup menu widgets
 627  */
 628     if (action == SHOW_BG_DARKBLUE) {
 629         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 630                                     "blue_background_menu");
 631         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 632                                          "view_background_display0");
 633
 634     } else if (action == SHOW_BG_BLACK) {
 635         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 636                                     "black_background_menu");
 637         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 638                                          "view_background_display1");
 639
 640     } else if (action == SHOW_BG_IMG1) {
 641         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 642                                     "image_a_background_menu");
 643         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 644                                          "view_background_display2");
 645
 646     } else if (action == SHOW_BG_IMG2) {
 647         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 648                                     "image_b_background_menu");
 649         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 650                                          "view_background_display3");
 651     }
 652
 653 /*
 654  * Synchronize
 655  */
 656     synchronize_menu (popupmenu, TRUE, menu);
 657
 658 /*
 659  * Perform action
 660  */
 661     if (action == SHOW_BG_DARKBLUE) {
 662         color = "darkblue";
 663         if (disp->gci_bg != NULL) {
 664             gnome_canvas_item_set (GNOME_CANVAS_ITEM (disp->gci_bg),
 665                                    "fill_color", color,
 666                                    NULL);
 667         }
 668
 669     } else if (action == SHOW_BG_BLACK) {
 670         color = "black";
 671         if (disp->gci_bg != NULL) {
 672             gnome_canvas_item_set (GNOME_CANVAS_ITEM (disp->gci_bg),
 673                                    "fill_color", color,
 674                                    NULL);
 675         }
 676
 677     } else if (action == SHOW_BG_IMG1) {
 678         show_img1 (display_act);
 679
 680     } else if (action == SHOW_BG_IMG2) {
 681         show_img2 (display_act);
 682
 683     } else {
 684         color = "black";
 685         if (disp->gci_bg != NULL) {
 686             gnome_canvas_item_set (GNOME_CANVAS_ITEM (disp->gci_bg),
 687                                    "fill_color", color,
 688                                    NULL);
 689         } else {
 690             g_warning (_("select_view_background: should not arrive here"));
 691         }
 692     }
 693
 694 }
 695
 696
 697
 698 void
 699 view_toggle_intregs (GtkWidget *widget,
 700                      gpointer data
 701                      )
 702 /*-----------------------------------------------------------------------------
 703  */
 704 {
 705     Display *disp = display_act;
 706
 707 /*
 708  * Synchronizing menu item from menu bar.
 709  */
 710     if (GTK_CHECK_MENU_ITEM (widget)->active == TRUE) {
 711         synchronize_menu (widget, TRUE, disp->view_interrogation_areas);
 712     } else {
 713         synchronize_menu (widget, FALSE, disp->view_interrogation_areas);
 714     }
 715
 716 /*
 717  * Changing the displaying of interrogation area's
 718  */
 719     if (GTK_CHECK_MENU_ITEM (widget)->active == TRUE) {
 720         if (view_toggle_intregs_flag) {
 721             if (display_act->display_intregs == FALSE) {
 722                 display_act->display_intregs = TRUE;
 723                 create_all_intregs (display_act);
 724                 show_all_intregs (display_act);
 725             }
 726         }
 727     } else {
 728         if (display_act->display_intregs == TRUE) {
 729             destroy_all_intregs(display_act);
 730             display_act->display_intregs = FALSE;
 731         }
 732     }
 733 }
 734
 735
 736
 737 void
 738 view_toggle_piv (GtkWidget *widget,
 739                 gpointer data
 740                 )
 741 /*-----------------------------------------------------------------------------
 742  */
 743 {
 744     Display *disp = display_act;
 745
 746 /*
 747  * Synchronizing menu item from menu bar.
 748  */
 749     if (GTK_CHECK_MENU_ITEM (widget)->active == TRUE) {
 750         synchronize_menu (widget, TRUE, disp->view_velocity_vectors);
 751     } else {
 752         synchronize_menu (widget, FALSE, disp->view_velocity_vectors);
 753     }
 754
 755 /*
 756  * Changing the displaying of piv data (velocity vectors)
 757  */
 758     if (display_act->pida->exist_piv) {
 759         if (GTK_CHECK_MENU_ITEM (widget)->active == TRUE) {
 760             if (display_act->display_piv == FALSE) {
 761                 display_act->display_piv = TRUE;
 762                 create_all_vectors (display_act->pida);
 763             }
 764         } else {
 765             if (display_act->display_piv == TRUE) {
 766                 display_act->display_piv = FALSE;
 767                 destroy_all_vectors (display_act->pida);
 768             }
 769         }
 770     }
 771 }
 772
 773
 774
 775 void
 776 select_view_scalardata (gpointer data,
 777                         guint action,
 778                         GtkWidget *widget
 779                         )
 780 /*-----------------------------------------------------------------------------
 781  */
 782 {
 783     gchar *color = NULL;
 784     Display *disp = display_act;
 785     GtkWidget *menu = NULL, *popupmenu = NULL;
 786
 787
 788     gpiv_par->display__scalar =  action;
 789
 790     hide_all_scalars (disp, GPIV_VORTICITY);
 791     hide_all_scalars (disp, GPIV_S_STRAIN);
 792     hide_all_scalars (disp, GPIV_N_STRAIN);
 793
 794 /*
 795  * Select menu and popup menu widgets
 796  */
 797     if (action == SHOW_SC_NONE) {
 798         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 799                                     "view_none_scalars");
 800         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 801                                          "view_scalardata_display0");
 802
 803     } else if (action == SHOW_SC_VORTICITY) {
 804         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 805                                     "view_vorticity");
 806         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 807                                          "view_scalardata_display1");
 808
 809     } else if (action == SHOW_SC_SSTRAIN) {
 810         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 811                                     "view_shear_strain");
 812         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 813                                          "view_scalardata_display2");
 814
 815    } else if (action == SHOW_SC_NSTRAIN) {
 816         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 817                                     "view_normal_strain");
 818         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 819                                          "view_scalardata_display3");
 820     }
 821
 822
 823     synchronize_menu (popupmenu, TRUE, menu);
 824
 825 /*
 826  * Perform action
 827  */
 828     if (action == SHOW_SC_NONE) {
 829         hide_all_scalars (disp, GPIV_VORTICITY);
 830         hide_all_scalars (disp, GPIV_S_STRAIN);
 831         hide_all_scalars (disp, GPIV_N_STRAIN);
 832
 833     } else if (action == SHOW_SC_VORTICITY) {
 834         show_all_scalars (display_act, GPIV_VORTICITY);
 835
 836     } else if (action == SHOW_SC_SSTRAIN) {
 837         show_all_scalars (display_act, GPIV_S_STRAIN);
 838
 839     } else if (action == SHOW_SC_NSTRAIN) {
 840         show_all_scalars (display_act, GPIV_N_STRAIN);
 841
 842     } else {
 843         color = "black";
 844         if (disp->gci_bg != NULL) {
 845             gnome_canvas_item_set (GNOME_CANVAS_ITEM (disp->gci_bg),
 846                                    "fill_color", color,
 847                                    NULL);
 848         } else {
 849             g_warning (_("select_view_scalardata: should not arrive here"));
 850         }
 851     }
 852
 853 }
 854
 855
 856
 857 void
 858 select_vectorscale (gpointer data,
 859                     guint action,
 860                     GtkWidget *widget
 861                     )
 862 /*-----------------------------------------------------------------------------
 863   Setting vector_scale from display pop-up menu */
 864 {
 865     Display *disp = display_act;
 866     gchar *key1 = NULL, *key2 = NULL;
 867     GtkWidget *menu,  *popupmenu;
 868     guint16 fact = 1;
 869
 870     gpiv_par->display__vector_scale = fact << (int) action;;
 871
 872     key1 = g_strdup_printf ("vector_scale_menu_%d", (int) action);
 873     menu = gtk_object_get_data (GTK_OBJECT (disp->mwin), key1);
 874
 875     key2 = g_strdup_printf ("vs_mv_%d", (int) action);
 876     popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin), key2);
 877
 878     synchronize_menu (popupmenu, TRUE, menu);
 879
 880     update_all_vectors (display_act->pida);
 881     g_free (key1);
 882     g_free (key2);
 883 }
 884
 885
 886
 887 void
 888 select_vectorcolor (gpointer data,
 889                     guint action,
 890                     GtkWidget *widget
 891                     )
 892 /*-----------------------------------------------------------------------------
 893   Setting vector_color from display pop-up menu */
 894 {
 895     Display *disp = display_act;
 896     GtkWidget *menu, *popupmenu;
 897
 898 /*
 899  * Select menu and popup menu widgets
 900  */
 901     if (action == SHOW_PEAKNR) {
 902         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 903                                     "vector_color_peak_nr");
 904         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 905                                          "vectorcolor_menu_display0");
 906
 907     } else if (action == SHOW_SNR) {
 908         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 909                                     "vector_color_snr");
 910         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 911                                          "vectorcolor_menu_display1");
 912
 913     } else if (action == SHOW_MAGNITUDE_GRAY) {
 914         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 915                                     "vector_color_magngray");
 916         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 917                                          "vectorcolor_menu_display2");
 918
 919     } else if (action == SHOW_MAGNITUDE) {
 920         menu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 921                                     "vector_color_magncolor");
 922         popupmenu = gtk_object_get_data (GTK_OBJECT (disp->mwin),
 923                                          "vectorcolor_menu_display3");
 924     }
 925
 926 /*
 927  * Synchronize
 928  */
 929     synchronize_menu (popupmenu, TRUE, menu);
 930
 931 /*
 932  * Perform action
 933  */
 934     gpiv_par->display__vector_color = action;
 935     update_all_vectors (display_act->pida);
 936 }
 937
 938
 939
 940 void
 941 nav_popup_click_handler (GtkWidget *widget,
 942                          GdkEventButton *event,
 943                          gpointer data
 944                          )
 945 /*-----------------------------------------------------------------------------
 946  */
 947 {
 948     /* Seee gimp: nav_window.c */
 949 }
 950
 951
 952
 953 void
 954 on_view_options_clicked (GtkButton *button,
 955                          gpointer user_data
 956                          )
 957 /*-----------------------------------------------------------------------------
 958  */
 959 {
 960
 961 }
 962
 963
 964 /*
 965  * Local functions
 966  */
 967 static void
 968 on_adj_changed__adapt_hcanvas (Display *disp
 969                                )
 970 /*-----------------------------------------------------------------------------
 971  */
 972 {
 973     int x_old, y_old;
 974     gnome_canvas_get_scroll_offsets (GNOME_CANVAS (disp->canvas),
 975                                              &x_old,
 976                                              &y_old);
 977     gnome_canvas_scroll_to (GNOME_CANVAS (disp->canvas),
 978                             (int) disp->x_adj_value,
 979                             y_old);
 980 }
 981
 982
 983 static void
 984 on_adj_changed__adapt_vcanvas (Display *disp
 985                                )
 986 /*-----------------------------------------------------------------------------
 987  */
 988 {
 989     int x_old, y_old;
 990     gnome_canvas_get_scroll_offsets (GNOME_CANVAS (disp->canvas),
 991                                              &x_old,
 992                                              &y_old);
 993     gnome_canvas_scroll_to (GNOME_CANVAS (disp->canvas),
 994                             x_old,
 995                             (int) disp->y_adj_value);
 996 }
 997
 998 static void
 999 on_adj_changed__adapt_hruler (Display *disp
1000                               )
1001 /*-----------------------------------------------------------------------------
1002  */
1003 {
1004     set__hrulerscale (disp);
1005 }
1006
1007
1008 static void
1009 on_adj_changed__adapt_vruler (Display *disp
1010                               )
1011 /*-----------------------------------------------------------------------------
1012  */
1013 {
1014     set__vrulerscale (disp);
1015 }
1016
1017
1018 static void
1019 synchronize_menu (GtkWidget *menu_src,
1020                   gboolean state,
1021                   GtkWidget *menu_dest
1022                   )
1023 /*-----------------------------------------------------------------------------
1024  * Synchronizes menu_dest with menu_src, which is in 'state' position.
1025  * Only change if the state between menu_src and menu_dest differ in order
1026  * to avoid a loop.
1027  */
1028 {
1029     if (GTK_CHECK_MENU_ITEM (menu_src) != NULL
1030         && GTK_CHECK_MENU_ITEM (menu_src)->active == state) {
1031         if (GTK_CHECK_MENU_ITEM (menu_dest) != NULL
1032             && gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menu_dest))
1033             == !state) {
1034             gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_dest),
1035                                             state);
1036         }
1037     }
1038 }
1039
1040
1041
1042