app_view.C

Go to the documentation of this file.
00001 /* Gxsm - Gnome X Scanning Microscopy
00002  * universal STM/AFM/SARLS/SPALEED/... controlling and
00003  * data analysis software
00004  * 
00005  * Copyright (C) 1999,2000,2001,2002,2003 Percy Zahl
00006  *
00007  * Authors: Percy Zahl <zahl@users.sf.net>
00008  * additional features: Andreas Klust <klust@users.sf.net>
00009  * WWW Home: http://gxsm.sf.net
00010  *
00011  * This program is free software; you can redistribute it and/or modify
00012  * it under the terms of the GNU General Public License as published by
00013  * the Free Software Foundation; either version 2 of the License, or
00014  * (at your option) any later version.
00015  *
00016  * This program is distributed in the hope that it will be useful,
00017  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  * GNU General Public License for more details.
00020  *
00021  * You should have received a copy of the GNU General Public License
00022  * along with this program; if not, write to the Free Software
00023  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
00024  */
00025 
00026 /* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 8 c-style: "K&R" -*- */
00027 
00028 
00029 #include <locale.h>
00030 #include <libintl.h>
00031 
00032 #include "gxsm_app.h"
00033 
00034 #include "unit.h"
00035 #include "pcs.h"
00036 #include "xsmtypes.h"
00037 #include "action_id.h"
00038 #include "glbvars.h"
00039 
00040 #include "app_profile.h"
00041 #include "app_vobj.h"
00042 #include "app_vinfo.h"
00043 #include "app_view.h"
00044 #include "app_vpopupdef.h"
00045 
00046 #define OUT_OF_RANGE _("Value out of range!")
00047 
00048 #define VIEW_PREFIX "AppView_"
00049 
00050 #define OB_MARKER_SCALE (1./vc->vinfo->GetZfac())
00051 
00052 
00053 #define APP_EC_SPIN(EC, LABEL, UNIT, ERROR_TEXT, VAR, LO, HI, FMT, STEP, PAGE) \
00054         do{\
00055                 label = gtk_label_new (_(LABEL));       \
00056                 gtk_widget_show (label);\
00057                 gtk_box_pack_start (GTK_BOX (hbox_param), label, FALSE, FALSE, GNOME_PAD); \
00058                 GtkWidget *input = mygtk_add_spin(hbox_param);          \
00059                 gtk_object_set_data (GTK_OBJECT (input), "Adjustment_PCS_Name", (void*)(VIEW_PREFIX LABEL)); \
00060                 EC = new Gtk_EntryControl (UNIT, _(ERROR_TEXT), VAR, LO, HI, FMT, input, STEP, PAGE); \
00061         }while(0)
00062 
00063 #define APP_SELECTOR(CB, LABEL) \
00064         do{\
00065                 if (strlen (LABEL)){                            \
00066                         label = gtk_label_new (_(LABEL));       \
00067                         gtk_widget_show (label);                        \
00068                         gtk_box_pack_start (GTK_BOX (hbox_param), label, FALSE, FALSE, GNOME_PAD); \
00069                 } \
00070                 CB = gtk_combo_box_new_text (); \
00071                 gtk_widget_show (CB); \
00072                 gtk_box_pack_start (GTK_BOX (hbox_param), CB, FALSE, FALSE, GNOME_PAD); \
00073         }while(0)
00074 
00075 #define ADD_TOGGLE(TOG, LABEL, DEFAULT)                 \
00076         do {\
00077                    TOG = gtk_check_button_new_with_label(_(LABEL)); \
00078                    gtk_widget_show (TOG);                               \
00079                    gtk_box_pack_start (GTK_BOX (hbox_param), TOG, FALSE, FALSE, GNOME_PAD); \
00080                    GTK_TOGGLE_BUTTON (TOG)->active = (DEFAULT)?1:0;             \
00081         }while(0)
00082 //                   g_signal_connect (TOG, "toggled",G_CALLBACK(CB_FUNC), this);
00083 
00084 VObject *current_vobject = NULL;
00085 
00086 ViewControl::ViewControl (char *title, int nx, int ny, 
00087                           int ChNo, Scan *sc, 
00088                           int ZoomFac, int QuenchFac){
00089         GtkWidget *statusbar;
00090         GtkWidget *scrollarea;
00091         GtkWidget *vbox_param;
00092         GtkWidget *hbox_param;
00093         GtkWidget *label;
00094         const int border=6;
00095         const int activeframe=8;
00096         rulewidth = 0;
00097         const double statusheight = 36.;
00098         int  usx=MIN((nx+rulewidth+2*border+20), (2*gdk_screen_width()/3));
00099         int  usy=MIN((int)(ny+rulewidth+2*border+statusheight+40), (2*gdk_screen_height()/3));
00100 
00101         active_event = NULL; 
00102         gobjlist = NULL;
00103         geventlist = NULL;
00104         event_filter = NULL;
00105         RedLine  = NULL;
00106         EventPlot = NULL;
00107         v_trace  = NULL;
00108         AddObjFkt = ViewControl::view_tool_addrectangle;
00109         ZoomQFkt = NULL;
00110         scan = sc;
00111         scan->RedLineActive = FALSE;
00112         chno=ChNo;
00113         local_radius = 10;
00114         npx = nx;
00115         npy = ny;
00116         vinfo = new ViewInfo(scan, QuenchFac, ZoomFac);
00117         
00118         CursorXYVt[0]=0.;
00119         CursorXYVt[1]=0.;
00120         CursorXYVt[2]=0.;
00121         CursorXYVt[3]=0.;
00122 
00123         AppWidgetInit (title);
00124         gtk_object_set_data  (GTK_OBJECT (widget), "Ch", (void*)ChNo);
00125         gtk_object_set_data  (GTK_OBJECT (widget), "ChNo", (void*)(ChNo+1));
00126         gtk_object_set_data  (GTK_OBJECT (widget), "ViewControl", this);
00127         gapp->configure_drop_on_widget(widget);
00128         
00129         XSM_DEBUG (DBG_L2,  "VC::VC set_default_size" );
00130         gtk_window_set_default_size(GTK_WINDOW(widget), usx, usy);
00131         
00132         // Make Vbox
00133         //  vbox = gtk_vbox_new (FALSE,1);
00134         
00135         // New Scrollarea
00136         
00137         XSM_DEBUG (DBG_L2,  "VC::VC scrollwindownew" );
00138         scrollarea = gtk_scrolled_window_new (NULL, NULL);
00139         gtk_container_set_border_width (GTK_CONTAINER (scrollarea), 0);
00140         
00141         /* the policy is one of GTK_POLICY AUTOMATIC, or GTK_POLICY_ALWAYS.
00142          * GTK_POLICY_AUTOMATIC will automatically decide whether you need
00143          * scrollbars, whereas GTK_POLICY_ALWAYS will always leave the scrollbars
00144          * there.  The first one is the horizontal scrollbar, the second, 
00145          * the vertical. */
00146         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollarea),
00147                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
00148         
00149         gtk_box_pack_start (GTK_BOX (vbox), scrollarea, TRUE, TRUE, 0);
00150         gtk_widget_show (scrollarea);
00151 
00152         vbox_param = vbox;
00153         hbox_param = gtk_hbox_new (FALSE, 0);
00154         gtk_box_pack_start (GTK_BOX (vbox), hbox_param, FALSE, FALSE, 0);
00155         control_box = hbox_param;
00156 
00157         // Events Control ----------------------------------------
00158         XsmRescourceManager xrm("App_View");
00159         xrm.Get ("CursorRadius", &CursorRadius, "100.");
00160         xrm.Get ("MaxNumberEventsCursorRadius", &MaxNumberEvents, "30");
00161         xrm.Get ("ArrowSize", &ArrowSize, "25.");
00162 
00163         APP_EC_SPIN (ec_radius, "Radius", gapp->xsm->LenUnit, OUT_OF_RANGE, &CursorRadius, 0., 100000., ".1f", 10., 100.);
00164         APP_EC_SPIN (ec_number, "Events", gapp->xsm->Unity, OUT_OF_RANGE, &MaxNumberEvents, 0., 500., ".0f", 1., 10.);
00165         APP_EC_SPIN (ec_arrowsize, "Arrow-Size", gapp->xsm->Unity, OUT_OF_RANGE, &ArrowSize, 0., 200., ".1f", 1., 10.);
00166         gtk_widget_hide (control_box);
00167 
00168 
00169 
00170         hbox_param = gtk_hbox_new (FALSE, 0);
00171         gtk_box_pack_start (GTK_BOX (vbox), hbox_param, FALSE, FALSE, 0);
00172         control_box_event_xysel = hbox_param;
00173 
00174 //      label = gtk_label_new (_("---"));
00175 //      gtk_widget_show (label);
00176 //      gtk_box_pack_start (GTK_BOX (hbox_param), label, FALSE, FALSE, GNOME_PAD);
00177 
00178         APP_SELECTOR (active_event_list, "");
00179         APP_SELECTOR (active_event_xchan, "X");
00180         APP_SELECTOR (active_event_ychan, "Y");
00181         gtk_widget_hide (control_box_event_xysel);
00182 
00183 //      gtk_combo_box_append_text (GTK_COMBO_BOX (active_event_list), "---");
00184         gtk_combo_box_append_text (GTK_COMBO_BOX (active_event_xchan), "Index");
00185         gtk_combo_box_append_text (GTK_COMBO_BOX (active_event_ychan), "Index");
00186         active_event_num_channels = 0;
00187         active_event_num_events = 0;
00188         gtk_combo_box_set_active (GTK_COMBO_BOX (active_event_list), 0);
00189         gtk_combo_box_set_active (GTK_COMBO_BOX (active_event_xchan), 0);
00190         gtk_combo_box_set_active (GTK_COMBO_BOX (active_event_ychan), 0);
00191 
00192         GtkWidget* button = gtk_button_new_with_label(N_("Plot"));
00193         gtk_box_pack_start (GTK_BOX (hbox_param), button, FALSE, FALSE, GNOME_PAD);
00194         gtk_widget_show (button);
00195         gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (ViewControl:: obj_event_plot_callback), this);
00196 
00197         ADD_TOGGLE (tog_plot, "auto", 0);
00198         ADD_TOGGLE (tog_average, "all", 0);
00199 
00200         // PopUp ----------------------------------------
00201         XSM_DEBUG (DBG_L2,  "VC::VC popup" );
00202         // New PopUp Menu
00203         GtkAccelGroup *accel_group;
00204         accel_group = gtk_accel_group_new ();
00205         gtk_window_add_accel_group (GTK_WINDOW (widget), accel_group); 
00206         VPopup = (GtkWidget*)gnome_popup_menu_new_with_accelgroup (scan_popup_menu, accel_group);
00207 
00208 /*
00209         // look for GXSM->Math menushell and attach to the popup
00210         GtkWidget *main_math_menu;
00211         gint pos;
00212         gchar *tmp_mpath = g_strconcat (N_("_Math"), NULL);
00213         main_math_menu = gnome_app_find_menu_pos (gapp->gxsmmenu, tmp_mpath, &pos);
00214         g_free (tmp_mpath);
00215         gtk_menu_shell_insert (GTK_MENU_SHELL (VPopup), main_math_menu, 6);
00216         ??? - did not work this way ???
00217         ??? - data will be overwritten at popup attach... -- cannot work:-( ???
00218 */
00219 
00220         gnome_popup_menu_attach (VPopup, widget, this);
00221         gtk_object_set_data (GTK_OBJECT (VPopup), "gnome_popup_menu_do_popup_user_data", this);
00222 
00223         // Setup initial Menu Toggleitem states
00224         gapp->SetupToggleMenuItem(VPopup, "View/Autozoom", TRUE);
00225 //      gapp->SetupToggleMenuItem(VPopup, "View/Direct", TRUE);
00226         
00227         
00228         // New Statusbar
00229         statusbar = gtk_statusbar_new ();
00230         gtk_object_set_data (GTK_OBJECT (widget), "statusbar", statusbar);
00231         gtk_widget_show (statusbar);
00232         gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, TRUE, 0);
00233         
00234         XSM_DEBUG (DBG_L2,  "VC::VC canvas" );
00235         // Setup Canvas
00236         if(xsmres.antialiascanvas){
00237                 gtk_widget_push_visual(gdk_rgb_get_visual());
00238                 gtk_widget_push_colormap(gdk_rgb_get_cmap());
00239                 canvas = gnome_canvas_new_aa();
00240                 gtk_widget_pop_colormap();
00241                 gtk_widget_pop_visual();
00242         }else{
00243                 canvas = gnome_canvas_new();
00244                 gtk_widget_pop_visual();
00245                 gtk_widget_pop_colormap();
00246         }
00247         
00248         XSM_DEBUG (DBG_L2,  "VC::VC data attach" );
00249         gtk_object_set_data (GTK_OBJECT (canvas), "statusbar", statusbar);
00250         gtk_object_set_data (GTK_OBJECT (canvas), "ViewInfo", vinfo);
00251         gtk_object_set_data (GTK_OBJECT (canvas), "Ch", (void*)ChNo);
00252         gtk_object_set_data (GTK_OBJECT (canvas), "ViewControl", this);
00253         gtk_object_set_data (GTK_OBJECT (canvas), "Scan", scan);
00254         
00255         gtk_object_set_data (GTK_OBJECT (canvas), "viewpopup", VPopup);
00256         
00257         
00258         gtk_object_set_data (GTK_OBJECT (canvas), "ObjPopupEvent", 
00259                              gnome_popup_menu_new (vobj_popup_menu_event));
00260         gtk_object_set_data (GTK_OBJECT (canvas), "ObjPopup1", 
00261                              gnome_popup_menu_new (vobj_popup_menu_1));
00262         gtk_object_set_data (GTK_OBJECT (canvas), "ObjPopup2", 
00263                              gnome_popup_menu_new (vobj_popup_menu_2));
00264         gtk_object_set_data (GTK_OBJECT (canvas), "ObjPopupN", 
00265                              gnome_popup_menu_new (vobj_popup_menu_n));
00266         
00267         gnome_canvas_set_pixels_per_unit( GNOME_CANVAS(canvas), (double)ZoomFac);
00268         gnome_canvas_set_scroll_region (
00269                 GNOME_CANVAS(canvas), 
00270                 (double)(-rulewidth-border/ZoomFac), (double)(-rulewidth-border/ZoomFac), 
00271                 (double)((nx+border)/ZoomFac), (double)((ny+border)/ZoomFac)
00272                 );
00273         
00274         XSM_DEBUG (DBG_L2,  "VC::VC ximg" );
00275         // setup image object into canvas
00276         ximg = new ShmImage2D(canvas,nx/ZoomFac,ny/ZoomFac,0,0);
00277         
00278         XSM_DEBUG (DBG_L2,  "VC::VC ActiveFrame" );
00279         ActiveFrame = gnome_canvas_item_new (
00280                 gnome_canvas_root( GNOME_CANVAS(canvas)),
00281                 gnome_canvas_rect_get_type(),
00282                 "x1",(double)(-activeframe/ZoomFac),
00283                 "y1",(double)(-activeframe/ZoomFac),
00284                 "x2",(double)((nx+activeframe)/ZoomFac),
00285                 "y2",(double)((ny+activeframe)/ZoomFac),
00286                 "outline_color","yellow",
00287                 "width_pixels", activeframe/2,
00288                 NULL);
00289         
00290         XSM_DEBUG (DBG_L2,  "VC::VC signal connect" );
00291         gtk_signal_connect (GTK_OBJECT(ximg->GetGimg()), "event",
00292                             (GtkSignalFunc) ViewControl::canvas_event_cb,
00293                             this);
00294         
00295         XSM_DEBUG (DBG_L2,  "VC::VC container add canvas" );
00296         gtk_container_add (GTK_CONTAINER(scrollarea), canvas);
00297         
00298         XSM_DEBUG (DBG_L2,  "VC::VC setevents canvas" );
00299         gtk_widget_set_events (canvas, GDK_POINTER_MOTION_MASK |
00300                                GDK_POINTER_MOTION_HINT_MASK );
00301         
00302         XSM_DEBUG (DBG_L2,  "VC::VC show" );
00303         gtk_widget_show( canvas );
00304 }
00305 
00306 ViewControl::~ViewControl (){
00307         XSM_DEBUG (DBG_L2,  "~ViewControl" );
00308         
00309         XsmRescourceManager xrm("App_View");
00310         xrm.Put ("CursorRadius", CursorRadius);
00311         xrm.Put ("MaxNumberEventsCursorRadius", MaxNumberEvents);
00312         xrm.Put ("ArrowSize", ArrowSize);
00313 
00314         RemoveObjects();
00315         if(RedLine)
00316                 delete RedLine;
00317 
00318         if (EventPlot)
00319                 delete EventPlot;
00320 
00321         
00322         remove_trace ();
00323 
00324         RemoveEventObjects ();
00325 
00326         delete ximg;
00327         delete vinfo;
00328 }
00329 
00330 void ViewControl::AppWidgetInit(gchar *title, int InWindow){
00331         XSM_DEBUG (DBG_L2,  "ViewControl::WidgetInit" );
00332         InWindowFlg = InWindow;
00333         // we have our own window
00334         if(InWindowFlg){
00335                 widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
00336                 gtk_object_set_data (GTK_OBJECT (widget), "widget", widget);
00337                 gtk_window_set_title (GTK_WINDOW (widget), title);
00338                 gtk_window_set_policy (GTK_WINDOW (widget), TRUE, TRUE, FALSE);
00339                 gtk_signal_connect(GTK_OBJECT(widget),
00340                                    "delete_event",
00341                                    GTK_SIGNAL_FUNC(App::close_scan_event_cb),
00342                                    this);
00343         }else{
00344                 widget = NULL;
00345         }
00346         vbox = gtk_vbox_new (FALSE, 0);
00347         gtk_object_set_data (GTK_OBJECT (widget), "vbox", vbox);
00348         gtk_widget_show (vbox);
00349         
00350         if(widget)
00351                 gtk_container_add (GTK_CONTAINER (widget), vbox);
00352         else
00353                 // we are only a pure widget
00354                 widget=vbox;
00355 }
00356 
00357 
00358 void ViewControl::Resize (char *title, int nx, int ny, 
00359                           int ChNo, Scan *sc, 
00360                           int ZoomFac, int QuenchFac){
00361         const int border=6;
00362         const int activeframe=2;
00363         rulewidth = 0;
00364         const double statusheight = 20.;
00365         
00366         int  usx=MIN((nx+rulewidth+2*border+20), (2*gdk_screen_width()/3));
00367         int  usy=MIN((int)(ny+rulewidth+2*border+statusheight+20), (2*gdk_screen_height()/3));
00368         gnome_canvas_set_pixels_per_unit( GNOME_CANVAS(canvas), (double)ZoomFac);
00369         gnome_canvas_set_scroll_region( GNOME_CANVAS(canvas), (double)(-rulewidth-border/ZoomFac), (double)(-rulewidth-border/ZoomFac), (double)((nx+border)/ZoomFac), (double)((ny+border)/ZoomFac));
00370         
00371         vinfo->SetQfZf(QuenchFac, ZoomFac);
00372         
00373         // refit image object into canvas
00374         XSM_DEBUG (DBG_L2,  "VC::RESIZE setting window default size: " << usx << ", "<< usy );
00375         gtk_window_resize (GTK_WINDOW(widget), usx, usy);
00376         
00377         XSM_DEBUG (DBG_L2,  "VC::RESIZE ximg->Resize" );
00378         ximg->Resize (nx/ZoomFac,ny/ZoomFac);
00379         
00380         XSM_DEBUG (DBG_L2,  "VC::RESIZE gnome_canvas_item_set ActiveFrameCoords update" );
00381         gnome_canvas_item_set(ActiveFrame,
00382                               "x1",(double)(-activeframe/ZoomFac),
00383                               "y1",(double)(-activeframe/ZoomFac),
00384                               "x2",(double)((nx+activeframe)/ZoomFac),
00385                               "y2",(double)((ny+activeframe)/ZoomFac),
00386                               NULL);
00387         
00388         XSM_DEBUG (DBG_L2, "VC::RESIZE done" );
00389 }
00390 
00391 void ViewControl::SetTitle(char *title){
00392         gtk_window_set_title (GTK_WINDOW (widget), title);
00393         CheckOptions();
00394 }
00395 
00396 void get_obj_coords_wrapper(int i, double &x, double &y){
00397         if (current_vobject)
00398                 current_vobject->obj_get_xy_i (i,x,y);
00399 }
00400 
00401 void ViewControl::AddObject(VObject *vo){
00402         gobjlist = g_slist_prepend (gobjlist, vo);
00403         vo->Update ();
00404         if (current_vobject){
00405                 XSM_DEBUG(DBG_L2, "ViewControl::AddObject  ERROR, recursive call occured!!" );
00406                 return;
00407         }
00408         current_vobject = vo;
00409         vo->obj_id (scan->add_object (vo->obj_name (), vo->obj_text (),
00410                                       vo->obj_num_points (),
00411                                       get_obj_coords_wrapper));
00412         vo->set_marker_scale (1./vinfo->GetZfac());
00413         current_vobject = NULL;
00414 }
00415 
00416 void ViewControl::SetEventFilter(gchar *filter){
00417         if (event_filter)
00418                 g_free (event_filter);
00419         if (filter)
00420                 event_filter = g_strdup (filter);
00421         else
00422                 event_filter = NULL;
00423 }
00424 
00425 void ViewControl::RescanEventObjects(){
00426         if (event_filter){
00427                 if (*event_filter == 'P')
00428                         scan->mem2d->ReportScanEvents ((GFunc) ViewControl::add_event_obj, this, CursorXYVt, CursorRadius, MaxNumberEvents);
00429                 else
00430                         scan->mem2d->ReportScanEvents ((GFunc) ViewControl::add_event_obj, this);
00431         } else
00432                 scan->mem2d->ReportScanEvents ((GFunc) ViewControl::add_event_obj, this);
00433 }
00434 
00435 
00436 gint check_func (gpointer *vo, gpointer *se){
00437         return ((VObEvent*) vo)->get_scan_event() == (ScanEvent*)se ? 0:-1;
00438 }
00439 
00440 void ViewControl::add_event_obj(ScanEvent *se, ViewControl *vc)
00441 {
00442         double xy[2];
00443 
00444         if (se->flag) return;
00445         if (((EventEntry*)(se->event_list->data))->description_id () != vc->event_filter[0]) return;
00446 
00447 // nice check, but gets horribly inefficient and slow for a very long list... using a flag now
00448 //      if (vc->geventlist) // check if existing
00449 //              if (g_slist_find_custom (vc->geventlist, se, (GCompareFunc)check_func))
00450 //                      return;
00451 
00452         se->get_position (xy[0], xy[1]);
00453         VObEvent *voe = new VObEvent (vc->canvas, xy, vc->scan->Pkt2d, FALSE, VOBJ_COORD_ABSOLUT, NULL, vc->ArrowSize/100.);
00454         voe->set_scan_event (se);
00455         vc->geventlist = g_slist_prepend (vc->geventlist, voe);
00456         se->flag = TRUE; // set object flag
00457 
00458         if (((EventEntry*)(se->event_list->data))->description_id () == 'U'){
00459                 UserEntry* ue = (UserEntry*) (se->event_list->data);
00460                 voe->obj_text (ue->get (0));
00461         }
00462 }
00463 
00464 void ViewControl::RemoveEventObjects(){
00465 // unsets object flag and delete obj!
00466         g_slist_foreach((GSList*) geventlist, (GFunc) ViewControl::unflag_scan_event_and_remove_obj, this); 
00467         g_slist_free(geventlist);
00468         geventlist = NULL;
00469 
00470         active_event = NULL; 
00471 }
00472 
00473 void ViewControl::set_event_label(ScanEvent *se, ViewControl *vc){
00474 }
00475 
00476 void ViewControl::SetEventLabels(int mode){
00477         if (mode)
00478                 g_slist_foreach((GSList*) geventlist, (GFunc) ViewControl::obj_label_on, this);
00479         else
00480                 g_slist_foreach((GSList*) geventlist, (GFunc) ViewControl::obj_label_off, this);
00481 
00482 }
00483 
00484 void ViewControl::update_event_panel (ScanEvent *se){
00485         gint xi,yi;
00486 
00487         if (!se){
00488                 active_event = NULL; 
00489                 return; 
00490         }
00491 
00492         active_event = se;
00493 //      se->print ();
00494 
00495         xi = gtk_combo_box_get_active (GTK_COMBO_BOX (active_event_xchan));
00496         yi = gtk_combo_box_get_active (GTK_COMBO_BOX (active_event_ychan));
00497 
00498         while (active_event_num_events)
00499                 gtk_combo_box_remove_text (GTK_COMBO_BOX (active_event_list), active_event_num_events--);
00500 
00501         while (active_event_num_channels){
00502                 gtk_combo_box_remove_text (GTK_COMBO_BOX (active_event_xchan), active_event_num_channels);
00503                 gtk_combo_box_remove_text (GTK_COMBO_BOX (active_event_ychan), active_event_num_channels--);
00504         }
00505         active_event_num_channels = 0;
00506         active_event_num_events = active_event->get_event_count();
00507 
00508         GSList *ev=active_event->event_list;
00509         for (guint i=0; i<active_event_num_events; ++i){
00510                 EventEntry *ee = (EventEntry*) ev->data;
00511 //              gchar *txt = g_strdup_printf ("%s @ %u", ee->description(), (guint)ee->get_time());
00512                 gchar *txt = g_strdup_printf ("%s", ee->description());
00513                 gtk_combo_box_append_text (GTK_COMBO_BOX (active_event_list), txt);
00514                 g_free (txt);
00515                 ev=ev->next;
00516         }
00517         gtk_combo_box_set_active (GTK_COMBO_BOX (active_event_list), 0);
00518 
00519         EventEntry *ee = (EventEntry*) active_event->event_list->data;
00520         if (ee->description_id () == 'P'){
00521                 ProbeEntry* pe = (ProbeEntry*) ee;
00522                 active_event_num_channels = pe->get_chunk_size ();
00523                 for (guint i=0; i<active_event_num_channels; ++i){
00524                         gchar *txt = g_strdup_printf ("%s [%s]", pe->get_label (i), pe->get_unit_symbol (i)); 
00525                         gtk_combo_box_append_text (GTK_COMBO_BOX (active_event_xchan), txt);    
00526                         gtk_combo_box_append_text (GTK_COMBO_BOX (active_event_ychan), txt);    
00527                         g_free (txt);
00528                 }
00529         }
00530         gtk_combo_box_set_active (GTK_COMBO_BOX (active_event_xchan), xi);
00531         gtk_combo_box_set_active (GTK_COMBO_BOX (active_event_ychan), yi);
00532 
00533         if (GTK_TOGGLE_BUTTON (tog_plot)->active)
00534                 obj_event_plot_callback (NULL, this);
00535 
00536 //      i = gtk_combo_box_get_active (GTK_COMBO_BOX (active_event_xchan));
00537 }
00538 
00539 void  ViewControl::obj_event_plot_callback (GtkWidget *widget, ViewControl *vc){
00540         if (!vc->active_event) return;
00541 
00542         EventEntry *ee = (EventEntry*) vc->active_event->event_list->data;
00543 
00544         if (ee->description_id () == 'P'){
00545                 ProbeEntry* pe = (ProbeEntry*) ee;
00546                 gint xi,yi,nn;
00547                 double xmin, xmax, x;
00548 
00549                 nn = pe->get_num_sets ();
00550                 xi = gtk_combo_box_get_active (GTK_COMBO_BOX (vc->active_event_xchan)) - 1;
00551                 yi = gtk_combo_box_get_active (GTK_COMBO_BOX (vc->active_event_ychan)) - 1;
00552 
00553                 UnitObj *UXaxis = new UnitObj(pe->get_unit_symbol (xi), " ", "g", pe->get_label (xi));
00554                 UnitObj *UYaxis = new UnitObj(pe->get_unit_symbol (yi), " ", "g", pe->get_label (yi));
00555                 
00556                 // find min and max X limit
00557                 xmin = xmax = pe->get (0, xi);
00558                 for(int i = 1; i < nn; i++){
00559                         x =  pe->get (i, xi);
00560                         if (x > xmax) xmax = x;
00561                         if (x < xmin) xmin = x;
00562                 }
00563 
00564                 if (!vc->EventPlot){
00565                         gchar   *title  = g_strdup_printf ("Probe Event");
00566                         vc->EventPlot = new ProfileControl (title, nn, UXaxis, UYaxis, xmin, xmax, "EventPlot");
00567                         g_free (title);
00568                 } else {
00569                         vc->EventPlot->scan1d->mem2d->Resize (nn, 1);
00570                         vc->EventPlot->SetXrange (xmin, xmax);
00571                         vc->EventPlot->SetXlabel (pe->get_label (xi));
00572                         vc->EventPlot->SetYlabel (pe->get_label (yi));
00573                         if (GTK_TOGGLE_BUTTON (vc->tog_average)->active){
00574                                 gchar* txt = g_strdup_printf ("Average of all probe events shown: %s", pe->get_label (yi));
00575                                 vc->EventPlot->SetTitle (txt);
00576                                 g_free (txt);
00577                         }else
00578                                 vc->EventPlot->SetTitle (pe->get_label (yi));
00579                 }
00580                 
00581 
00582                 for(int i = 0; i < nn; i++)
00583                         vc->EventPlot->SetPoint (i, pe->get (i, xi), pe->get (i, yi));
00584 
00585                 if (GTK_TOGGLE_BUTTON (vc->tog_average)->active){
00586                         GSList* all = vc->scan->mem2d->ReportScanEvents (NULL, NULL, vc->CursorXYVt, 0., 0);
00587                         GSList* ev = all;
00588                         int i=0;
00589                         int count=1;
00590                         while (ev){
00591                                 ScanEvent *sen = (ScanEvent*) ev->data;
00592                                 if (sen != vc->active_event){
00593                                         EventEntry *een = (EventEntry*) sen->event_list->data;
00594                                         if (een->description_id () == 'P'){
00595                                                 ProbeEntry* pen = (ProbeEntry*) een;
00596                                                 if (++i > vc->MaxNumberEvents || ((ScanEvent*)(ev->data))->distance (vc->CursorXYVt) > vc->CursorRadius)
00597                                                         break;
00598                                                 
00599                                                 
00600                                                 for(int i = 0; i < nn; i++)
00601                                                         vc->EventPlot->AddPoint (i, pen->get (i, yi));
00602                                                 
00603                                                 ++count;
00604                                         }
00605                                 }
00606                                 ev = g_slist_next (ev);
00607                         }
00608                         g_slist_free (all);
00609                         for(int i = 0; i < nn; i++)
00610                                 vc->EventPlot->MulPoint (i, 1./((double)count));
00611                 }
00612                 else
00613                         for(int i = 0; i < nn; i++)
00614                                 vc->EventPlot->SetPoint (i, pe->get (i, xi), pe->get (i, yi));
00615                 
00616                 vc->EventPlot->drawScans ();
00617                 vc->EventPlot->UpdateArea ();
00618                 vc->EventPlot->show ();
00619         }
00620 }
00621 
00622 
00623 void ViewControl::PaintAllRegionsInactive(){
00624         g_slist_foreach((GSList*) gobjlist, (GFunc) ViewControl::deactivate_obj, this); 
00625         g_slist_foreach((GSList*) geventlist, (GFunc) ViewControl::deactivate_obj, this); 
00626 }
00627 
00628 void ViewControl::PaintAllRegionsActive(){
00629         g_slist_foreach((GSList*) gobjlist, (GFunc) ViewControl::activate_obj, this); 
00630         g_slist_foreach((GSList*) geventlist, (GFunc) ViewControl::activate_obj, this); 
00631 }
00632 
00633 void ViewControl::MoveAllObjects2LocMax(){
00634         g_slist_foreach((GSList*) gobjlist, (GFunc) ViewControl::move2locmax_obj, this);
00635 }
00636 
00637 void ViewControl::CheckAllObjectsLabels(gboolean flg){
00638         if (flg)
00639                 g_slist_foreach((GSList*) gobjlist, (GFunc) ViewControl::obj_label_on, this);
00640         else
00641                 g_slist_foreach((GSList*) gobjlist, (GFunc) ViewControl::obj_label_off, this);
00642 }
00643 
00644 void ViewControl::RemoveObjects(){
00645         g_slist_foreach((GSList*) gobjlist, (GFunc) ViewControl::remove_obj, this);
00646         g_slist_free(gobjlist);
00647         gobjlist = NULL;
00648         scan->PktVal=0;
00649 }
00650 
00651 void ViewControl::SaveObjects(){
00652         g_slist_foreach((GSList*) gobjlist, (GFunc) ViewControl::save_obj, this);
00653 }
00654 
00655 void ViewControl::SaveObjectsHPGL(){
00656         g_slist_foreach((GSList*) gobjlist, (GFunc) ViewControl::save_obj_HPGL, this);
00657 }
00658 
00659 void ViewControl::SetActive(int flg){
00660         GtkWidget *statusbar = (GtkWidget*)gtk_object_get_data (GTK_OBJECT (canvas), "statusbar");
00661         gint statusid  = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "drag");
00662         
00663         if(flg){
00664                 gnome_canvas_item_show(ActiveFrame);
00665                 gtk_statusbar_push(GTK_STATUSBAR(statusbar), statusid, "channel is active now");
00666         }else{
00667                 gnome_canvas_item_hide(ActiveFrame);
00668                 gtk_statusbar_push(GTK_STATUSBAR(statusbar), statusid, "inactive");
00669         }
00670 }
00671 
00672 gint ViewControl::canvas_event_cb(GnomeCanvasItem *item, GdkEvent *event, ViewControl *vc){
00673         static int dragging=FALSE;
00674         static GtkWidget *coordpopup=NULL;
00675         static GtkWidget *coordlab=NULL;
00676         GtkWidget *frame;
00677         gchar *mld;
00678         GdkCursor *fleur;
00679         gdouble x,y;
00680         x = event->button.x;
00681         y = event->button.y;
00682         gnome_canvas_item_w2i(item->parent, &x, &y);
00683         switch (event->type) 
00684         {
00685         case GDK_BUTTON_PRESS:
00686                 switch(event->button.button) 
00687                 {
00688                 case 1: 
00689                         if(vc->AddObjFkt)
00690                                 (*vc->AddObjFkt)(NULL, vc); return TRUE; // Add Obj
00691                         break;
00692                 case 2:  // Show XYZ
00693                         mld = vc->vinfo->makeXYZinfo(x, y, NULL);
00694                         coordpopup = gtk_window_new (GTK_WINDOW_POPUP);
00695                         gtk_window_set_position (GTK_WINDOW (coordpopup), GTK_WIN_POS_MOUSE);
00696                         gtk_container_add (GTK_CONTAINER (coordpopup), frame = gtk_frame_new (NULL));
00697                         gtk_container_add (GTK_CONTAINER (frame),   coordlab = gtk_label_new (mld));
00698                         gtk_widget_show_all (coordpopup);
00699                         g_free(mld);
00700                         fleur = gdk_cursor_new(GDK_CROSSHAIR);
00701                         gnome_canvas_item_grab(item,
00702                                                GDK_POINTER_MOTION_MASK | 
00703                                                GDK_BUTTON_RELEASE_MASK,
00704                                                fleur,
00705                                                event->button.time);
00706                         gdk_cursor_destroy(fleur);
00707                         dragging=TRUE;
00708 
00709                         if (vc->event_filter){
00710                                 int ix = (int)round(x*vc->vinfo->GetQfac());
00711                                 int iy = (int)round(y*vc->vinfo->GetQfac());
00712                                 vc->scan->Pixel2World (ix,iy, vc->CursorXYVt[0], vc->CursorXYVt[1]);
00713                                 if (*vc->event_filter == 'P'){
00714                                         vc->RemoveEventObjects ();
00715                                         vc->RescanEventObjects ();
00716                                 }
00717                         }
00718                         break;
00719                 case 4: if(vc->ZoomQFkt) (*vc->ZoomQFkt)(0,1,vc->ZQFktData); break; // Zoom Out
00720                 case 5: if(vc->ZoomQFkt) (*vc->ZoomQFkt)(1,0,vc->ZQFktData); break; // Zoom In
00721                 }
00722                 break;
00723                 
00724         case GDK_MOTION_NOTIFY:
00725                 if (dragging && (event->motion.state & GDK_BUTTON2_MASK)){
00726                         mld = vc->vinfo->makeXYZinfo(x, y, NULL);
00727                         gtk_label_set_text (GTK_LABEL (coordlab), mld);
00728                         g_free(mld);
00729                 }
00730                 break;
00731                 
00732         case GDK_BUTTON_RELEASE:
00733                 switch(event->button.button){
00734                 case 2:  // Hide XYZ
00735                         gtk_widget_destroy (coordpopup);
00736                         coordpopup=NULL;
00737                         
00738                         gnome_canvas_item_ungrab(item, event->button.time);
00739                         dragging=FALSE;
00740                         break;
00741                 }
00742                 break;
00743         default: break;
00744         }
00745         return FALSE;
00746 }
00747 
00748 void ViewControl::CheckRedLine(){
00749         if(RedLine){
00750                 RedLine->NewData(vinfo->sc);
00751                 RedLine->show();
00752         }
00753 }
00754 
00755 
00756 void ViewControl::CheckOptions(){
00757 //      GtkWidget *menushell;
00758 //      GtkWidget *menuitem;
00759 //      gint pos;
00760         gchar *vmode=NULL;
00761         
00762         switch(scan->GetVM()){
00763         case SCAN_V_DIRECT: vmode=g_strconcat(N_("View"),"/",N_("Direct"), NULL); break;
00764         case SCAN_V_QUICK:  vmode=g_strconcat(N_("View"),"/",N_("Quick"), NULL); break;
00765         case SCAN_V_LOG:    vmode=g_strconcat(N_("View"),"/",N_("Logarithmic"), NULL); break;
00766         case SCAN_V_DIFFERENTIAL:    vmode=g_strconcat(_("View"),"/",N_("Differential"), NULL); break;
00767         case SCAN_V_PERIODIC:    vmode=g_strconcat(_("View"),"/",N_("Periodic"), NULL); break;
00768         }
00769         if(vmode){
00770 /*
00771                 menushell = (GtkWidget*)gnome_app_find_menu_pos 
00772                         (
00773                                 (GtkWidget*)gtk_object_get_data (GTK_OBJECT (canvas), "viewpopup"), 
00774                                 vmode, 
00775                                 &pos
00776                                 );
00777                 if(menushell){
00778                         menuitem = (GtkWidget*)g_list_nth_data(GTK_MENU_SHELL (menushell) -> children, --pos);
00779                         if(menuitem){
00780                                 if (!gtk_check_menu_item_get_active  (GTK_CHECK_MENU_ITEM(menuitem)))
00781                                         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
00782                         }
00783                 }
00784 */
00785                 g_free(vmode);
00786         }
00787 }
00788 
00789 void ViewControl::Activate_callback (GtkWidget *widget, ViewControl *vc){
00790         gapp->xsm->ActivateChannel(vc->chno);
00791 }
00792 void ViewControl::SetOff_callback (GtkWidget *widget, ViewControl *vc){
00793         gapp->xsm->SetMode(vc->chno, ID_CH_M_OFF);
00794 }
00795 void ViewControl::SetOn_callback (GtkWidget *widget, ViewControl *vc){
00796         gapp->xsm->SetMode(vc->chno, ID_CH_M_ON);
00797 }
00798 void ViewControl::SetMath_callback (GtkWidget *widget, ViewControl *vc){
00799         gapp->xsm->SetMode(vc->chno, ID_CH_M_MATH);
00800 }
00801 void ViewControl::SetX_callback (GtkWidget *widget, ViewControl *vc){
00802         gapp->xsm->SetMode(vc->chno, ID_CH_M_X);
00803 }
00804 
00805 void ViewControl::AutoDisp_callback (GtkWidget *widget, ViewControl *vc){
00806         gapp->xsm->ActivateChannel(vc->chno);
00807         gapp->xsm->AutoDisplay();
00808 }
00809 
00810 void ViewControl::view_file_openhere_callback (GtkWidget *widget, ViewControl *vc){
00811         gapp->xsm->ActivateChannel(vc->chno);
00812         gapp->xsm->load();
00813 }
00814 
00815 void ViewControl::view_file_save_callback (GtkWidget *widget, ViewControl *vc){
00816         gapp->xsm->save(TRUE, NULL, vc->chno);
00817 }
00818 
00819 void ViewControl::view_file_saveobjects_callback (GtkWidget *widget, ViewControl *vc){
00820         gchar *oname = g_strconcat(vc->scan->data.ui.basename,"-objects",NULL);
00821         gchar *fname = gapp->file_dialog("Save Objects, list or .plt (HPGL)", NULL, NULL, oname, "objectsave");
00822         g_free(oname);
00823         if (!fname) return;
00824         vc->objsavestream.open(fname, std::ios::out);
00825         if (strncmp(fname+strlen(fname)-4,".plt",4))
00826                 vc->SaveObjects();
00827         else
00828                 vc->SaveObjectsHPGL();
00829         vc->objsavestream.close();
00830 }
00831 
00832 gchar *GetXAngYAng (std::ifstream &is, double *xy, int skip){
00833         gchar line[64];
00834         gchar *lab = NULL;
00835         int i;
00836         if (skip){
00837                 is.getline (line, 64); // label
00838                 if (strrchr(line, '"')){
00839                         * (strrchr(line, '"')) = 0;
00840                         lab = g_strdup(strchr(line, '"')+1);
00841                 }
00842                 is.getline (line, 64); // skip NPkte
00843                 is.getline (line, 64); // skip Info
00844         }
00845         is.getline (line, 64); // get XY data
00846         i = atoi (strtok(line, " ,;()"));
00847         strtok(NULL, " ,;()"); // ignore X in pix
00848         strtok(NULL, " ,;()"); // ignore Y in pix
00849         xy[0] = atof (strtok(NULL, " ,;()"));
00850         xy[1] = atof (strtok(NULL, " ,;()"));
00851         return lab;
00852 }
00853 
00854 void ViewControl::view_file_loadobjects_callback (GtkWidget *widget, ViewControl *vc){
00855         gchar *oname = g_strconcat (vc->scan->data.ui.basename,"-objects",NULL);
00856         gchar *fname = gapp->file_dialog ("Load Objects list (not .plt)", NULL, NULL, oname, "objectload");
00857         g_free (oname);
00858         vc->objloadstream.open (fname, std::ios::in);
00859 
00860 // very primitive parser of object data
00861 //  I've no idea how to choose from "Object-Name" automatically the right object class 
00862 //  without using a explicit if ( strcpm (..)) chooser list!
00863 // loads only Point,Line,Rect,Circle
00864         while (vc->objloadstream.good ()){
00865                 gchar line[64];
00866                 gchar *lab = NULL;
00867                 vc->objloadstream.getline (line, 64);
00868                 if (!strncmp (line, "(VObject \"Point\"", 16)){
00869                         double xy[2];
00870                         lab = GetXAngYAng (vc->objloadstream, xy, TRUE);
00871                         XSM_DEBUG(DBG_L2, "Adding Point@xy:" << xy[0] << ", " << xy[1] );
00872                         vc->AddObject (new VObPoint (vc->canvas, xy, vc->scan->Pkt2d, FALSE, VOBJ_COORD_ABSOLUT, lab, OB_MARKER_SCALE));
00873                 } else if (!strncmp (line, "(VObject \"Line\"", 15)){
00874                         double xy[4];
00875                         lab = GetXAngYAng (vc->objloadstream, xy, TRUE);
00876                         GetXAngYAng (vc->objloadstream, xy+2, FALSE);
00877                         XSM_DEBUG(DBG_L2, "Adding Line@xy:" << xy[0] << ", " << xy[1]
00878                              << " : " << xy[2] << ", " << xy[3] );
00879                         vc->AddObject (new VObLine (vc->canvas, xy, vc->scan->Pkt2d, FALSE, VOBJ_COORD_ABSOLUT, lab, OB_MARKER_SCALE));
00880                 } else if (!strncmp (line, "(VObject \"Rectangle\"", 20)){
00881                         double xy[4];
00882                         lab = GetXAngYAng (vc->objloadstream, xy, TRUE);
00883                         GetXAngYAng (vc->objloadstream, xy+2, FALSE);
00884                         XSM_DEBUG(DBG_L2, "Adding Rectangle@xy:" << xy[0] << ", " << xy[1]
00885                              << " : " << xy[2] << ", " << xy[3] );
00886                         vc->AddObject (new VObRectangle (vc->canvas, xy, vc->scan->Pkt2d, FALSE, VOBJ_COORD_ABSOLUT, lab, OB_MARKER_SCALE));
00887                 } else if (!strncmp (line, "(VObject \"Circle\"", 17)){
00888                         double xy[4];
00889                         lab = GetXAngYAng (vc->objloadstream, xy, TRUE);
00890                         GetXAngYAng (vc->objloadstream, xy+2, FALSE);
00891                         XSM_DEBUG(DBG_L2, "Adding Circle@xy:" << xy[0] << ", " << xy[1]
00892                              << " : " << xy[2] << ", " << xy[3] );
00893                         vc->AddObject (new VObCircle (vc->canvas, xy, vc->scan->Pkt2d, FALSE, VOBJ_COORD_ABSOLUT, lab, OB_MARKER_SCALE));
00894                 }
00895                 g_free(lab);
00896                 lab = NULL;
00897         }
00898         vc->objloadstream.close ();
00899 }
00900 
00901 void ViewControl::view_file_save_as_callback (GtkWidget *widget, ViewControl *vc){
00902         gapp->xsm->save(FALSE, NULL, vc->chno);
00903 }
00904 
00905 void ViewControl::view_file_saveimage_callback (GtkWidget *widget, ViewControl *vc){
00906         gchar *imgname;
00907         imgname = gapp->file_dialog("Save as image", NULL, NULL, NULL);
00908         vc->ximg->saveimage(imgname);
00909 }
00910 
00911 void ViewControl::view_file_getinfo_callback (GtkWidget *widget, ViewControl *vc){
00912         gapp->xsm->ActivateChannel(vc->chno);
00913         XSM_DEBUG(DBG_L2, gapp->xsm->ActiveScan->data.ui.name );
00914         gapp->CallGetNCInfoPlugin (gapp->xsm->ActiveScan->data.ui.name);
00915 }
00916 
00917 void ViewControl::view_file_print_callback (GtkWidget *widget, ViewControl *vc){
00918         gapp->xsm->ActivateChannel(vc->chno);
00919         gapp->file_print_callback(widget, NULL);
00920 }
00921 
00922 void ViewControl::view_file_kill_callback (GtkWidget *widget, ViewControl *vc){
00923         gapp->xsm->SetMode(vc->chno, ID_CH_M_OFF);
00924 }
00925 
00926 void ViewControl::view_edit_copy_callback (GtkWidget *widget, ViewControl *vc){
00927         gapp->xsm->ActivateChannel(vc->chno);
00928         gapp->xsm->MathOperation(CopyScan);
00929 }
00930 
00931 void ViewControl::view_edit_crop_callback (GtkWidget *widget, ViewControl *vc){
00932         gapp->xsm->ActivateChannel(vc->chno);
00933         gapp->xsm->MathOperation(CropScan);
00934 }
00935 
00936 void ViewControl::view_edit_zoomin_callback (GtkWidget *widget, ViewControl *vc){
00937         gapp->xsm->ActivateChannel(vc->chno);
00938         gapp->xsm->MathOperation(ZoomInScan);
00939 }
00940 
00941 void ViewControl::view_edit_zoomout_callback (GtkWidget *widget, ViewControl *vc){
00942         gapp->xsm->ActivateChannel(vc->chno);
00943         gapp->xsm->MathOperation(ZoomOutScan);
00944 }
00945 
00946 void ViewControl::view_tool_all2locmax_callback (GtkWidget *widget, ViewControl *vc){
00947         vc->MoveAllObjects2LocMax();
00948 }
00949 
00950 void ViewControl::view_tool_removeall_callback (GtkWidget *widget, ViewControl *vc){
00951         vc->RemoveObjects();
00952         vc->scan->PktVal=0;
00953 }
00954 
00955 void ViewControl::view_tool_labels_callback (GtkWidget *widget, ViewControl *vc){
00956         vc->CheckAllObjectsLabels (GTK_CHECK_MENU_ITEM (widget)->active ? TRUE:FALSE);
00957 }
00958 
00959 // ---------------
00960 
00961 #define MAKE_VOB_DEFAULTS(TYPE)  new TYPE(vc->canvas, xy, vc->scan->Pkt2d, FALSE, VOBJ_COORD_FROM_MOUSE, NULL, OB_MARKER_SCALE)
00962 #define MAKE_VOB_DEFAULTS_SHOW(TYPE)  new TYPE(vc->canvas, xy, vc->scan->Pkt2d, TRUE, VOBJ_COORD_FROM_MOUSE, NULL, OB_MARKER_SCALE)
00963 
00964 void ViewControl::view_tool_disable_callback (GtkWidget *widget, ViewControl *vc){
00965         vc->AddObjFkt = NULL;
00966 }
00967 void ViewControl::view_tool_addpoint_callback (GtkWidget *widget, ViewControl *vc){
00968         vc->AddObjFkt = ViewControl::view_tool_addpoint;
00969 }
00970 void ViewControl::view_tool_addpoint (GtkWidget *widget, ViewControl *vc){
00971         double xy[2] = {0.,0.};
00972         vc->AddObject (MAKE_VOB_DEFAULTS (VObPoint));
00973         vc->scan->PktVal=1;
00974 }
00975 void ViewControl::view_tool_addshowpoint_callback (GtkWidget *widget, ViewControl *vc){
00976         vc->AddObjFkt = ViewControl::view_tool_addshowpoint;
00977 }
00978 void ViewControl::view_tool_addshowpoint (GtkWidget *widget, ViewControl *vc){
00979         double xy[2] = {0.,0.};
00980         vc->AddObject (MAKE_VOB_DEFAULTS_SHOW (VObPoint));
00981         vc->scan->PktVal=1;
00982 }
00983 void ViewControl::view_tool_addline_callback (GtkWidget *widget, ViewControl *vc){
00984         vc->AddObjFkt = ViewControl::view_tool_addline;
00985 }
00986 void ViewControl::view_tool_addline (GtkWidget *widget, ViewControl *vc){
00987         double xy[4] = {0.,0.,15.,15.};
00988         vc->AddObject (MAKE_VOB_DEFAULTS (VObLine));
00989         vc->scan->PktVal=2;
00990 }
00991 void ViewControl::view_tool_addpolyline_callback (GtkWidget *widget, ViewControl *vc){
00992         vc->AddObjFkt = ViewControl::view_tool_addpolyline;
00993 }
00994 void ViewControl::view_tool_addpolyline (GtkWidget *widget, ViewControl *vc){
00995         double xy[13] = {6., 0.,0., 10.,10., 20.,20., 30.,30., 40.,40., 50.,50. };
00996         vc->scan->realloc_pkt2d (6);
00997         vc->AddObject (MAKE_VOB_DEFAULTS (VObPolyLine));
00998         vc->scan->PktVal=6;
00999 }
01000 void ViewControl::view_tool_addksys_callback (GtkWidget *widget, ViewControl *vc){
01001         vc->AddObjFkt = ViewControl::view_tool_addksys;
01002 }
01003 void ViewControl::view_tool_addksys (GtkWidget *widget, ViewControl *vc){
01004         double xy[6] = {15.,0.,0.,0.,0.,15.};
01005         vc->AddObject (MAKE_VOB_DEFAULTS (VObKsys));
01006         vc->scan->PktVal=3;
01007 }
01008 void ViewControl::view_tool_addparabel_callback (GtkWidget *widget, ViewControl *vc){
01009         vc->AddObjFkt = ViewControl::view_tool_addparabel;
01010 }
01011 void ViewControl::view_tool_addparabel (GtkWidget *widget, ViewControl *vc){
01012         double xy[6] = {0.,0.,25.,30.,50.,50.};
01013         vc->AddObject(new VObParabel(vc->canvas, xy, vc->scan->Pkt2d));
01014         vc->scan->PktVal=3;
01015 }
01016 void ViewControl::view_tool_showline_callback (GtkWidget *widget, ViewControl *vc){
01017         vc->AddObjFkt = ViewControl::view_tool_showline;
01018 }
01019 void ViewControl::view_tool_showline (GtkWidget *widget, ViewControl *vc){
01020         double xy[4] = {0.,0.,15.,15.};
01021         vc->AddObject (MAKE_VOB_DEFAULTS_SHOW (VObLine));
01022         vc->scan->PktVal=2;
01023 }
01024 void ViewControl::view_tool_addrectangle_callback (GtkWidget *widget, ViewControl *vc){
01025         vc->AddObjFkt = ViewControl::view_tool_addrectangle;
01026 }
01027 void ViewControl::view_tool_addrectangle (GtkWidget *widget, ViewControl *vc){
01028         double xy[4] = {0.,0.,15.,15.};
01029         vc->AddObject (MAKE_VOB_DEFAULTS (VObRectangle));
01030         vc->scan->PktVal=2;
01031 }
01032 void ViewControl::view_tool_addcircle_callback (GtkWidget *widget, ViewControl *vc){
01033         vc->AddObjFkt = ViewControl::view_tool_addcircle;
01034 }
01035 void ViewControl::view_tool_addcircle (GtkWidget *widget, ViewControl *vc){
01036         double xy[4] = {0.,0.,15.,15.};
01037         vc->AddObject (MAKE_VOB_DEFAULTS (VObCircle));
01038         vc->scan->PktVal=2;
01039 }
01040 
01041 void ViewControl::view_tool_addshowcircle_callback (GtkWidget *widget, ViewControl *vc){
01042         vc->AddObjFkt = ViewControl::view_tool_addshowcircle;
01043 }
01044 void ViewControl::view_tool_addshowcircle (GtkWidget *widget, ViewControl *vc){
01045         double xy[4] = {0.,0.,15.,15.};
01046         vc->AddObject (MAKE_VOB_DEFAULTS_SHOW (VObCircle));
01047         vc->scan->PktVal=2;
01048 }
01049 
01050 // ---------------
01051 
01052 void ViewControl::view_tool_mvprop_r2_callback (GtkWidget *widget, ViewControl *vc){ vc->local_radius=2; }
01053 void ViewControl::view_tool_mvprop_r5_callback (GtkWidget *widget, ViewControl *vc){ vc->local_radius=5; }
01054 void ViewControl::view_tool_mvprop_r10_callback (GtkWidget *widget, ViewControl *vc){ vc->local_radius=10; }
01055 void ViewControl::view_tool_mvprop_r20_callback (GtkWidget *widget, ViewControl *vc){ vc->local_radius=20; }
01056 void ViewControl::view_tool_mvprop_r50_callback (GtkWidget *widget, ViewControl *vc){ vc->local_radius=50; }
01057 void ViewControl::view_tool_mvprop_r100_callback (GtkWidget *widget, ViewControl *vc){ vc->local_radius=100; }
01058  
01059 // ---------------
01060 
01061 void ViewControl::view_view_direct_callback (GtkWidget *widget, ViewControl *vc){
01062         if (GTK_CHECK_MENU_ITEM (widget)->active){
01063                 //    vc->scan->SetVM(SCAN_V_DIRECT);
01064                 gapp->xsm->ActivateChannel(vc->chno);
01065                 gapp->xsm->SetVM(SCAN_V_DIRECT);
01066         }
01067 }
01068 
01069 void ViewControl::view_view_quick_callback (GtkWidget *widget, ViewControl *vc){
01070         if (GTK_CHECK_MENU_ITEM (widget)->active){
01071                 //    vc->scan->SetVM(SCAN_V_QUICK);
01072                 gapp->xsm->ActivateChannel(vc->chno);    
01073                 gapp->xsm->SetVM(SCAN_V_QUICK);
01074         }
01075 }
01076 
01077 void ViewControl::view_view_planesub_callback (GtkWidget *widget, ViewControl *vc){
01078         if (GTK_CHECK_MENU_ITEM (widget)->active){
01079                 //    vc->scan->SetVM(SCAN_V_PLANESUB);
01080                 gapp->xsm->ActivateChannel(vc->chno);    
01081                 gapp->xsm->SetVM(SCAN_V_PLANESUB);
01082         }
01083 }
01084 
01085 void ViewControl::view_view_log_callback (GtkWidget *widget, ViewControl *vc){
01086         if (GTK_CHECK_MENU_ITEM (widget)->active){
01087                 //    vc->scan->SetVM(SCAN_V_LOG);
01088                 gapp->xsm->ActivateChannel(vc->chno);
01089                 gapp->xsm->SetVM(SCAN_V_LOG);
01090         }
01091 }
01092 
01093 void ViewControl::view_view_horizont_callback (GtkWidget *widget, ViewControl *vc){
01094         if (GTK_CHECK_MENU_ITEM (widget)->active){
01095                 //    vc->scan->SetVM(SCAN_V_HORIZONTAL);
01096                 gapp->xsm->ActivateChannel(vc->chno);
01097                 gapp->xsm->SetVM(SCAN_V_HORIZONTAL);
01098         }
01099 }
01100 
01101 void ViewControl::view_view_periodic_callback (GtkWidget *widget, ViewControl *vc){
01102         if (GTK_CHECK_MENU_ITEM (widget)->active)
01103                 //    vc->scan->SetVM(SCAN_V_PERIODIC);
01104                 gapp->xsm->ActivateChannel(vc->chno);
01105         gapp->xsm->SetVM(SCAN_V_PERIODIC);
01106 }
01107 
01108 void ViewControl::view_view_differential_callback (GtkWidget *widget, ViewControl *vc){
01109         if (GTK_CHECK_MENU_ITEM (widget)->active)
01110                 //    vc->scan->SetVM(SCAN_V_DIFFERENTIAL);
01111                 gapp->xsm->ActivateChannel(vc->chno);
01112         gapp->xsm->SetVM(SCAN_V_DIFFERENTIAL);
01113 }
01114 
01115 
01116 
01117 void ViewControl::view_view_redline_callback (GtkWidget *widget, ViewControl *vc){
01118         if (GTK_CHECK_MENU_ITEM (widget)->active){
01119                 vc->scan->RedLineActive=TRUE;
01120                 if(!vc->RedLine)
01121                         vc->RedLine = new ProfileControl("Red Line");
01122         }else{
01123                 vc->scan->RedLineActive=FALSE;
01124                 if(vc->RedLine)
01125                         delete vc->RedLine;
01126                 vc->RedLine=NULL;
01127         }
01128 }
01129 
01130 void ViewControl::view_view_autozoom_callback (GtkWidget *widget, ViewControl *vc){
01131         if (GTK_CHECK_MENU_ITEM (widget)->active)
01132                 gapp->xsm->ZoomFlg = (gapp->xsm->ZoomFlg & ~VIEW_ZOOM) | VIEW_ZOOM;
01133         else
01134                 gapp->xsm->ZoomFlg &= ~VIEW_ZOOM;
01135 }
01136 
01137 void ViewControl::view_view_color_callback (GtkWidget *widget, ViewControl *vc){
01138         if (GTK_CHECK_MENU_ITEM (widget)->active){
01139                 SET_FLAG(gapp->xsm->ZoomFlg, VIEW_PALETTE);
01140                 SET_FLAG(gapp->xsm->ZoomFlg, VIEW_COLOR);
01141         }else{
01142                 CLR_FLAG(gapp->xsm->ZoomFlg, VIEW_PALETTE);
01143                 CLR_FLAG(gapp->xsm->ZoomFlg, VIEW_COLOR);
01144         }
01145 }
01146 
01147 void ViewControl::view_view_coord_absolute_callback (GtkWidget *widget, ViewControl *vc){
01148         if (GTK_CHECK_MENU_ITEM (widget)->active){
01149                 vc->vinfo->SetCoordMode (SCAN_COORD_ABSOLUTE);
01150                 vc->vinfo->SetPixelUnit (FALSE);
01151                 vc->vinfo->ChangeXYUnit (NULL);
01152                 vc->vinfo->ChangeZUnit (NULL);
01153         }
01154 }
01155 
01156 void ViewControl::view_view_coord_relative_callback (GtkWidget *widget, ViewControl *vc){
01157         if (GTK_CHECK_MENU_ITEM (widget)->active){
01158                 vc->vinfo->SetCoordMode (SCAN_COORD_RELATIVE);
01159                 vc->vinfo->SetPixelUnit (FALSE);
01160                 vc->vinfo->ChangeXYUnit (NULL);
01161                 vc->vinfo->ChangeZUnit (NULL);
01162         }
01163 }
01164 
01165 void ViewControl::view_view_coord_pixels_callback (GtkWidget *widget, ViewControl *vc){
01166         if (GTK_CHECK_MENU_ITEM (widget)->active){
01167                 vc->vinfo->SetCoordMode (SCAN_COORD_RELATIVE);
01168                 vc->vinfo->SetPixelUnit (TRUE);
01169                 vc->vinfo->ChangeXYUnit (gapp->xsm->Unity);
01170                 vc->vinfo->ChangeZUnit (gapp->xsm->Unity);
01171         }else{
01172                 vc->vinfo->SetPixelUnit (FALSE);
01173                 vc->vinfo->ChangeXYUnit (NULL);
01174                 vc->vinfo->ChangeZUnit (NULL);
01175         }
01176 }
01177 
01178 void ViewControl::view_view_zoom10_1_callback (GtkWidget *widget, ViewControl *vc){
01179         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(10,1,vc->ZQFktData); }
01180 void ViewControl::view_view_zoom5_1_callback (GtkWidget *widget, ViewControl *vc){
01181         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(5,1,vc->ZQFktData); }
01182 void ViewControl::view_view_zoom4_1_callback (GtkWidget *widget, ViewControl *vc){
01183         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(4,1,vc->ZQFktData); }
01184 void ViewControl::view_view_zoom3_1_callback (GtkWidget *widget, ViewControl *vc){
01185         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(3,1,vc->ZQFktData); }
01186 void ViewControl::view_view_zoom2_1_callback (GtkWidget *widget, ViewControl *vc){
01187         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(2,1,vc->ZQFktData); }
01188 void ViewControl::view_view_zoom1_1_callback (GtkWidget *widget, ViewControl *vc){
01189         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(1,1,vc->ZQFktData); }
01190 void ViewControl::view_view_zoom1_2_callback (GtkWidget *widget, ViewControl *vc){
01191         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(1,2,vc->ZQFktData); }
01192 void ViewControl::view_view_zoom1_3_callback (GtkWidget *widget, ViewControl *vc){
01193         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(1,3,vc->ZQFktData); }
01194 void ViewControl::view_view_zoom1_4_callback (GtkWidget *widget, ViewControl *vc){
01195         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(1,4,vc->ZQFktData); }
01196 void ViewControl::view_view_zoom1_5_callback (GtkWidget *widget, ViewControl *vc){
01197         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(1,5,vc->ZQFktData); }
01198 void ViewControl::view_view_zoom1_10_callback (GtkWidget *widget, ViewControl *vc){
01199         if(vc->ZoomQFkt) (*vc->ZoomQFkt)(1,10,vc->ZQFktData); }
01200 
01201 // Events control
01202 void ViewControl::events_probe_callback (GtkWidget *widget, ViewControl *vc){
01203         vc->RemoveEventObjects ();
01204         if (GTK_CHECK_MENU_ITEM (widget)->active){
01205                 vc->SetEventFilter ("Probe");
01206                 vc->RescanEventObjects ();
01207                 gtk_widget_show (vc->control_box);
01208                 gtk_widget_show (vc->control_box_event_xysel);
01209         }
01210         else{
01211                 vc->SetEventFilter (NULL);
01212                 gtk_widget_hide (vc->control_box);
01213                 gtk_widget_hide (vc->control_box_event_xysel);
01214         }
01215 }
01216 void ViewControl::events_user_callback (GtkWidget *widget, ViewControl *vc){
01217         vc->RemoveEventObjects ();
01218         if (GTK_CHECK_MENU_ITEM (widget)->active){
01219                 vc->SetEventFilter ("User");
01220                 vc->RescanEventObjects ();
01221         }
01222         else
01223                 vc->SetEventFilter (NULL);
01224 }
01225 
01226 void ViewControl::events_labels_callback (GtkWidget *widget, ViewControl *vc){
01227         vc->SetEventLabels (GTK_CHECK_MENU_ITEM (widget)->active ? TRUE:FALSE);
01228 }
01229 
01230 void ViewControl::events_verbose_callback (GtkWidget *widget, ViewControl *vc){
01231 }
01232 
01233 void ViewControl::events_remove_callback (GtkWidget *widget, ViewControl *vc){
01234         vc->RemoveEventObjects ();
01235         vc->scan->mem2d->RemoveScanEvents ();
01236 }
01237 
01238 void ViewControl::events_update (){
01239         if (event_filter)
01240                 RescanEventObjects ();
01241 }
01242 
01243 
01244 // ======================================== Object Cb´s
01245 
01246 void ViewControl::obj_remove_callback (GtkWidget *widget, VObject *vo){
01247         ViewControl *vc = (ViewControl*)gtk_object_get_data (GTK_OBJECT (vo->canvas), "ViewControl");
01248         vc->scan->PktVal=0;
01249         vc->remove_obj(vo, vc);
01250         vc->gobjlist = g_slist_remove((GSList*) vc->gobjlist, vo);
01251 }
01252 
01253 void ViewControl::obj_properties_callback (GtkWidget *widget, VObject *vo){
01254         vo->properties ();
01255 }
01256 
01257 void ViewControl::obj_dump_callback (GtkWidget *widget, VObject *vo){
01258         ViewControl *vc = (ViewControl*)gtk_object_get_data (GTK_OBJECT (vo->canvas), "ViewControl");
01259         vc->scan->dump_object_data (vc->scan->find_object (vo->obj_id ()));
01260 }
01261 
01262 void ViewControl::obj_setoffset_callback (GtkWidget *widget, VObject *vo){
01263         vo->set_offset ();
01264 }
01265 
01266 void ViewControl::obj_getcoords_callback (GtkWidget *widget, VObject *vo){
01267         vo->SetUpScan ();
01268 }
01269 
01270 void ViewControl::obj_go_locmax_callback (GtkWidget *widget, VObject *vo){  
01271         //  vo->GoLocMax(((ViewControl*)gtk_object_get_data (GTK_OBJECT (widget), "ViewControl"))->local_radius);
01272         vo->GoLocMax ();
01273 }
01274 
01275 void ViewControl::obj_follow_callback (GtkWidget *widget, VObject *vo){  
01276         if (GTK_CHECK_MENU_ITEM (widget)->active)
01277                 vo->follow_on ();
01278         else
01279                 vo->follow_off ();
01280 }
01281 
01282 void ViewControl::obj_addnode_callback (GtkWidget *widget, VObject *vo){
01283         vo->AddNode ();
01284 }
01285 
01286 void ViewControl::obj_delnode_callback (GtkWidget *widget, VObject *vo){
01287         vo->DelNode ();
01288 }
01289 
01290 
01291 // handle Event Objects
01292 void ViewControl::obj_event_use_callback (GtkWidget *widget, VObject *vo){
01293         if (vo->get_scan_event())
01294                 (vo->get_scan_event())->print ();
01295 }
01296 
01297 void ViewControl::obj_event_open_callback (GtkWidget *widget, VObject *vo){
01298 }
01299 
01300 void ViewControl::obj_event_save_callback (GtkWidget *widget, VObject *vo){
01301 }
01302 
01303 
01304 void ViewControl::update_trace (double *xy, int len){
01305         double *nxy = new double[1+2*len];
01306         nxy[0] = len;
01307         memcpy (&nxy[1], xy, 2*len*sizeof(double));
01308         if (v_trace){
01309                 v_trace->Change (nxy);
01310         }else{
01311                 v_trace = new VObTrace(canvas, nxy, scan->Pkt2d, FALSE, VOBJ_COORD_ABSOLUT, "Tip Trace");
01312         }
01313         delete[] nxy;
01314         v_trace->Update ();
01315 }
01316 
01317 void ViewControl::remove_trace (){
01318         if (v_trace){
01319                 delete v_trace;
01320                 v_trace = NULL;
01321         }
01322 }
01323 
01324 

Generated on Sat Apr 1 09:03:50 2006 for GXSM by  doxygen 1.4.6