src/pivvalid_interface.c

   1
   2 /*----------------------------------------------------------------------
   3
   4   gpiv - Graphic program for Particle Image Velocimetry, based on gtk/gnome
   5           libraries.
   6
   7    Copyright (C) 2002, 2003, 2004 Gerber van der Graaf
   8
   9    This file is part of gpiv.
  10
  11    Gpiv is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2, or (at your option)
  14    any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software Foundation,
  23    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24
  25 ----------------------------------------------------------------------*/
  26
  27 /*
  28  * PIV Validation interface
  29  * $Log: pivvalid_interface.c,v $
  30  * Revision 1.11  2007-12-19 08:42:35  gerber
  31  * debugged
  32  *
  33  * Revision 1.10  2007-11-23 16:24:08  gerber
  34  * release 0.5.0: Kafka
  35  *
  36  * Revision 1.9  2007-01-29 11:27:44  gerber
  37  * added image formats png, gif, tif png, bmp, improved buffer display
  38  *
  39  * Revision 1.8  2006/01/31 14:28:13  gerber
  40  * version 0.3.0
  41  *
  42  * Revision 1.6  2005/02/12 14:12:12  gerber
  43  * Changed tabular names and titles
  44  *
  45  * Revision 1.5  2005/01/19 15:53:42  gerber
  46  * Initiation of Data Acquisition (DAC); trigerring of lasers and camera
  47  * by using RTAI and Realtime Linux, recording images from IEEE1394
  48  * (Firewire) IIDC compliant camera's
  49  *
  50  * Revision 1.4  2004/10/15 19:24:05  gerber
  51  * GPIV_ and Gpiv prefix to defines and structure names of libgpiv
  52  *
  53  * Revision 1.3  2004/06/14 21:19:23  gerber
  54  * Image depth up to 16 bits.
  55  * Improvement "single int" and "drag int" in Eval tab.
  56  * Viewer's pop-up menu.
  57  * Adaption for gpiv_matrix_* and gpiv_vector_*.
  58  * Resizing console.
  59  * See Changelog for further info.
  60  *
  61  * Revision 1.2  2003/08/22 15:24:52  gerber
  62  * interactive spatial scaling
  63  *
  64  * Revision 1.1.1.1  2003/06/17 17:10:52  gerber
  65  * Imported gpiv
  66  *
  67  */
  68
  69 #ifdef HAVE_CONFIG_H
  70 #  include <config.h>
  71 #endif
  72
  73 #include "gpiv_gui.h"
  74 /* #include "console.h" */
  75 #include "utils.h"
  76 #include "pivvalid_interface.h"
  77 #include "pivvalid.h"
  78
  79 PivValid *
  80 create_pivvalid (GnomeApp *main_window,
  81                 GtkWidget *container
  82                  )
  83 /*-----------------------------------------------------------------------------
  84  */
  85 {
  86     GpivConsole * gpiv = gtk_object_get_data (GTK_OBJECT (main_window), "gpiv");
  87     PivValid *valid = g_new0(PivValid, 1);
  88
  89
  90
  91     valid->vbox_label = gtk_vbox_new (FALSE,
  92                                      0);
  93     gtk_widget_ref(valid->vbox_label);
  94     gtk_object_set_data_full (GTK_OBJECT (main_window),
  95                              "vbox_label",
  96                              valid->vbox_label,
  97                              (GtkDestroyNotify) gtk_widget_unref);
  98     gtk_widget_show(valid->vbox_label);
  99     gtk_container_add (GTK_CONTAINER (container),
 100                       valid->vbox_label);
 101
 102     valid->label_title = gtk_label_new( _("Piv data validation"));
 103     gtk_widget_ref(valid->label_title);
 104     gtk_object_set_data_full (GTK_OBJECT (main_window),
 105                              "label_title",
 106                              valid->label_title,
 107                              (GtkDestroyNotify) gtk_widget_unref);
 108     gtk_widget_show (valid->label_title);
 109     gtk_box_pack_start (GTK_BOX (valid->vbox_label),
 110                        valid->label_title,
 111                        FALSE,
 112                        FALSE,
 113                        0);
 114
 115
 116 /*
 117  * Scrolled window
 118  */
 119     valid->vbox_scroll = gtk_vbox_new (FALSE,
 120                                       0);
 121     gtk_widget_ref (valid->vbox_scroll);
 122     gtk_object_set_data_full (GTK_OBJECT (main_window),
 123                              "vbox_scroll",
 124                              valid->vbox_scroll,
 125                              (GtkDestroyNotify) gtk_widget_unref);
 126     gtk_widget_show (valid->vbox_scroll);
 127     gtk_box_pack_start (GTK_BOX (valid->vbox_label),
 128                        valid->vbox_scroll,
 129                        TRUE,
 130                        TRUE,
 131                        0);
 132
 133
 134     valid->scrolledwindow = gtk_scrolled_window_new (NULL,
 135                                                     NULL);
 136     gtk_widget_ref (valid->scrolledwindow);
 137     gtk_object_set_data_full (GTK_OBJECT (main_window),
 138                              "scrolledwindow",
 139                              valid->scrolledwindow,
 140                              (GtkDestroyNotify) gtk_widget_unref);
 141     gtk_widget_show (valid->scrolledwindow);
 142     gtk_box_pack_start (GTK_BOX (valid->vbox_scroll),
 143                        valid->scrolledwindow,
 144                        TRUE,
 145                        TRUE,
 146                        0);
 147     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW
 148                                    (valid->scrolledwindow),
 149                                    GTK_POLICY_NEVER,
 150                                    GTK_POLICY_AUTOMATIC);
 151
 152
 153
 154
 155     valid->viewport = gtk_viewport_new (NULL,
 156                                        NULL);
 157     gtk_widget_ref (valid->viewport);
 158     gtk_object_set_data_full (GTK_OBJECT (main_window),
 159                              "viewport",
 160                              valid->viewport,
 161                              (GtkDestroyNotify) gtk_widget_unref);
 162     gtk_widget_show (valid->viewport);
 163     gtk_container_add (GTK_CONTAINER (valid->scrolledwindow),
 164                       valid->viewport);
 165
 166 /*
 167  * main table for validation
 168  */
 169     valid->table = gtk_table_new (2,
 170                                  2,
 171                                  FALSE);
 172     gtk_widget_ref (valid->table);
 173     gtk_object_set_data_full (GTK_OBJECT (main_window),
 174                              "table",
 175                              valid->table,
 176                              (GtkDestroyNotify) gtk_widget_unref);
 177     gtk_widget_show (valid->table);
 178     gtk_container_add (GTK_CONTAINER (valid->viewport),
 179                       valid->table);
 180
 181
 182
 183 /*
 184  * Enable / Disable frame
 185  */
 186
 187     valid->frame_disable = gtk_frame_new ( _("Disable data"));
 188     gtk_widget_ref (valid->frame_disable);
 189     gtk_object_set_data_full (GTK_OBJECT (main_window),
 190                              "frame_disable",
 191                              valid->frame_disable,
 192                              (GtkDestroyNotify)
 193                              gtk_widget_unref);
 194     gtk_widget_show (valid->frame_disable);
 195     gtk_table_attach (GTK_TABLE (valid->table),
 196                      valid->frame_disable,
 197                      0,
 198                      1,
 199                      0,
 200                      1,
 201                      (GtkAttachOptions) (GTK_FILL),
 202                      (GtkAttachOptions) (GTK_SHRINK),
 203                      0,
 204                      0);
 205
 206
 207
 208     valid->vbox_disable = gtk_vbox_new (FALSE,
 209                                        0);
 210     gtk_widget_ref (valid->vbox_disable);
 211     gtk_object_set_data_full (GTK_OBJECT (main_window),
 212                              "vbox_disable",
 213                              valid->vbox_disable,
 214                              (GtkDestroyNotify) gtk_widget_unref);
 215     gtk_widget_show (valid->vbox_disable);
 216     gtk_container_add (GTK_CONTAINER (valid->frame_disable),
 217                       valid->vbox_disable);
 218
 219
 220
 221     valid->radiobutton_disable_0 =
 222         gtk_radio_button_new_with_label (gpiv->mouse_sel_group,
 223                                          _("None"));
 224     gpiv->mouse_sel_group =
 225         gtk_radio_button_group (GTK_RADIO_BUTTON
 226                                (valid->radiobutton_disable_0));
 227     gtk_widget_ref (valid->radiobutton_disable_0);
 228     gtk_object_set_data_full (GTK_OBJECT (main_window),
 229                              "radiobutton_disable_0",
 230                              valid->radiobutton_disable_0,
 231                              (GtkDestroyNotify) gtk_widget_unref);
 232     gtk_widget_show (valid->radiobutton_disable_0);
 233     gtk_box_pack_start (GTK_BOX (valid->vbox_disable),
 234                        valid->radiobutton_disable_0,
 235                        FALSE,
 236                        FALSE,
 237                        0);
 238
 239
 240     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_disable_0),
 241                         "valid",
 242                         valid);
 243     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_disable_0),
 244                         "mouse_select",
 245                         "0" /* NO_MS */);
 246
 247     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_0),
 248                        "enter",
 249                        G_CALLBACK (on_radiobutton_valid_disable_0_enter),
 250                        NULL);
 251     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_0),
 252                        "leave",
 253                        G_CALLBACK (on_widget_leave),
 254                        NULL);
 255     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_0),
 256                        "toggled",
 257                        G_CALLBACK (on_radiobutton_valid_disable),
 258                        NULL);
 259
 260
 261
 262
 263     valid->radiobutton_disable_1 =
 264         gtk_radio_button_new_with_label (gpiv->mouse_sel_group,
 265                                          _("Enable point"));
 266     gpiv->mouse_sel_group =
 267         gtk_radio_button_group (GTK_RADIO_BUTTON
 268                                (valid->radiobutton_disable_1));
 269     gtk_widget_ref (valid->radiobutton_disable_1);
 270     gtk_object_set_data_full (GTK_OBJECT (main_window),
 271                              "radiobutton_valid_disable_1",
 272                              valid->radiobutton_disable_1,
 273                              (GtkDestroyNotify) gtk_widget_unref);
 274     gtk_widget_show (valid->radiobutton_disable_1);
 275     gtk_box_pack_start (GTK_BOX (valid->vbox_disable),
 276                        valid->radiobutton_disable_1,
 277                        FALSE,
 278                        FALSE,
 279                        0);
 280
 281    gtk_object_set_data (GTK_OBJECT (valid->radiobutton_disable_1),
 282                         "valid",
 283                         valid);
 284     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_disable_1),
 285                         "mouse_select",
 286                         "7" /* ENABLE_POINT_MS */);
 287     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_1),
 288                        "enter",
 289                        G_CALLBACK (on_radiobutton_valid_disable_1_enter),
 290                        NULL);
 291     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_1),
 292                        "leave",
 293                        G_CALLBACK (on_widget_leave),
 294                        NULL);
 295     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_1),
 296                        "toggled",
 297                        G_CALLBACK (on_radiobutton_valid_disable),
 298                        NULL);
 299
 300
 301
 302     valid->radiobutton_disable_2 =
 303         gtk_radio_button_new_with_label (gpiv->mouse_sel_group,
 304                                          _("Disable point"));
 305     gpiv->mouse_sel_group =
 306         gtk_radio_button_group (GTK_RADIO_BUTTON
 307                                (valid->radiobutton_disable_2));
 308     gtk_widget_ref (valid->radiobutton_disable_2);
 309     gtk_object_set_data_full (GTK_OBJECT (main_window),
 310                              "radiobutton_disable_2",
 311                              valid->radiobutton_disable_2,
 312                              (GtkDestroyNotify) gtk_widget_unref);
 313     gtk_widget_show (valid->radiobutton_disable_2);
 314     gtk_box_pack_start (GTK_BOX (valid->vbox_disable),
 315                        valid->radiobutton_disable_2,
 316                        FALSE,
 317                        FALSE,
 318                        0);
 319
 320     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_disable_2),
 321                         "valid",
 322                         valid);
 323     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_disable_2),
 324                         "mouse_select",
 325                         "8" /* DISABLE_POINT_MS */);
 326     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_2),
 327                        "enter",
 328                        G_CALLBACK (on_radiobutton_valid_disable_2_enter),
 329                        NULL);
 330     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_2),
 331                        "leave",
 332                        G_CALLBACK (on_widget_leave),
 333                        NULL);
 334     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_2),
 335                        "toggled",
 336                        G_CALLBACK (on_radiobutton_valid_disable),
 337                        NULL);
 338
 339
 340
 341     valid->radiobutton_disable_3 =
 342         gtk_radio_button_new_with_label (gpiv->mouse_sel_group,
 343                                          _("Enable area"));
 344     gpiv->mouse_sel_group =
 345         gtk_radio_button_group (GTK_RADIO_BUTTON
 346                                (valid->radiobutton_disable_3));
 347     gtk_widget_ref (valid->radiobutton_disable_3);
 348     gtk_object_set_data_full (GTK_OBJECT (main_window),
 349                              "radiobutton_disable_3",
 350                              valid->radiobutton_disable_3,
 351                              (GtkDestroyNotify) gtk_widget_unref);
 352     gtk_widget_show (valid->radiobutton_disable_3);
 353     gtk_box_pack_start (GTK_BOX (valid->vbox_disable),
 354                        valid->radiobutton_disable_3,
 355                        FALSE,
 356                        FALSE,
 357                        0);
 358
 359     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_disable_3),
 360                         "valid",
 361                         valid);
 362     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_disable_3),
 363                         "mouse_select",
 364                         "9" /* ENABLE_AREA_MS */);
 365     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_3),
 366                        "enter",
 367                        G_CALLBACK (on_radiobutton_valid_disable_3_enter),
 368                        NULL);
 369     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_3),
 370                        "leave",
 371                        G_CALLBACK (on_widget_leave),
 372                        NULL);
 373     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_3),
 374                        "toggled",
 375                        G_CALLBACK (on_radiobutton_valid_disable),
 376                        NULL);
 377
 378
 379
 380     valid->radiobutton_disable_4 =
 381         gtk_radio_button_new_with_label (gpiv->mouse_sel_group,
 382                                          _("Disable area"));
 383     gpiv->mouse_sel_group =
 384         gtk_radio_button_group (GTK_RADIO_BUTTON
 385                                (valid->radiobutton_disable_4));
 386     gtk_widget_ref (valid->radiobutton_disable_4);
 387     gtk_object_set_data_full (GTK_OBJECT (main_window),
 388                              "radiobutton_disable_4",
 389                              valid->radiobutton_disable_4,
 390                              (GtkDestroyNotify) gtk_widget_unref);
 391     gtk_widget_show (valid->radiobutton_disable_4);
 392     gtk_box_pack_start (GTK_BOX (valid->vbox_disable),
 393                        valid->radiobutton_disable_4,
 394                        FALSE,
 395                        FALSE,
 396                        0);
 397
 398     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_disable_4),
 399                         "valid",
 400                         valid);
 401      gtk_object_set_data (GTK_OBJECT (valid->radiobutton_disable_4),
 402                         "mouse_select",
 403                          "10" /* DISABLE_AREA_MS */);
 404     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_4),
 405                        "enter",
 406                        G_CALLBACK (on_radiobutton_valid_disable_4_enter),
 407                        NULL);
 408     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_4),
 409                        "leave",
 410                        G_CALLBACK (on_widget_leave),
 411                        NULL);
 412     g_signal_connect (GTK_OBJECT (valid->radiobutton_disable_4),
 413                        "toggled",
 414                        G_CALLBACK (on_radiobutton_valid_disable),
 415                        NULL);
 416
 417
 418
 419 /*
 420  * Button for testing on velocity gradients
 421  */
 422     valid->button_gradient =
 423         gtk_button_new_with_label ( _("validate on velocity gradient "));
 424     gtk_widget_ref (valid->button_gradient);
 425     gtk_object_set_data_full (GTK_OBJECT (main_window),
 426                              "button_gradient",
 427                              valid->button_gradient,
 428                              (GtkDestroyNotify) gtk_widget_unref);
 429     gtk_widget_show (valid->button_gradient);
 430     gtk_table_attach (GTK_TABLE (valid->table),
 431                      valid->button_gradient,
 432                      1,
 433                      2,
 434                      0,
 435                      1,
 436                      (GtkAttachOptions)(GTK_SHRINK /*FILL*/),
 437                      (GtkAttachOptions)(GTK_SHRINK),
 438                      0,
 439                      0);
 440
 441     gtk_tooltips_set_tip(gpiv->tooltips,
 442                          valid->button_gradient,
 443                           _("Disables PIV data that have a too large velocity "
 444 "gradient over the Interrogation Area"),
 445                          NULL);
 446
 447     gtk_object_set_data (GTK_OBJECT (valid->button_gradient),
 448                         "valid",
 449                         valid);
 450     g_signal_connect (GTK_OBJECT (valid->button_gradient),
 451                        "enter",
 452                        G_CALLBACK (on_button_valid_gradient_enter),
 453                        NULL);
 454     g_signal_connect (GTK_OBJECT (valid->button_gradient),
 455                        "leave",
 456                        G_CALLBACK (on_widget_leave),
 457                        NULL);
 458     g_signal_connect (GTK_OBJECT (valid->button_gradient),
 459                        "clicked",
 460                        G_CALLBACK (on_button_valid_gradient),
 461                        NULL);
 462
 463
 464
 465
 466 /*
 467  * Frame for histogram of sub-pixel values (used to test on peak-locking
 468  * effect)
 469  */
 470
 471     valid->frame_histo = gtk_frame_new ( _("Histograms"));
 472     gtk_widget_ref (valid->frame_histo);
 473     gtk_object_set_data_full (GTK_OBJECT (main_window),
 474                              "frame_histo",
 475                              valid->frame_histo,
 476                              (GtkDestroyNotify) gtk_widget_unref);
 477     gtk_widget_show (valid->frame_histo);
 478     gtk_table_attach (GTK_TABLE (valid->table),
 479                      valid->frame_histo,
 480                      0,
 481                      1,
 482                      1,
 483                      2,
 484                     (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 485                      (GtkAttachOptions) /* (GTK_SHRINK) */
 486                      (GTK_EXPAND | GTK_FILL),
 487                      0,
 488                      0);
 489
 490
 491
 492     valid->vbox_histo = gtk_vbox_new (FALSE,
 493                                        0);
 494     gtk_widget_ref (valid->vbox_histo);
 495     gtk_object_set_data_full (GTK_OBJECT (main_window),
 496                              "vbox_histo",
 497                              valid->vbox_histo,
 498                              (GtkDestroyNotify) gtk_widget_unref);
 499     gtk_widget_show (valid->vbox_histo);
 500     gtk_container_add (GTK_CONTAINER (valid->frame_histo),
 501                       valid->vbox_histo);
 502
 503
 504
 505
 506     valid->hbox_histo_spin = gtk_hbox_new (FALSE,
 507                                             0);
 508     gtk_widget_ref (valid->hbox_histo_spin);
 509     gtk_object_set_data_full (GTK_OBJECT (main_window),
 510                              "hbox_histo_spin",
 511                              valid->hbox_histo_spin,
 512                              (GtkDestroyNotify) gtk_widget_unref);
 513     gtk_widget_show (valid->hbox_histo_spin);
 514     gtk_box_pack_start (GTK_BOX (valid->vbox_histo),
 515                        valid->hbox_histo_spin,
 516                        FALSE,
 517                        FALSE,
 518                        0);
 519
 520
 521
 522     valid->label_histo_bins = gtk_label_new ( _("# bins: "));
 523     gtk_widget_ref (valid->label_histo_bins);
 524     gtk_object_set_data_full (GTK_OBJECT (main_window),
 525                              "label_histo_bins",
 526                              valid->label_histo_bins,
 527                              (GtkDestroyNotify) gtk_widget_unref);
 528     gtk_widget_show (valid->label_histo_bins);
 529     gtk_box_pack_start (GTK_BOX (valid->hbox_histo_spin),
 530                        valid->label_histo_bins,
 531                        FALSE,
 532                        FALSE,
 533                        0);
 534
 535
 536
 537 /*
 538  * NBINS_DEFAULT defined in gpiv.h
 539  */
 540     valid->spinbutton_adj_histo_bins =
 541       gtk_adjustment_new (GPIV_NBINS_DEFAULT,
 542                          0,
 543                          100,
 544                          1,
 545                          10,
 546                          100);
 547     valid->spinbutton_histo_bins =
 548       gtk_spin_button_new (GTK_ADJUSTMENT
 549                           (valid->spinbutton_adj_histo_bins),
 550                           1,
 551                           0);
 552     gtk_widget_ref (valid->spinbutton_histo_bins);
 553     gtk_object_set_data_full (GTK_OBJECT (main_window),
 554                              "spinbutton_histo_bins",
 555                              valid->spinbutton_histo_bins,
 556                              (GtkDestroyNotify) gtk_widget_unref);
 557     gtk_widget_show (valid->spinbutton_histo_bins);
 558     gtk_box_pack_start (GTK_BOX (valid->hbox_histo_spin),
 559                        valid->spinbutton_histo_bins,
 560                        FALSE,
 561                        FALSE,
 562                        0);
 563
 564     gtk_object_set_data (GTK_OBJECT (valid->spinbutton_histo_bins),
 565                         "valid",
 566                         valid);
 567     g_signal_connect (GTK_OBJECT (valid->spinbutton_histo_bins),
 568                        "changed",
 569                        G_CALLBACK (on_spinbutton_valid_peaklck_bins),
 570                        valid->spinbutton_histo_bins);
 571
 572
 573
 574
 575
 576 /*
 577  * Gnome2:
 578  */
 579 /*     gtk_widget_push_colormap (GdkColormap *cmap) */
 580 /*     gtk_widget_push_visual (gdk_imlib_get_visual ()); */
 581 /*     gtk_widget_push_colormap (gdk_imlib_get_colormap ()); */
 582     valid->canvas_histo = gnome_canvas_new ();
 583     gtk_widget_pop_colormap ();
 584     gtk_widget_pop_visual ();
 585     gtk_widget_ref (valid->canvas_histo);
 586     gtk_object_set_data_full (GTK_OBJECT (main_window),
 587                              "canvas_histo",
 588                              valid->canvas_histo,
 589                              (GtkDestroyNotify) gtk_widget_unref);
 590     gtk_box_pack_start (GTK_BOX (valid->vbox_histo),
 591                        valid->canvas_histo,
 592                        TRUE,
 593                        TRUE,
 594                        0);
 595     gtk_widget_show (valid->canvas_histo);
 596
 597
 598
 599
 600     valid->hbox_histo_buttons = gtk_hbox_new (FALSE,
 601                                                0);
 602     gtk_widget_ref (valid->hbox_histo_buttons);
 603     gtk_object_set_data_full (GTK_OBJECT (main_window),
 604                              "hbox_histo_buttons",
 605                              valid->hbox_histo_buttons,
 606                              (GtkDestroyNotify) gtk_widget_unref);
 607     gtk_widget_show (valid->hbox_histo_buttons);
 608     gtk_box_pack_start (GTK_BOX (valid->vbox_histo),
 609                        valid->hbox_histo_buttons,
 610                        FALSE,
 611                        FALSE,
 612                        0);
 613
 614
 615
 616
 617     valid->button_errvec_resstats =
 618         gtk_button_new_with_label ( _("residu"));
 619     gtk_widget_ref (valid->button_errvec_resstats);
 620     gtk_object_set_data_full (GTK_OBJECT (main_window),
 621                              "button_errvec_resstats",
 622                              valid->button_errvec_resstats,
 623                              (GtkDestroyNotify) gtk_widget_unref);
 624     gtk_widget_show (valid->button_errvec_resstats);
 625     gtk_box_pack_start (GTK_BOX (valid->hbox_histo_buttons),
 626                        valid->button_errvec_resstats,
 627                        FALSE,
 628                        FALSE,
 629                        0);
 630     gtk_tooltips_set_tip(gpiv->tooltips,
 631                          valid->button_errvec_resstats,
 632                           _("calculates residus of displacements "
 633 "and displays in a histogram"),
 634                          NULL);
 635
 636     gtk_object_set_data (GTK_OBJECT (valid->button_errvec_resstats),
 637                         "valid",
 638                         valid);
 639     g_signal_connect (GTK_OBJECT (valid->button_errvec_resstats),
 640                        "enter",
 641                        G_CALLBACK (on_button_valid_errvec_resstats_enter),
 642                        NULL);
 643     g_signal_connect (GTK_OBJECT (valid->button_errvec_resstats),
 644                        "leave",
 645                        G_CALLBACK (on_widget_leave),
 646                        NULL);
 647     g_signal_connect (GTK_OBJECT (valid->button_errvec_resstats),
 648                        "clicked",
 649                        G_CALLBACK (on_button_valid_errvec_resstats),
 650                        NULL);
 651
 652
 653
 654     valid->button_peaklck = gtk_button_new_with_label ( _("sub-pixel"));
 655     gtk_widget_ref (valid->button_peaklck);
 656     gtk_object_set_data_full (GTK_OBJECT (main_window),
 657                              "button_peaklck",
 658                              valid->button_peaklck,
 659                              (GtkDestroyNotify) gtk_widget_unref);
 660     gtk_widget_show (valid->button_peaklck);
 661     gtk_box_pack_start (GTK_BOX (valid->hbox_histo_buttons),
 662                        valid->button_peaklck,
 663                        FALSE,
 664                        FALSE,
 665                        0);
 666     gtk_tooltips_set_tip(gpiv->tooltips,
 667                          valid->button_peaklck,
 668                           _("shows histogram of sub-pixel displacements "
 669 "to check on peak-locking effects"),
 670                          NULL);
 671
 672     gtk_object_set_data (GTK_OBJECT (valid->button_peaklck),
 673                         "valid",
 674                         valid);
 675     g_signal_connect (GTK_OBJECT (valid->button_peaklck),
 676                        "enter",
 677                        G_CALLBACK (on_button_valid_peaklck_enter),
 678                        valid->button_peaklck);
 679     g_signal_connect (GTK_OBJECT (valid->button_peaklck),
 680                        "leave",
 681                        G_CALLBACK (on_widget_leave),
 682                        valid->button_peaklck);
 683     g_signal_connect (GTK_OBJECT (valid->button_peaklck),
 684                        "clicked",
 685                        G_CALLBACK (on_button_valid_peaklck),
 686                        valid->button_peaklck);
 687
 688
 689
 690
 691     valid->button_uhisto = gtk_button_new_with_label ( _("U-comp"));
 692     gtk_widget_ref (valid->button_uhisto);
 693     gtk_object_set_data_full (GTK_OBJECT (main_window),
 694                              "button_uhisto",
 695                              valid->button_uhisto,
 696                              (GtkDestroyNotify) gtk_widget_unref);
 697     gtk_widget_show (valid->button_uhisto);
 698     gtk_box_pack_start (GTK_BOX (valid->hbox_histo_buttons),
 699                        valid->button_uhisto,
 700                        FALSE,
 701                        FALSE,
 702                        0);
 703     gtk_tooltips_set_tip(gpiv->tooltips,
 704                          valid->button_uhisto,
 705                           _("shows histogram of horizontal displacements.\n\
 706 Only this histogram will be saved"),
 707                          NULL);
 708
 709     gtk_object_set_data (GTK_OBJECT (valid->button_uhisto),
 710                         "valid",
 711                         valid);
 712     g_signal_connect (GTK_OBJECT (valid->button_uhisto),
 713                        "enter",
 714                        G_CALLBACK (on_button_valid_uhisto_enter),
 715                        valid->button_uhisto);
 716     g_signal_connect (GTK_OBJECT (valid->button_uhisto),
 717                        "leave",
 718                        G_CALLBACK (on_widget_leave),
 719                        valid->button_uhisto);
 720     g_signal_connect (GTK_OBJECT (valid->button_uhisto),
 721                        "clicked",
 722                        G_CALLBACK (on_button_valid_uhisto),
 723                        valid->button_uhisto);
 724
 725
 726
 727     valid->button_vhisto = gtk_button_new_with_label ( _("V-comp"));
 728     gtk_widget_ref (valid->button_vhisto);
 729     gtk_object_set_data_full (GTK_OBJECT (main_window),
 730                              "button_vhisto",
 731                              valid->button_vhisto,
 732                              (GtkDestroyNotify) gtk_widget_unref);
 733     gtk_widget_show (valid->button_vhisto);
 734     gtk_box_pack_start (GTK_BOX (valid->hbox_histo_buttons),
 735                        valid->button_vhisto,
 736                        FALSE,
 737                        FALSE,
 738                        0);
 739     gtk_tooltips_set_tip(gpiv->tooltips,
 740                          valid->button_vhisto,
 741                           _("shows histogram of vertical displacements.\n\
 742 Only this histogram will be saved"),
 743                          NULL);
 744
 745     gtk_object_set_data (GTK_OBJECT (valid->button_vhisto),
 746                         "valid",
 747                         valid);
 748     g_signal_connect (GTK_OBJECT (valid->button_vhisto),
 749                        "enter",
 750                        G_CALLBACK (on_button_valid_vhisto_enter),
 751                        valid->button_vhisto);
 752     g_signal_connect (GTK_OBJECT (valid->button_vhisto),
 753                        "leave",
 754                        G_CALLBACK (on_widget_leave),
 755                        valid->button_vhisto);
 756     g_signal_connect (GTK_OBJECT (valid->button_vhisto),
 757                        "clicked",
 758                        G_CALLBACK (on_button_valid_vhisto),
 759                        valid->button_vhisto);
 760
 761
 762
 763
 764 /*
 765  * Errvec frame
 766  */
 767     valid->frame_errvec = gtk_frame_new ( _("Outliers"));
 768     gtk_widget_ref (valid->frame_errvec);
 769     gtk_object_set_data_full (GTK_OBJECT (main_window),
 770                              "frame_errvec",
 771                              valid->frame_errvec,
 772                              (GtkDestroyNotify)
 773                              gtk_widget_unref);
 774     gtk_widget_show (valid->frame_errvec);
 775     gtk_table_attach (GTK_TABLE (valid->table),
 776                      valid->frame_errvec,
 777                      1,
 778                      2,
 779                      1,
 780                      2,
 781                      (GtkAttachOptions)(GTK_FILL),
 782                      (GtkAttachOptions)(GTK_SHRINK),
 783                      0,
 784                      0);
 785
 786
 787
 788     valid->vbox_errvec = gtk_vbox_new (FALSE,
 789                                       0);
 790     gtk_widget_ref (valid->vbox_errvec);
 791     gtk_object_set_data_full (GTK_OBJECT (main_window),
 792                              "vbox_errvec",
 793                              valid->vbox_errvec,
 794                              (GtkDestroyNotify) gtk_widget_unref);
 795     gtk_widget_show (valid->vbox_errvec);
 796     gtk_container_add (GTK_CONTAINER (valid->frame_errvec),
 797                       valid->vbox_errvec);
 798
 799
 800
 801 /*
 802  * Spinner for array length of neighboring PIV data
 803  */
 804     valid->hbox_errvec_neighbors_spin = gtk_hbox_new (FALSE,
 805                                                  0);
 806     gtk_widget_ref (valid->hbox_errvec_neighbors_spin);
 807     gtk_object_set_data_full (GTK_OBJECT (main_window),
 808                              "hbox_errvec_neighbors_spin",
 809                              valid->hbox_errvec_neighbors_spin,
 810                              (GtkDestroyNotify) gtk_widget_unref);
 811     gtk_widget_show (valid->hbox_errvec_neighbors_spin);
 812     gtk_box_pack_start (GTK_BOX (valid->vbox_errvec),
 813                                valid->hbox_errvec_neighbors_spin,
 814                        TRUE,
 815                        TRUE,
 816                        0);
 817
 818
 819
 820     valid->label_errvec_neighbors = gtk_label_new ( _("Neighbors: "));
 821     gtk_widget_ref (valid->label_errvec_neighbors);
 822     gtk_object_set_data_full (GTK_OBJECT (main_window),
 823                              "label_errvec_neighbors",
 824                              valid->label_errvec_neighbors,
 825                              (GtkDestroyNotify) gtk_widget_unref);
 826     gtk_widget_show (valid->label_errvec_neighbors);
 827     gtk_box_pack_start (GTK_BOX (valid->hbox_errvec_neighbors_spin),
 828                        valid->label_errvec_neighbors,
 829                        FALSE,
 830                        FALSE,
 831                        0);
 832
 833
 834
 835     valid->spinbutton_adj_errvec_neighbors =
 836         gtk_adjustment_new (gl_valid_par->neighbors,
 837                             3,
 838                             GPIV_VALIDPAR_MAX__NEIGHBORS,
 839                             2,
 840                             2,
 841                             2);
 842     valid->spinbutton_errvec_neighbors =
 843         gtk_spin_button_new (GTK_ADJUSTMENT (valid->spinbutton_adj_errvec_neighbors),
 844                             2,
 845                             0);
 846     gtk_widget_ref (valid->spinbutton_errvec_neighbors);
 847     gtk_object_set_data_full (GTK_OBJECT (main_window),
 848                              "spinbutton_errvec_neighbors",
 849                              valid->spinbutton_errvec_neighbors,
 850                              (GtkDestroyNotify) gtk_widget_unref);
 851     gtk_widget_show (valid->spinbutton_errvec_neighbors);
 852     gtk_box_pack_start (GTK_BOX (valid->hbox_errvec_neighbors_spin),
 853                        valid->spinbutton_errvec_neighbors,
 854                        TRUE,
 855                        TRUE,
 856                        0);
 857
 858     gtk_object_set_data (GTK_OBJECT (valid->spinbutton_errvec_neighbors),
 859                         "valid",
 860                         valid);
 861     g_signal_connect (GTK_OBJECT (valid->spinbutton_errvec_neighbors),
 862                       "changed",
 863                       G_CALLBACK (on_spinbutton_valid_errvec_neighbors),
 864                       NULL);
 865
 866
 867
 868
 869 /*
 870  * Spinner for data yield
 871  */
 872     valid->hbox_errvec_yield_spin = gtk_hbox_new (FALSE,
 873                                                  0);
 874     gtk_widget_ref (valid->hbox_errvec_yield_spin);
 875     gtk_object_set_data_full (GTK_OBJECT (main_window),
 876                              "hbox_errvec_yield_spin",
 877                              valid->hbox_errvec_yield_spin,
 878                              (GtkDestroyNotify) gtk_widget_unref);
 879     gtk_widget_show (valid->hbox_errvec_yield_spin);
 880     gtk_box_pack_start (GTK_BOX (valid->vbox_errvec),
 881                                valid->hbox_errvec_yield_spin,
 882                        TRUE,
 883                        TRUE,
 884                        0);
 885
 886
 887
 888     valid->label_errvec_yield = gtk_label_new ( _("Data yield: "));
 889     gtk_widget_ref (valid->label_errvec_yield);
 890     gtk_object_set_data_full (GTK_OBJECT (main_window),
 891                              "label_errvec_yield",
 892                              valid->label_errvec_yield,
 893                              (GtkDestroyNotify) gtk_widget_unref);
 894     gtk_widget_show (valid->label_errvec_yield);
 895     gtk_box_pack_start (GTK_BOX (valid->hbox_errvec_yield_spin),
 896                        valid->label_errvec_yield,
 897                        FALSE,
 898                        FALSE,
 899                        0);
 900
 901
 902
 903     valid->spinbutton_adj_errvec_yield =
 904         gtk_adjustment_new (gl_valid_par->data_yield,
 905                            0.0,
 906                            1.0,
 907                            0.01,
 908                            0.1,
 909                            0.1);
 910     valid->spinbutton_errvec_yield =
 911         gtk_spin_button_new (GTK_ADJUSTMENT (valid->spinbutton_adj_errvec_yield),
 912                             0.1,
 913                             3);
 914     gtk_widget_ref (valid->spinbutton_errvec_yield);
 915     gtk_object_set_data_full (GTK_OBJECT (main_window),
 916                              "spinbutton_errvec_yield",
 917                              valid->spinbutton_errvec_yield,
 918                              (GtkDestroyNotify) gtk_widget_unref);
 919     gtk_widget_show (valid->spinbutton_errvec_yield);
 920     gtk_box_pack_start (GTK_BOX (valid->hbox_errvec_yield_spin),
 921                        valid->spinbutton_errvec_yield,
 922                        TRUE,
 923                        TRUE,
 924                        0);
 925
 926     gtk_object_set_data (GTK_OBJECT (valid->spinbutton_errvec_yield),
 927                         "valid",
 928                         valid);
 929     g_signal_connect (GTK_OBJECT (valid->spinbutton_errvec_yield),
 930                       "changed",
 931                       G_CALLBACK (on_spinbutton_valid_errvec_yield),
 932                       NULL);
 933
 934
 935
 936
 937 /*
 938  * Spinner for threshold residu
 939  */    valid->hbox_errvec_residu_spin = gtk_hbox_new (FALSE,
 940                                                   0);
 941     gtk_widget_ref (valid->hbox_errvec_residu_spin);
 942     gtk_object_set_data_full (GTK_OBJECT (main_window),
 943                              "hbox_errvec_residu_spin",
 944                              valid->hbox_errvec_residu_spin,
 945                             (GtkDestroyNotify) gtk_widget_unref);
 946     gtk_widget_show (valid->hbox_errvec_residu_spin);
 947     gtk_box_pack_start (GTK_BOX (valid->vbox_errvec),
 948                        valid->hbox_errvec_residu_spin,
 949                        TRUE,
 950                        TRUE,
 951                        0);
 952
 953
 954
 955     valid->label_errvec_res = gtk_label_new ( _("Threshold: "));
 956     gtk_widget_ref (valid->label_errvec_res);
 957     gtk_object_set_data_full (GTK_OBJECT (main_window),
 958                              "label_errvec_res",
 959                              valid->label_errvec_res,
 960                             (GtkDestroyNotify) gtk_widget_unref);
 961     gtk_widget_show (valid->label_errvec_res);
 962     gtk_box_pack_start (GTK_BOX (valid->hbox_errvec_residu_spin),
 963                        valid->label_errvec_res,
 964                        FALSE,
 965                        FALSE,
 966                        0);
 967
 968
 969
 970     valid->spinbutton_adj_errvec_res =
 971         gtk_adjustment_new (gl_valid_par->residu_max,
 972                            0.,
 973                            THRESHOLD_MAX,
 974                            0.1,
 975                            1.0,
 976                            1.0);
 977     valid->spinbutton_errvec_res =
 978         gtk_spin_button_new (GTK_ADJUSTMENT (valid->spinbutton_adj_errvec_res),
 979                             0.1,
 980                             3);
 981     gtk_widget_ref (valid->spinbutton_errvec_res);
 982     gtk_object_set_data_full (GTK_OBJECT (main_window),
 983                              "spinbutton_errvec_res",
 984                              valid->spinbutton_errvec_res,
 985                             (GtkDestroyNotify) gtk_widget_unref);
 986     gtk_widget_show (valid->spinbutton_errvec_res);
 987     gtk_box_pack_start (GTK_BOX (valid->hbox_errvec_residu_spin),
 988                        valid->spinbutton_errvec_res,
 989                        TRUE,
 990                        TRUE,
 991                        0);
 992
 993     gtk_object_set_data (GTK_OBJECT (valid->spinbutton_errvec_res),
 994                         "valid",
 995                         valid);
 996     g_signal_connect (GTK_OBJECT (valid->spinbutton_errvec_res),
 997                       "changed",
 998                       G_CALLBACK (on_spinbutton_valid_errvec_res),
 999                       NULL);
1000
1001
1002
1003
1004     valid->checkbutton_errvec_disres =
1005         gtk_check_button_new_with_label ( _("Show SNR values"));
1006     gtk_widget_ref (valid->checkbutton_errvec_disres);
1007     gtk_object_set_data_full (GTK_OBJECT (main_window),
1008                              "checkbutton_errvec_disres",
1009                              valid->checkbutton_errvec_disres,
1010                             (GtkDestroyNotify) gtk_widget_unref);
1011     gtk_widget_show (valid->checkbutton_errvec_disres);
1012     gtk_box_pack_start (GTK_BOX (valid->vbox_errvec),
1013                        valid->checkbutton_errvec_disres,
1014                        FALSE,
1015                        FALSE,
1016                        0);
1017
1018     gtk_object_set_data (GTK_OBJECT (valid->checkbutton_errvec_disres),
1019                         "valid",
1020                         valid);
1021     g_signal_connect (GTK_OBJECT (valid->checkbutton_errvec_disres),
1022                        "enter",
1023                        G_CALLBACK
1024                       (on_checkbutton_valid_errvec_disres_enter),
1025                        NULL);
1026     g_signal_connect (GTK_OBJECT (valid->checkbutton_errvec_disres),
1027                        "leave",
1028                        G_CALLBACK (on_widget_leave),
1029                        NULL);
1030     g_signal_connect (GTK_OBJECT (valid->checkbutton_errvec_disres),
1031                        "toggled",
1032                        G_CALLBACK (on_checkbutton_valid_errvec_disres),
1033                        NULL);
1034     if (v_color == SHOW_SNR) {
1035         gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON
1036                                    (valid->checkbutton_errvec_disres),
1037                                     TRUE);
1038     }
1039
1040
1041
1042     valid->frame_errvec_residu = gtk_frame_new ( _("Residu type:"));
1043     gtk_widget_ref (valid->frame_errvec_residu);
1044     gtk_object_set_data_full (GTK_OBJECT (main_window),
1045                              "frame_errvec_residu",
1046                               valid->frame_errvec_residu,
1047                              (GtkDestroyNotify) gtk_widget_unref);
1048     gtk_widget_show (valid->frame_errvec_residu);
1049     gtk_box_pack_start (GTK_BOX (valid->vbox_errvec),
1050                        valid->frame_errvec_residu,
1051                        FALSE,
1052                        FALSE,
1053                        0);
1054     gtk_frame_set_shadow_type (GTK_FRAME (valid->frame_errvec_residu),
1055                               GTK_SHADOW_NONE);
1056
1057
1058
1059     valid->vbox_errvec_residu = gtk_vbox_new (FALSE,
1060                                              0);
1061     gtk_widget_ref (valid->vbox_errvec_residu);
1062     gtk_object_set_data_full (GTK_OBJECT (main_window),
1063                              "vbox_errvec_residu",
1064                              valid->vbox_errvec_residu,
1065                              (GtkDestroyNotify) gtk_widget_unref);
1066     gtk_widget_show (valid->vbox_errvec_residu);
1067     gtk_container_add (GTK_CONTAINER (valid->frame_errvec_residu),
1068                       valid->vbox_errvec_residu);
1069
1070
1071
1072     valid->radiobutton_errvec_residu_normmedian =
1073         gtk_radio_button_new_with_label (valid->vbox_errvec_residu_group,
1074                                         _("Normalized median"));
1075     valid->vbox_errvec_residu_group =
1076         gtk_radio_button_group (GTK_RADIO_BUTTON
1077                                (valid->radiobutton_errvec_residu_normmedian));
1078     gtk_widget_ref (valid->radiobutton_errvec_residu_normmedian);
1079     gtk_object_set_data_full (GTK_OBJECT (main_window),
1080                              "radiobutton_errvec_residu_normmedian",
1081                              valid->radiobutton_errvec_residu_normmedian,
1082                              (GtkDestroyNotify) gtk_widget_unref);
1083     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_residu_normmedian),
1084                         "valid",
1085                         valid);
1086     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_residu_normmedian),
1087                         "residu",
1088                         "2");
1089      gtk_widget_show (valid->radiobutton_errvec_residu_normmedian);
1090      gtk_box_pack_start (GTK_BOX (valid->vbox_errvec_residu),
1091                         valid->radiobutton_errvec_residu_normmedian,
1092                         FALSE,
1093                         FALSE,
1094                         0);
1095     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_residu_normmedian),
1096                        "enter",
1097                        G_CALLBACK
1098                        (on_radiobutton_valid_errvec_residu_enter),
1099                        NULL);
1100     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_residu_normmedian),
1101                        "leave",
1102                        G_CALLBACK (on_widget_leave),
1103                        NULL);
1104     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_residu_normmedian),
1105                        "clicked",
1106                        G_CALLBACK (on_radiobutton_valid_errvec_residu),
1107                        NULL);
1108     if (gl_valid_par->residu_type == 2) {
1109         gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON
1110                                     (valid->radiobutton_errvec_residu_normmedian),
1111                                     TRUE);
1112     }
1113
1114
1115
1116     valid->radiobutton_errvec_residu_median =
1117         gtk_radio_button_new_with_label (valid->vbox_errvec_residu_group,
1118                                         _("Median"));
1119     valid->vbox_errvec_residu_group =
1120         gtk_radio_button_group (GTK_RADIO_BUTTON
1121                                (valid->radiobutton_errvec_residu_median));
1122     gtk_widget_ref (valid->radiobutton_errvec_residu_median);
1123     gtk_object_set_data_full (GTK_OBJECT (main_window),
1124                              "radiobutton_errvec_residu_median",
1125                              valid->radiobutton_errvec_residu_median,
1126                              (GtkDestroyNotify) gtk_widget_unref);
1127     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_residu_median),
1128                         "valid",
1129                         valid);
1130     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_residu_median),
1131                         "residu",
1132                         "1");
1133      gtk_widget_show (valid->radiobutton_errvec_residu_median);
1134      gtk_box_pack_start (GTK_BOX (valid->vbox_errvec_residu),
1135                         valid->radiobutton_errvec_residu_median,
1136                         FALSE,
1137                         FALSE,
1138                         0);
1139     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_residu_median),
1140                        "enter",
1141                        G_CALLBACK
1142                        (on_radiobutton_valid_errvec_residu_enter),
1143                        NULL);
1144     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_residu_median),
1145                        "leave",
1146                        G_CALLBACK (on_widget_leave),
1147                        NULL);
1148     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_residu_median),
1149                        "clicked",
1150                        G_CALLBACK (on_radiobutton_valid_errvec_residu),
1151                        NULL);
1152     if (gl_valid_par->residu_type == 1) {
1153         gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON
1154                                     (valid->radiobutton_errvec_residu_median),
1155                                     TRUE);
1156     }
1157
1158
1159
1160     valid->radiobutton_errvec_residu_snr =
1161         gtk_radio_button_new_with_label (valid->vbox_errvec_residu_group,
1162                                          _("Snr"));
1163     valid->vbox_errvec_residu_group =
1164         gtk_radio_button_group (GTK_RADIO_BUTTON
1165                                (valid->radiobutton_errvec_residu_snr));
1166     gtk_widget_ref (valid->radiobutton_errvec_residu_snr);
1167     gtk_object_set_data_full (GTK_OBJECT (main_window),
1168                              "radiobutton_errvec_residu_snr",
1169                              valid->radiobutton_errvec_residu_snr,
1170                              (GtkDestroyNotify) gtk_widget_unref);
1171     gtk_widget_show (valid->radiobutton_errvec_residu_snr);
1172     gtk_box_pack_start (GTK_BOX (valid->vbox_errvec_residu),
1173                        valid->radiobutton_errvec_residu_snr,
1174                        FALSE,
1175                        FALSE,
1176                        0);
1177
1178     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_residu_snr),
1179                         "valid",
1180                         valid);
1181     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_residu_snr),
1182                         "residu",
1183                         "0");
1184     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_residu_snr),
1185                        "enter",
1186                        G_CALLBACK
1187                        (on_radiobutton_valid_errvec_residu_enter),
1188                        NULL);
1189     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_residu_snr),
1190                        "leave",
1191                        G_CALLBACK (on_widget_leave),
1192                        NULL);
1193     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_residu_snr),
1194                        "toggled",
1195                        G_CALLBACK (on_radiobutton_valid_errvec_residu),
1196                        NULL);
1197     if (gl_valid_par->residu_type == 0) {
1198         gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON
1199                                     (valid->radiobutton_errvec_residu_snr),
1200                                     TRUE);
1201     }
1202
1203
1204
1205 /*
1206  * A long time ago, the GtkWidget  valid->button_errvec_resstats was *here*.
1207  * Though it felt in love with valid->button_peaklock.
1208  * Now they are living  happily cheeck tot cheeck.
1209  * No, they haven't got child widgets, yet. But maybe, one day ...
1210  */
1211
1212
1213 /*
1214  * Radio buttons for substitution type
1215  */
1216     valid->frame_errvec_subst = gtk_frame_new ( _("Substituted by:"));
1217     gtk_widget_ref (valid->frame_errvec_subst);
1218     gtk_object_set_data_full (GTK_OBJECT (main_window),
1219                              "frame_errvec_subst",
1220                              valid->frame_errvec_subst,
1221                             (GtkDestroyNotify) gtk_widget_unref);
1222     gtk_widget_show (valid->frame_errvec_subst);
1223     gtk_box_pack_start (GTK_BOX (valid->vbox_errvec),
1224                        valid->frame_errvec_subst,
1225                        FALSE,
1226                        FALSE,
1227                        0);
1228     gtk_frame_set_shadow_type (GTK_FRAME (valid->frame_errvec_subst),
1229                               GTK_SHADOW_NONE);
1230
1231
1232
1233     valid->vbox_errvec_subst = gtk_vbox_new (FALSE,
1234                                             0);
1235     gtk_widget_ref (valid->vbox_errvec_subst);
1236     gtk_object_set_data_full (GTK_OBJECT (main_window),
1237                              "vbox_errvec_subst",
1238                              valid->vbox_errvec_subst,
1239                             (GtkDestroyNotify) gtk_widget_unref);
1240     gtk_widget_show (valid->vbox_errvec_subst);
1241     gtk_container_add (GTK_CONTAINER (valid->frame_errvec_subst),
1242                       valid->vbox_errvec_subst);
1243
1244
1245
1246
1247     valid->radiobutton_errvec_subst_0 =
1248         gtk_radio_button_new_with_label(valid->vbox_errvec_subst_group,
1249                                          _("Nothing"));
1250     valid->vbox_errvec_subst_group =
1251         gtk_radio_button_group (GTK_RADIO_BUTTON
1252                                (valid->radiobutton_errvec_subst_0));
1253     gtk_widget_ref(valid->radiobutton_errvec_subst_0);
1254     gtk_object_set_data_full (GTK_OBJECT (main_window),
1255                              "radiobutton_errvec_subst_0",
1256                              valid->radiobutton_errvec_subst_0,
1257                              (GtkDestroyNotify) gtk_widget_unref);
1258     gtk_widget_show(valid->radiobutton_errvec_subst_0);
1259     gtk_box_pack_start (GTK_BOX(valid->vbox_errvec_subst),
1260                        valid->radiobutton_errvec_subst_0,
1261                        FALSE,
1262                        FALSE,
1263                        0);
1264
1265     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_subst_0),
1266                         "valid",
1267                         valid);
1268     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_subst_0),
1269                         "substitute",
1270                         "0" /* GPIV_VALID_SUBSTYPE__NONE */);
1271     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_subst_0),
1272                        "enter",
1273                        G_CALLBACK
1274                        (on_radiobutton_valid_errvec_subst_enter),
1275                        NULL);
1276     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_subst_0),
1277                        "leave",
1278                        G_CALLBACK (on_widget_leave),
1279                        NULL);
1280     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_subst_0),
1281                        "toggled",
1282                        G_CALLBACK (on_radiobutton_valid_errvec_subst),
1283                        NULL);
1284     if (gl_valid_par->subst_type == GPIV_VALID_SUBSTYPE__NONE) {
1285         gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON
1286                                     (valid->radiobutton_errvec_subst_0),
1287                                     TRUE);
1288     }
1289
1290
1291
1292 /*
1293  * Substitute by mean of surroundings
1294  */
1295     valid->radiobutton_errvec_subst_1 =
1296         gtk_radio_button_new_with_label (valid->vbox_errvec_subst_group,
1297                                          _("Mean of surroundings"));
1298     valid->vbox_errvec_subst_group =
1299         gtk_radio_button_group (GTK_RADIO_BUTTON
1300                               (valid->radiobutton_errvec_subst_1));
1301     gtk_widget_ref (valid->radiobutton_errvec_subst_1);
1302     gtk_object_set_data_full (GTK_OBJECT (main_window),
1303                              "radiobutton_errvec_subst_1",
1304                              valid->radiobutton_errvec_subst_1,
1305                              (GtkDestroyNotify) gtk_widget_unref);
1306     gtk_widget_show(valid->radiobutton_errvec_subst_1);
1307     gtk_box_pack_start (GTK_BOX(valid->vbox_errvec_subst),
1308                        valid->radiobutton_errvec_subst_1,
1309                        FALSE,
1310                        FALSE,
1311                        0);
1312
1313     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_subst_1),
1314                         "valid",
1315                         valid);
1316     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_subst_1),
1317                         "substitute",
1318                         "1" /* GPIV_VALID_SUBSTYPE__L_MEAN */);
1319     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_subst_1),
1320                        "enter",
1321                        G_CALLBACK
1322                       (on_radiobutton_valid_errvec_subst_enter),
1323                        NULL);
1324     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_subst_1),
1325                        "leave",
1326                        G_CALLBACK (on_widget_leave),
1327                        NULL);
1328     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_subst_1),
1329                        "toggled",
1330                        G_CALLBACK (on_radiobutton_valid_errvec_subst),
1331                        NULL);
1332
1333
1334
1335 /*
1336  * Substitute by median of surroundings
1337  */
1338     valid->radiobutton_errvec_subst_2 =
1339       gtk_radio_button_new_with_label (valid->vbox_errvec_subst_group,
1340                                         _("Median"));
1341     valid->vbox_errvec_subst_group =
1342       gtk_radio_button_group  (GTK_RADIO_BUTTON
1343                               (valid->radiobutton_errvec_subst_2));
1344     gtk_widget_ref (valid->radiobutton_errvec_subst_2);
1345     gtk_object_set_data_full  (GTK_OBJECT (main_window),
1346                               "radiobutton_errvec_subst_2",
1347                               valid->radiobutton_errvec_subst_2,
1348                               (GtkDestroyNotify) gtk_widget_unref);
1349    gtk_widget_show (valid->radiobutton_errvec_subst_2);
1350    gtk_box_pack_start  (GTK_BOX (valid->vbox_errvec_subst),
1351                        valid->radiobutton_errvec_subst_2,
1352                        FALSE,
1353                        FALSE,
1354                        0);
1355
1356    gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_subst_2),
1357                        "valid",
1358                        valid);
1359    gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_subst_2),
1360                        "substitute",
1361                        "2" /* GPIV_VALID_SUBSTYPE__MEDIAN */);
1362    g_signal_connect  (GTK_OBJECT (valid->radiobutton_errvec_subst_2),
1363                        "enter",
1364                        G_CALLBACK(on_radiobutton_valid_errvec_subst_enter),
1365                        NULL);
1366    g_signal_connect  (GTK_OBJECT (valid->radiobutton_errvec_subst_2),
1367                        "leave",
1368                        G_CALLBACK (on_widget_leave),
1369                        NULL);
1370    g_signal_connect  (GTK_OBJECT (valid->radiobutton_errvec_subst_2),
1371                        "toggled",
1372                        G_CALLBACK (on_radiobutton_valid_errvec_subst),
1373                        NULL);
1374    if (gl_valid_par->subst_type == GPIV_VALID_SUBSTYPE__MEDIAN ) {
1375      gtk_toggle_button_set_state  (GTK_TOGGLE_BUTTON
1376                                   (valid->radiobutton_errvec_subst_2),
1377                                   TRUE);
1378    }
1379
1380
1381
1382     valid->radiobutton_errvec_subst_3 =
1383         gtk_radio_button_new_with_label (valid->vbox_errvec_subst_group,
1384                                          _("Next highest corr. peak"));
1385     valid->vbox_errvec_subst_group =
1386         gtk_radio_button_group (GTK_RADIO_BUTTON
1387                               (valid->radiobutton_errvec_subst_3));
1388     gtk_widget_ref (valid->radiobutton_errvec_subst_3);
1389     gtk_object_set_data_full (GTK_OBJECT (main_window),
1390                              "radiobutton_errvec_subst_3",
1391                              valid->radiobutton_errvec_subst_3,
1392                             (GtkDestroyNotify) gtk_widget_unref);
1393     gtk_widget_show (valid->radiobutton_errvec_subst_3);
1394     gtk_box_pack_start (GTK_BOX (valid->vbox_errvec_subst),
1395                        valid->radiobutton_errvec_subst_3,
1396                        FALSE,
1397                        FALSE,
1398                        0);
1399
1400     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_subst_3),
1401                         "valid",
1402                         valid);
1403     gtk_object_set_data (GTK_OBJECT (valid->radiobutton_errvec_subst_3),
1404                         "substitute",
1405                         "3" /* GPIV_VALID_SUBSTYPE__COV_PEAK */);
1406     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_subst_3),
1407                        "enter",
1408                        G_CALLBACK
1409                        (on_radiobutton_valid_errvec_subst_enter),
1410                        NULL);
1411     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_subst_3),
1412                        "leave",
1413                        G_CALLBACK (on_widget_leave),
1414                        NULL);
1415     g_signal_connect (GTK_OBJECT (valid->radiobutton_errvec_subst_3),
1416                        "toggled",
1417                        G_CALLBACK (on_radiobutton_valid_errvec_subst),
1418                        NULL);
1419     if (gl_valid_par->subst_type == GPIV_VALID_SUBSTYPE__COR_PEAK) {
1420         gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON
1421                                     (valid->radiobutton_errvec_subst_3),
1422                                     TRUE);
1423     }
1424
1425
1426
1427     valid->button_errvec =
1428         gtk_button_new_with_label ( _("validate on outliers"));
1429     gtk_widget_ref (valid->button_errvec);
1430     gtk_object_set_data_full (GTK_OBJECT (main_window),
1431                              "button_errvec",
1432                              valid->button_errvec,
1433                              (GtkDestroyNotify) gtk_widget_unref);
1434    gtk_widget_show (valid->button_errvec);
1435     gtk_box_pack_start (GTK_BOX (valid->vbox_errvec),
1436                        valid->button_errvec,
1437                        FALSE,
1438                        FALSE,
1439                        0);
1440     gtk_tooltips_set_tip(gpiv->tooltips,
1441                          valid->button_errvec,
1442                           _("substitutes outliers"),
1443                          NULL);
1444
1445     gtk_object_set_data (GTK_OBJECT (valid->button_errvec),
1446                         "valid",
1447                         valid);
1448     g_signal_connect (GTK_OBJECT (valid->button_errvec),
1449                        "enter",
1450                        G_CALLBACK (on_button_valid_errvec_enter),
1451                        NULL);
1452     g_signal_connect (GTK_OBJECT (valid->button_errvec),
1453                        "leave",
1454                        G_CALLBACK (on_widget_leave),
1455                        NULL);
1456     g_signal_connect (GTK_OBJECT (valid->button_errvec),
1457                        "clicked",
1458                        G_CALLBACK (on_button_valid_errvec),
1459                        NULL);
1460
1461
1462     return valid;
1463 }
1464
1465
1466
1467