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