00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099 #include <gtk/gtk.h>
00100 #include "config.h"
00101 #include "gxsm/plugin.h"
00102
00103 #include "gxsm/unit.h"
00104 #include "gxsm/pcs.h"
00105 #include "gxsm/xsmtypes.h"
00106 #include "gxsm/glbvars.h"
00107 #include "gxsm/action_id.h"
00108
00109 #include "include/dsp-pci32/xsm/xsmcmd.h"
00110
00111 #include "plug-ins/control/spm_scancontrol.h"
00112
00113
00114 static void spm_scancontrol_init (void);
00115 static void spm_scancontrol_query (void);
00116 static void spm_scancontrol_about (void);
00117 static void spm_scancontrol_configure (void);
00118 static void spm_scancontrol_cleanup (void);
00119
00120
00121 static void spm_scancontrol_show_callback (GtkWidget *w, void *data);
00122 static void spm_scancontrol_start_callback (GtkWidget *w, void *data);
00123 static void spm_scancontrol_movie_callback (GtkWidget *w, void *data);
00124 static void spm_scancontrol_hscapture_callback (GtkWidget *w, void *data);
00125 static void spm_scancontrol_pause_callback (GtkWidget *w, void *data);
00126 static void spm_scancontrol_stop_callback (GtkWidget *w, void *data);
00127 static void spm_scancontrol_SaveValues_callback ( gpointer );
00128
00129
00130 GxsmPlugin spm_scancontrol_pi = {
00131 NULL,
00132 NULL,
00133 0,
00134 NULL,
00135
00136
00137 "Spm_ScanControl",
00138
00139 "+ALL +noHARD +SRanger:SPMHARD +SRangerTest:SPMHARD +Innovative_DSP:SPMHARD +Innovative_DSP:SPAHARD +TC211-CCDHARD +video4linuxHARD +Comedi:SPMHARD -LAN_RHK:SPMHARD",
00140
00141 "SPM scan control",
00142 "Percy Zahl",
00143 N_("_Windows/"),
00144 N_("SPM Scan Control"),
00145 N_("open SPM Scan Control Window"),
00146 "SPM Scan Control Window and Scan Generator PlugIn",
00147 NULL,
00148 NULL,
00149 spm_scancontrol_init,
00150 spm_scancontrol_query,
00151
00152
00153 spm_scancontrol_about,
00154
00155
00156 spm_scancontrol_configure,
00157
00158
00159 NULL,
00160
00161
00162 spm_scancontrol_cleanup
00163 };
00164
00165
00166 static const char *about_text = N_("Gxsm SPM Scan Generator and Control Plugin\n\n"
00167 "This plugin manages the SPM scanning process\n"
00168 "and multichannel/layer dataaquisitation."
00169 );
00170
00171
00172
00173 GxsmPlugin *get_gxsm_plugin_info ( void ){
00174 spm_scancontrol_pi.description = g_strdup_printf(N_("Gxsm spm_scancontrol plugin %s"), VERSION);
00175 return &spm_scancontrol_pi;
00176 }
00177
00178
00179 typedef struct {
00180 GSList *scan_list;
00181 GFunc UpdateFunc;
00182 gpointer data;
00183 } IdleRefreshFuncData;
00184
00185 SPM_ScanControl *spm_scancontrol = NULL;
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199 static void spm_scancontrol_query(void)
00200 {
00201 PI_DEBUG (DBG_L2, "spm_scancontrol_query" );
00202 static GnomeUIInfo menuinfo_windowcontrol[] = {
00203 { GNOME_APP_UI_ITEM,
00204 N_("SPM Scan Control"), N_("SPM Scan Control Window for advanced control"),
00205 (gpointer) spm_scancontrol_show_callback, NULL,
00206 NULL, GNOME_APP_PIXMAP_STOCK, GNOME_STOCK_MENU_OPEN,
00207 0, GDK_CONTROL_MASK, NULL },
00208 GNOMEUIINFO_END
00209 };
00210
00211 gnome_app_insert_menus (
00212 GNOME_APP(spm_scancontrol_pi.app->getApp()),
00213 N_("Windows/"),
00214 menuinfo_windowcontrol
00215 );
00216
00217 if(spm_scancontrol_pi.status) g_free(spm_scancontrol_pi.status);
00218 spm_scancontrol_pi.status = g_strconcat (
00219 N_("Plugin query has attached "),
00220 spm_scancontrol_pi.name,
00221 N_(": File IO Filters are ready to use"),
00222 NULL);
00223
00224 PI_DEBUG (DBG_L2, "spm_scancontrol_query:new" );
00225 spm_scancontrol = new SPM_ScanControl;
00226
00227 PI_DEBUG (DBG_L2, "spm_scancontrol_query:res" );
00228 spm_scancontrol->SetResName ("WindowSPMScanControl", "false", xsmres.geomsave);
00229
00230 spm_scancontrol_pi.app->ConnectPluginToCDFSaveEvent (spm_scancontrol_SaveValues_callback);
00231
00232
00233 PI_DEBUG (DBG_L2, "spm_scancontrol_query:done" );
00234 }
00235
00236 static void spm_scancontrol_SaveValues_callback ( gpointer gp_ncf ){
00237 gchar *tmp = NULL;
00238 if( spm_scancontrol )
00239 tmp = strdup (spm_scancontrol->GetScanDir()==1 ? "TopDown " : "BottomUp");
00240 else
00241 tmp = strdup ("N/A");
00242
00243 NcFile *ncf = (NcFile *) gp_ncf;
00244 NcDim* spmscd = ncf->add_dim("spm_scancontrol_dim", strlen(tmp));
00245 NcVar* spmsc = ncf->add_var("spm_scancontrol", ncChar, spmscd);
00246 spmsc->add_att("long_name", "spm_scancontrol: scan direction");
00247 spmsc->put(tmp, strlen(tmp));
00248 g_free (tmp);
00249 }
00250
00251
00252
00253
00254
00255
00256
00257
00258 static void spm_scancontrol_init(void)
00259 {
00260 PI_DEBUG (DBG_L2, "spm_scancontrol Plugin Init" );
00261 }
00262
00263
00264 static void spm_scancontrol_about(void)
00265 {
00266 const gchar *authors[] = { spm_scancontrol_pi.authors, NULL};
00267 gtk_widget_show(gnome_about_new ( spm_scancontrol_pi.name,
00268 VERSION,
00269 N_("(C) 2001 the Free Software Foundation"),
00270 about_text,
00271 authors,
00272 NULL, NULL, NULL
00273 ));
00274 }
00275
00276
00277 static void spm_scancontrol_configure(void)
00278 {
00279 if(spm_scancontrol_pi.app)
00280 spm_scancontrol_pi.app->message("spm_scancontrol Plugin Configuration");
00281 }
00282
00283
00284 static void spm_scancontrol_cleanup(void)
00285 {
00286 PI_DEBUG (DBG_L2, "spm_scancontrol Plugin Cleanup" );
00287 gnome_app_remove_menus (GNOME_APP (spm_scancontrol_pi.app->getApp()),
00288 N_("Windows/SPM Scan Control"), 1);
00289
00290 if( spm_scancontrol )
00291 delete spm_scancontrol ;
00292
00293 if(spm_scancontrol_pi.status) g_free(spm_scancontrol_pi.status);
00294 }
00295
00296 static void spm_scancontrol_show_callback( GtkWidget* widget, void* data){
00297 if( spm_scancontrol )
00298 spm_scancontrol->show();
00299 }
00300
00301 static void cb_setscandir( GtkWidget *widget, SPM_ScanControl *scc ){
00302 if (GTK_TOGGLE_BUTTON (widget)->active)
00303 scc->SetScanDir (widget);
00304 else
00305 scc->ClrScanDir (widget);
00306 }
00307
00308 SPM_ScanControl::SPM_ScanControl ()
00309 {
00310 GtkWidget *box, *hbox;
00311 GtkWidget *frame_param;
00312 GtkWidget *vbox_param, *hbox_param;
00313 GtkWidget *button;
00314
00315
00316
00317 GSList *EC_list=NULL;
00318 GSList **RemoteEntryList = new GSList *;
00319 *RemoteEntryList = NULL;
00320
00321 master_scan = NULL;
00322 master_probescan = NULL;
00323
00324 xp_scan_list = NULL;
00325 xp_2nd_scan_list = NULL;
00326 xp_prbscan_list = NULL;
00327 xm_scan_list = NULL;
00328 xm_2nd_scan_list = NULL;
00329 xm_prbscan_list = NULL;
00330 scan_flag = SCAN_FLAG_READY;
00331 scan_dir = SCAN_DIR_TOPDOWN;
00332 last_scan_dir = SCAN_DIR_TOPDOWN;
00333 do_probe = FALSE;
00334
00335 Unity = new UnitObj(" "," ");
00336
00337
00338
00339
00340
00341 AppWidgetInit("SPM Scan Control");
00342
00343 box = gtk_vbox_new (FALSE, 0);
00344 gtk_widget_show (box);
00345 gtk_box_pack_start (GTK_BOX (vbox), box, TRUE, TRUE, 0);
00346
00347 hbox = gtk_hbox_new (FALSE, 0);
00348 gtk_widget_show (hbox);
00349 gtk_box_pack_start (GTK_BOX (box), hbox, TRUE, TRUE, 0);
00350
00351 #define MYGTK_INPUT(L) mygtk_create_input(L, vbox_param, hbox_param, 50, 70);
00352
00353 frame_param = gtk_frame_new (N_("SPM Scan Control"));
00354 gtk_widget_show (frame_param);
00355 gtk_container_add (GTK_CONTAINER (hbox), frame_param);
00356
00357 vbox_param = gtk_vbox_new (FALSE, 0);
00358 gtk_widget_show (vbox_param);
00359 gtk_container_add (GTK_CONTAINER (frame_param), vbox_param);
00360
00361
00362
00363
00364
00365
00366 hbox_param = gtk_hbox_new (FALSE, 0);
00367 gtk_widget_show (hbox_param);
00368 gtk_box_pack_start (GTK_BOX (vbox_param), hbox_param, TRUE, TRUE, 0);
00369
00370 button = gtk_button_new_with_label("Start");
00371 gtk_widget_show (button);
00372 gtk_box_pack_start (GTK_BOX (hbox_param), button, TRUE, TRUE, 0);
00373 gtk_signal_connect ( GTK_OBJECT (button), "pressed",
00374 GTK_SIGNAL_FUNC (spm_scancontrol_start_callback),
00375 this);
00376 gapp->RegisterPluginToolbarButton (GTK_OBJECT (button), "Toolbar_Scan_Start");
00377
00378 button = gtk_button_new_with_label("Movie");
00379 gtk_widget_show (button);
00380 gtk_box_pack_start (GTK_BOX (hbox_param), button, TRUE, TRUE, 0);
00381 gtk_signal_connect ( GTK_OBJECT (button), "pressed",
00382 GTK_SIGNAL_FUNC (spm_scancontrol_movie_callback),
00383 this);
00384 gapp->RegisterPluginToolbarButton (GTK_OBJECT (button), "Toolbar_Scan_Movie");
00385
00386 button = gtk_button_new_with_label("HS Capture");
00387 gtk_widget_show (button);
00388 gtk_box_pack_start (GTK_BOX (hbox_param), button, TRUE, TRUE, 0);
00389 gtk_signal_connect ( GTK_OBJECT (button), "pressed",
00390 GTK_SIGNAL_FUNC (spm_scancontrol_hscapture_callback),
00391 this);
00392
00393
00394 button = gtk_button_new_with_label("Pause");
00395 gtk_widget_show (button);
00396 gtk_box_pack_start (GTK_BOX (hbox_param), button, TRUE, TRUE, 0);
00397 gtk_signal_connect ( GTK_OBJECT (button), "pressed",
00398 GTK_SIGNAL_FUNC (spm_scancontrol_pause_callback),
00399 this);
00400 gapp->RegisterPluginToolbarButton (GTK_OBJECT (button), "Toolbar_Scan_Pause");
00401
00402 button = gtk_button_new_with_label("Stop");
00403 gtk_widget_show (button);
00404 gtk_box_pack_start (GTK_BOX (hbox_param), button, TRUE, TRUE, 0);
00405 gtk_signal_connect ( GTK_OBJECT (button), "pressed",
00406 GTK_SIGNAL_FUNC (spm_scancontrol_stop_callback),
00407 this);
00408 gapp->RegisterPluginToolbarButton (GTK_OBJECT (button), "Toolbar_Scan_Stop");
00409
00410 GtkWidget *radiobutton;
00411 GSList *radiogroup;
00412
00413 hbox_param = gtk_hbox_new (FALSE, 0);
00414 gtk_widget_show (hbox_param);
00415 gtk_box_pack_start (GTK_BOX (vbox_param), hbox_param, TRUE, TRUE, 0);
00416
00417
00418 radiobutton = gtk_radio_button_new_with_label( NULL, "TopDown");
00419 gtk_box_pack_start (GTK_BOX (hbox_param), radiobutton, TRUE, TRUE, 0);
00420 gtk_widget_show (radiobutton);
00421 gtk_object_set_data (GTK_OBJECT (radiobutton), "SCANDIR", (void*) SCAN_DIR_TOPDOWN);
00422 gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
00423 GTK_SIGNAL_FUNC (cb_setscandir), this);
00424
00425 radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
00426
00427 radiobutton = gtk_radio_button_new_with_label (radiogroup, "TopDown BotUp");
00428 gtk_box_pack_start (GTK_BOX (hbox_param), radiobutton, TRUE, TRUE, 0);
00429 gtk_widget_show (radiobutton);
00430 gtk_object_set_data (GTK_OBJECT (radiobutton), "SCANDIR", (void*) SCAN_DIR_TOPDOWN_BOTUP);
00431 gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
00432 GTK_SIGNAL_FUNC (cb_setscandir), this);
00433
00434 radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
00435
00436 radiobutton = gtk_radio_button_new_with_label (radiogroup, "BotUp");
00437 gtk_box_pack_start (GTK_BOX (hbox_param), radiobutton, TRUE, TRUE, 0);
00438 gtk_widget_show (radiobutton);
00439 gtk_object_set_data (GTK_OBJECT (radiobutton), "SCANDIR", (void*) SCAN_DIR_BOTUP);
00440 gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
00441 GTK_SIGNAL_FUNC (cb_setscandir), this);
00442
00443
00444 gtk_object_set_data( GTK_OBJECT (widget), "SPMCONTROL_EC_list", EC_list);
00445
00446 }
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459 SPM_ScanControl::~SPM_ScanControl (){
00460
00461
00462
00463
00464 gapp->RegisterPluginToolbarButton (NULL, "Toolbar_Scan_Start");
00465 gapp->RegisterPluginToolbarButton (NULL, "Toolbar_Scan_Movie");
00466 gapp->RegisterPluginToolbarButton (NULL, "Toolbar_Scan_Pause");
00467 gapp->RegisterPluginToolbarButton (NULL, "Toolbar_Scan_Stop");
00468
00469 delete Unity;
00470
00471
00472 line = -1;
00473 do_scanline (TRUE);
00474
00475 }
00476
00477
00478
00479 void SPM_ScanControl::update(){
00480 g_slist_foreach((GSList*)gtk_object_get_data( GTK_OBJECT (widget), "SPMCONTROL_EC_list"),
00481 (GFunc) App::update_ec, NULL);
00482 }
00483
00484
00485
00486 static void spm_scancontrol_start_callback (GtkWidget *w, void *data){
00487 if (((SPM_ScanControl*)data) -> scan_in_progress())
00488 return;
00489
00490 gtk_widget_set_sensitive (w, FALSE);
00491 gtk_widget_set_sensitive ((GtkWidget*)gtk_object_get_data( GTK_OBJECT (w), "ToolbarButton"), FALSE);
00492
00493 gapp->xsm->data.ui.SetDateOfScanNow();
00494 gapp->spm_update_all();
00495 gapp->xsm->hardware->SetScanMode();
00496
00497 ((SPM_ScanControl*)data) -> do_scan();
00498 if(gapp->xsm->IsMode(MODE_AUTOSAVE))
00499 gapp->xsm->save(1);
00500
00501 gtk_widget_set_sensitive (w, TRUE);
00502 gtk_widget_set_sensitive ((GtkWidget*)gtk_object_get_data( GTK_OBJECT (w), "ToolbarButton"), TRUE);
00503 }
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515 static void spm_scancontrol_movie_callback (GtkWidget *w, void *data){
00516 int nostop;
00517 if (((SPM_ScanControl*)data) -> scan_in_progress())
00518 return;
00519
00520 gtk_widget_set_sensitive (w, FALSE);
00521 gtk_widget_set_sensitive ((GtkWidget*)gtk_object_get_data( GTK_OBJECT (w), "ToolbarButton"), FALSE);
00522
00523 do {
00524 time_t t;
00525 time(&t);
00526 G_FREE_STRDUP_PRINTF(gapp->xsm->data.ui.dateofscan, ctime(&t));
00527 gapp->spm_update_all();
00528 gapp->xsm->hardware->SetScanMode();
00529
00530 nostop = ((SPM_ScanControl*)data) -> do_scan();
00531
00532 if(gapp->xsm->IsMode(MODE_AUTOSAVE))
00533 gapp->xsm->save(1);
00534 } while (nostop);
00535
00536 gtk_widget_set_sensitive (w, TRUE);
00537 gtk_widget_set_sensitive ((GtkWidget*)gtk_object_get_data( GTK_OBJECT (w), "ToolbarButton"), TRUE);
00538 }
00539
00540 static void spm_scancontrol_hscapture_callback (GtkWidget *w, void *data){
00541 int nostop;
00542 if (((SPM_ScanControl*)data) -> scan_in_progress())
00543 return;
00544 do {
00545 time_t t;
00546 time(&t);
00547 G_FREE_STRDUP_PRINTF(gapp->xsm->data.ui.dateofscan, ctime(&t));
00548 gapp->spm_update_all();
00549 gapp->xsm->hardware->SetScanMode();
00550
00551 nostop = ((SPM_ScanControl*)data) -> do_hscapture();
00552
00553 if(gapp->xsm->IsMode(MODE_AUTOSAVE))
00554 gapp->xsm->save(1);
00555 } while (nostop);
00556 }
00557
00558 static void spm_scancontrol_pause_callback (GtkWidget *w, void *data){
00559 ((SPM_ScanControl*)data) -> pause_scan();
00560 }
00561
00562 static void spm_scancontrol_stop_callback (GtkWidget *w, void *data){
00563 ((SPM_ScanControl*)data) -> stop_scan();
00564 }
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583 #define MSK_PID(X) (1<<((X)&3))
00584 #define MSK_MUXA(X) (1<<(((X)&3)+4))
00585 #define MSK_MUXB(X) (1<<(((X)&3)+8))
00586 #define MSK_AUX(X) (1<<(((X)&3)+12))
00587
00588
00589 int SPM_ScanControl::free_scan_lists (){
00590 if (xp_scan_list){
00591 g_slist_free (xp_scan_list);
00592 xp_scan_list = NULL;
00593 }
00594 if (xp_2nd_scan_list){
00595 g_slist_free (xp_2nd_scan_list);
00596 xp_2nd_scan_list = NULL;
00597 }
00598 if (xp_prbscan_list){
00599 g_slist_free (xp_prbscan_list);
00600 xp_prbscan_list = NULL;
00601 }
00602 if (xm_scan_list){
00603 g_slist_free (xm_scan_list);
00604 xm_scan_list = NULL;
00605 }
00606 if (xm_2nd_scan_list){
00607 g_slist_free (xm_2nd_scan_list);
00608 xm_2nd_scan_list = NULL;
00609 }
00610 if (xm_prbscan_list){
00611 g_slist_free (xm_prbscan_list);
00612 xm_prbscan_list = NULL;
00613 }
00614
00615 return 0;
00616 }
00617
00618
00619 int SPM_ScanControl::initialize_scan_lists (){
00620 int i,ipid,idaq,i2nddaq,iprb,ch,sok,checks;
00621
00622 if (xp_scan_list || xm_scan_list
00623 || xp_2nd_scan_list || xm_2nd_scan_list
00624 || xp_prbscan_list || xm_prbscan_list)
00625 return -1;
00626
00627 do_probe = FALSE;
00628 master_scan = NULL;
00629 master_probescan = NULL;
00630
00631 sok=FALSE;
00632 checks=2;
00633 xp_srcs = xm_srcs = 0;
00634 xp_2nd_srcs = xm_2nd_srcs = 0;
00635
00636
00637 do {
00638 PI_DEBUG (DBG_L3, "SPM_SCANCONTROL::initialize_scan_lists : do");
00639
00640
00641 for (ipid=idaq=i2nddaq=iprb=i=0; i < MAXSCANS; i++){
00642
00643
00644 for (ch = -1; (ipid < PIDCHMAX) && ((ch=gapp->xsm->FindChan(xsmres.pidchno[ipid++])) < 0););
00645
00646 if(ch >= 0){
00647 PI_DEBUG (DBG_L3, "SPM_SCANCONTROL::initialize_scan_lists : Setting up XpScan - PID src found");
00648
00649 xp_srcs |= MSK_PID(ipid-1);
00650
00651 setup_scan (ch, "X+",
00652 xsmres.pidsrc[ipid-1],
00653 xsmres.pidsrcZunit[ipid-1],
00654 xsmres.pidsrcZlabel[ipid-1]
00655 );
00656
00657 xp_scan_list = g_slist_prepend (xp_scan_list, gapp->xsm->scan[ch]);
00658
00659 if (!master_scan) master_scan = gapp->xsm->scan[ch];
00660
00661 sok=TRUE;
00662 }
00663 else{
00664
00665
00666 for(ch = -1; (idaq < DAQCHMAX) && ((ch=gapp->xsm->FindChan(xsmres.daqchno[idaq++])) < 0););
00667 if(ch >= 0){
00668
00669 if(idaq <= 4)
00670 xp_srcs |= MSK_MUXA(idaq-1);
00671 else{
00672
00673 if(idaq <= 8)
00674 xp_srcs |= MSK_MUXB(idaq-5);
00675 else
00676
00677 xp_srcs |= MSK_AUX(idaq-9);
00678 }
00679 PI_DEBUG (DBG_L3, "SPM_SCANCONTROL::initialize_scan_lists : Setting up XpScan - DAQ src found");
00680
00681 setup_scan (ch, "X+",
00682 xsmres.daqsrc[idaq-1],
00683 xsmres.daqZunit[idaq-1],
00684 xsmres.daqZlabel[idaq-1]
00685 );
00686
00687 xp_scan_list = g_slist_prepend (xp_scan_list, gapp->xsm->scan[ch]);
00688 if (!master_scan) master_scan = gapp->xsm->scan[ch];
00689 sok=TRUE;
00690 }
00691 else{
00692
00693
00694 for(ch = -1; (i2nddaq < DAQCHMAX) && ((ch=gapp->xsm->FindChan(ID_CH_M_2ND_OFFSET+xsmres.daqchno[i2nddaq++])) < 0););
00695 if(ch >= 0){
00696
00697 if(i2nddaq <= 4)
00698 xp_2nd_srcs |= MSK_MUXA(i2nddaq-1);
00699 else{
00700
00701 if(i2nddaq <= 8)
00702 xp_2nd_srcs |= MSK_MUXB(i2nddaq-5);
00703 else
00704
00705 xp_2nd_srcs |= MSK_AUX(i2nddaq-9);
00706 }
00707 PI_DEBUG (DBG_L3, "SPM_SCANCONTROL::initialize_scan_lists : Setting up 2nd XpScan - DAQ src found");
00708
00709 setup_scan (ch, "X2+",
00710 xsmres.daqsrc[i2nddaq-1],
00711 xsmres.daqZunit[i2nddaq-1],
00712 xsmres.daqZlabel[i2nddaq-1]
00713 );
00714
00715 xp_2nd_scan_list = g_slist_prepend (xp_2nd_scan_list, gapp->xsm->scan[ch]);
00716 if (!master_scan) master_scan = gapp->xsm->scan[ch];
00717 sok=TRUE;
00718 }
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742 }
00743 }
00744 }
00745
00746
00747
00748 for (ipid=i2nddaq=idaq=i=0; i<MAXSCANS; i++){
00749
00750 for(ch = -1; (ipid < PIDCHMAX) && ((ch=gapp->xsm->FindChan(-xsmres.pidchno[ipid++])) < 0););
00751
00752 if(ch >= 0){
00753 PI_DEBUG (DBG_L3, "SPM_SCANCONTROL::initialize_scan_lists : Setting up XmScan - PID src found");
00754 xm_srcs |= MSK_PID(ipid-1);
00755
00756 setup_scan (ch, "X-",
00757 xsmres.pidsrc[ipid-1],
00758 xsmres.pidsrcZunit[ipid-1],
00759 xsmres.pidsrcZlabel[ipid-1]
00760 );
00761 xm_scan_list = g_slist_prepend (xm_scan_list, gapp->xsm->scan[ch]);
00762 if (!master_scan) master_scan = gapp->xsm->scan[ch];
00763 sok=TRUE;
00764 }
00765 else{
00766 for(ch = -1; (idaq < DAQCHMAX) && ((ch=gapp->xsm->FindChan(-xsmres.daqchno[idaq++])) < 0););
00767 if(ch >= 0){
00768 if(idaq <= 4)
00769 xm_srcs |= MSK_MUXA(idaq-1);
00770 else{
00771 if(idaq <= 8)
00772 xm_srcs |= MSK_MUXB(idaq-5);
00773 else
00774 xm_srcs |= MSK_AUX(idaq-9);
00775 }
00776
00777 PI_DEBUG (DBG_L3, "SPM_SCANCONTROL::initialize_scan_lists : Setting up XmScan - DAQ src found");
00778 setup_scan (ch, "X-",
00779 xsmres.daqsrc[idaq-1],
00780 xsmres.daqZunit[idaq-1],
00781 xsmres.daqZlabel[idaq-1]
00782 );
00783 xm_scan_list = g_slist_prepend (xm_scan_list, gapp->xsm->scan[ch]);
00784 if (!master_scan) master_scan = gapp->xsm->scan[ch];
00785 sok=TRUE;
00786 }
00787 else{
00788 for(ch = -1; (i2nddaq < DAQCHMAX) && ((ch=gapp->xsm->FindChan(-ID_CH_M_2ND_OFFSET-xsmres.daqchno[i2nddaq++])) < 0););
00789 if(ch >= 0){
00790 if(i2nddaq <= 4)
00791 xm_2nd_srcs |= MSK_MUXA(i2nddaq-1);
00792 else{
00793 if(i2nddaq <= 8)
00794 xm_2nd_srcs |= MSK_MUXB(i2nddaq-5);
00795 else
00796 xm_2nd_srcs |= MSK_AUX(i2nddaq-9);
00797 }
00798
00799 PI_DEBUG (DBG_L3, "SPM_SCANCONTROL::initialize_scan_lists : Setting up 2nd XmScan - DAQ src found");
00800 setup_scan (ch, "X2-",
00801 xsmres.daqsrc[i2nddaq-1],
00802 xsmres.daqZunit[i2nddaq-1],
00803 xsmres.daqZlabel[i2nddaq-1]
00804 );
00805 xm_2nd_scan_list = g_slist_prepend (xm_2nd_scan_list, gapp->xsm->scan[ch]);
00806 if (!master_scan) master_scan = gapp->xsm->scan[ch];
00807 sok=TRUE;
00808 }
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832 }
00833 }
00834 }
00835
00836
00837
00838 if(! sok){
00839 PI_DEBUG (DBG_L3, "SPM_SCANCONTROL::initialize_scan_lists : No Srcs specified, setting up default!");
00840 ch = gapp->xsm->FindChan(ID_CH_M_ACTIVE);
00841 if(!(ch >= 0)){
00842 ch = gapp->xsm->FindChan(ID_CH_M_MATH);
00843 if(!(ch >= 0))
00844 ch = gapp->xsm->FindChan(ID_CH_M_OFF);
00845 else{
00846 scan_flag = SCAN_FLAG_RUN;
00847 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOFREECHAN,"",1);
00848 return FALSE;
00849 }
00850 }
00851 gapp->channelselector->SetMode(ch, xsmres.piddefault);
00852 gapp->xsm->ChannelMode[ch] = xsmres.piddefault;
00853 gapp->xsm->ChannelScanMode[ch] = gapp->xsm->ChannelScanMode[ch] < 0 ? -xsmres.piddefault : xsmres.piddefault;
00854 }
00855 }while (! sok && --checks);
00856
00857
00858 if (!checks)
00859 XSM_SHOW_ALERT (ERR_SORRY, ERR_NOSRCCHAN, "", 1);
00860
00861 return 0;
00862 }
00863
00864 int SPM_ScanControl::setup_scan (int ch,
00865 const gchar *titleprefix,
00866 const gchar *name,
00867 const gchar *unit,
00868 const gchar *label,
00869 const gchar *vunit,
00870 const gchar *vlabel,
00871 const gchar *prbsrcs,
00872 int prboutp
00873 ){
00874 PI_DEBUG (DBG_L2, "setup_scan");
00875
00876 if ( ! gapp->xsm->scan[ch]){
00877 gapp->xsm->scan[ch] = gapp->xsm->NewScan (gapp->xsm->ChannelView[ch],
00878 gapp->xsm->data.display.ViewFlg,
00879 ch,
00880 &gapp->xsm->data);
00881
00882 if (!gapp->xsm->scan[ch]){
00883 XSM_SHOW_ALERT (ERR_SORRY, ERR_NOMEM,"",1);
00884 return FALSE;
00885 }
00886 }
00887
00888
00889 UnitObj *u = gapp->xsm->MakeUnit (unit, label);
00890 gapp->xsm->scan[ch]->data.SetZUnit (u);
00891 delete u;
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920 gapp->xsm->scan[ch]->create (TRUE);
00921
00922
00923 gapp->xsm->scan[ch]->data.s.dz = gapp->xsm->Inst->ZResolution (unit);
00924
00925
00926 gchar *scantitle = g_strdup_printf ("%s %s", titleprefix, name);
00927 gapp->xsm->scan[ch]->data.ui.SetName (scantitle);
00928 gapp->xsm->scan[ch]->data.ui.SetOriginalName ("unknown");
00929 gapp->xsm->scan[ch]->data.ui.SetTitle (scantitle);
00930 gapp->xsm->scan[ch]->data.ui.SetType (scantitle);
00931 g_free (scantitle);
00932 gapp->xsm->scan[ch]->draw ();
00933
00934 return 0;
00935 }
00936
00937 int SPM_ScanControl::prepare_to_start_scan (SCAN_DT_TYPE st){
00938
00939 if (IS_SPALEED_CTRL||xsmres.ScanOrgCenter)
00940 YOriginTop = FALSE;
00941 else
00942 YOriginTop = TRUE;
00943 scan_flag = SCAN_FLAG_RUN;
00944
00945 gapp->SetStatus ("Starting Scan: Ch.Setup");
00946 gapp->check_events ();
00947
00948
00949 gapp->xsm->hardware->SetDxDy (
00950 R2INT (gapp->xsm->Inst->XA2Dig (gapp->xsm->data.s.dx)),
00951 R2INT (gapp->xsm->Inst->YA2Dig (gapp->xsm->data.s.dy)));
00952 gapp->xsm->hardware->SetNxNy (gapp->xsm->data.s.nx, gapp->xsm->data.s.ny);
00953
00954 gapp->xsm->data.s.dz = gapp->xsm->Inst->ZResolution ();
00955
00956 gapp->SignalStartScanEventToPlugins ();
00957
00958
00959 int result = initialize_scan_lists ();
00960
00961 if (result){
00962 XSM_SHOW_ALERT (ERR_SORRY, ERR_SCAN_CANCEL,
00963 "Channel setup failed.",
00964 1);
00965 return result;
00966 }
00967
00968
00969 int ns_xp=0;
00970 int ns_xm=0;
00971 for (int i=0; i<16; ++i){
00972 if (xp_srcs&(1<<i)) ++ns_xp;
00973 if (xm_srcs&(1<<i)) ++ns_xm;
00974 }
00975
00976
00977 switch (st){
00978 case SCAN_LINESCAN:
00979 if (gapp->xsm->data.s.nx*ns_xp >= gapp->xsm->hardware->GetMaxPointsPerLine ()){
00980 gchar *maxtxt = g_strdup_printf ("Hardware limits points per line to\n"
00981 "%ld in total for all channels (->)!",
00982 gapp->xsm->hardware->GetMaxPointsPerLine());
00983 XSM_SHOW_ALERT (ERR_SORRY,ERR_SCAN_CANCEL, maxtxt, 1);
00984 g_free (maxtxt);
00985 return -1;
00986 }
00987 if (gapp->xsm->data.s.nx*ns_xm >= gapp->xsm->hardware->GetMaxPointsPerLine ()){
00988 gchar *maxtxt = g_strdup_printf ("Hardware limits points per line to\n"
00989 "%ld in total for all channels (<-)!",
00990 gapp->xsm->hardware->GetMaxPointsPerLine());
00991 XSM_SHOW_ALERT (ERR_SORRY,ERR_SCAN_CANCEL, maxtxt, 1);
00992 g_free (maxtxt);
00993 return -1;
00994 }
00995 return 0;
00996 case SCAN_FRAMECAPTURE:
00997 if (gapp->xsm->data.s.nx*gapp->xsm->data.s.ny*ns_xp >= gapp->xsm->hardware->GetMaxPointsPerLine ()){
00998 gchar *maxtxt = g_strdup_printf ("Hardware limits points per frame to\n"
00999 "%ld in total for all channels (->)!",
01000 gapp->xsm->hardware->GetMaxPointsPerLine());
01001 XSM_SHOW_ALERT (ERR_SORRY,ERR_SCAN_CANCEL, maxtxt, 1);
01002 g_free (maxtxt);
01003 return -1;
01004 }
01005 if (gapp->xsm->data.s.nx*gapp->xsm->data.s.ny*ns_xm >= gapp->xsm->hardware->GetMaxPointsPerLine ()){
01006 gchar *maxtxt = g_strdup_printf ("Hardware limits points per frame to\n"
01007 "%ld in total for all channels (<-)!",
01008 gapp->xsm->hardware->GetMaxPointsPerLine());
01009 XSM_SHOW_ALERT (ERR_SORRY,ERR_SCAN_CANCEL, maxtxt, 1);
01010 g_free (maxtxt);
01011 return -1;
01012 }
01013 return 0;
01014 default: return -1;
01015 }
01016 }
01017
01018
01019 void IdleRefreshFunc (gpointer data){
01020 g_slist_foreach ((GSList*) ((IdleRefreshFuncData*)data)->scan_list,
01021 (GFunc) ((IdleRefreshFuncData*)data)->UpdateFunc,
01022 ((IdleRefreshFuncData*)data)->data);
01023 }
01024
01025
01026 void SPM_ScanControl::do_scanline (int init){
01027 static Mem2d **m2d_xp=NULL;
01028 static Mem2d **m2d_xm=NULL;
01029 static IdleRefreshFuncData idf_data;
01030
01031
01032 if (init){
01033 int num;
01034 PI_DEBUG (DBG_L2, "SPM_ScanControl::do_scanline : init");
01035 if (m2d_xp){
01036 g_free (m2d_xp);
01037 m2d_xp = NULL;
01038 }
01039 if (m2d_xm){
01040 g_free (m2d_xm);
01041 m2d_xm = NULL;
01042 }
01043 if( line < 0)
01044 return;
01045
01046 num = g_slist_length (xp_scan_list);
01047 if (num>0){
01048 Mem2d **m;
01049 m = m2d_xp = (Mem2d**) g_new (Mem2d*, num+1);
01050 GSList* tmp = g_slist_copy (xp_scan_list);
01051 GSList* rev = tmp = g_slist_reverse(tmp);
01052 while (tmp){
01053 *m++ = ((Scan*)tmp->data)->mem2d;
01054 ((Scan*)tmp->data)->view->remove_events();
01055 tmp = g_slist_next (tmp);
01056 }
01057 *m = NULL;
01058 g_slist_free (rev);
01059 }
01060
01061 num = g_slist_length (xm_scan_list);
01062 PI_DEBUG (DBG_L2, "SPM_ScanControl::do_scanline : init, num xm=" << num);
01063 if (num > 0){
01064 Mem2d **m;
01065 m = m2d_xm = (Mem2d**) g_new (Mem2d*, num+1);
01066 GSList* tmp = g_slist_copy (xm_scan_list);
01067 GSList* rev = tmp = g_slist_reverse(tmp);
01068 while (tmp){
01069 *m++ = ((Scan*)tmp->data)->mem2d;
01070 ((Scan*)tmp->data)->view->remove_events();
01071 tmp = g_slist_next (tmp);
01072 }
01073 *m = NULL;
01074 g_slist_free (rev);
01075 }
01076 idf_data.scan_list = NULL;
01077 idf_data.UpdateFunc = (GFunc) SPM_ScanControl::call_scan_draw_line;
01078 idf_data.data = this;
01079 PI_DEBUG (DBG_L2, "SPM_ScanControl::do_scanline : init done");
01080
01081 gapp->xsm->hardware->ScanLineM (-2, 1, xp_srcs, m2d_xp, 0);
01082 gapp->xsm->hardware->ScanLineM (-2, -1, xm_srcs, m2d_xm, 0);
01083
01084 return;
01085 }
01086
01087 if (line == -1){
01088
01089 if (m2d_xp)
01090 gapp->xsm->hardware->ScanLineM (-1, 1, xp_srcs, m2d_xp, ix0off);
01091
01092
01093 if (m2d_xm)
01094 PI_DEBUG (DBG_L2, "Sorry -- not in HS Capture mode" );
01095
01096 return;
01097 }
01098
01099
01100
01101
01102
01103 if (m2d_xp){
01104
01105 gapp->xsm->hardware->ScanLineM (line, 1, xp_srcs, m2d_xp, ix0off);
01106
01107 line2update = line;
01108 idf_data.scan_list = xp_scan_list;
01109 gapp->xsm->hardware->SetIdleFunc (&IdleRefreshFunc, &idf_data);
01110 }
01111
01112
01113
01114 if (m2d_xm){
01115 gapp->xsm->hardware->ScanLineM(line, -1, xm_srcs, m2d_xm, ix0off);
01116
01117 line2update = line;
01118 idf_data.scan_list = xm_scan_list;
01119 gapp->xsm->hardware->SetIdleFunc (&IdleRefreshFunc, &idf_data);
01120 }
01121
01122 autosave_check (update_status_info ());
01123 }
01124
01125 void SPM_ScanControl::run_probe (int ipx, int ipy){
01126
01127 }
01128
01129 void SPM_ScanControl::set_subscan (int ix0, int num){
01130 int n;
01131 ix0off = ix0;
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144 PI_DEBUG (DBG_L2, "SPM_ScanControl::set_subscan" << ix0off << ":" << n);
01145
01146 n = master_scan->data.s.nx;
01147
01148
01149 for (GSList* tmp = xp_scan_list; tmp; tmp = g_slist_next (tmp))
01150 ((Scan*)tmp->data) -> mem2d->data->ZPutDataSetDest (ix0off, n);
01151
01152 for (GSList* tmp = xm_scan_list; tmp; tmp = g_slist_next (tmp))
01153 ((Scan*)tmp->data) -> mem2d->data->ZPutDataSetDest (ix0off, n);
01154 }
01155
01156 int SPM_ScanControl::do_scan (){
01157 PI_DEBUG (DBG_L2, "do_scan");
01158
01159 if (scan_in_progress ()){
01160 PI_DEBUG (DBG_L2, "do_scan scan in progress, exiting.");
01161 return FALSE;
01162 }
01163
01164 if (prepare_to_start_scan ()){
01165 PI_DEBUG (DBG_L2, "prepare scan failed, exiting.");
01166 stop_scan ();
01167 free_scan_lists ();
01168 return FALSE;
01169 }
01170
01171 PI_DEBUG (DBG_L2, "do_scan precheck done.");
01172
01173
01174 gapp->spm_freeze_scanparam();
01175
01176 PI_DEBUG (DBG_L2, "do_scan SetOffsets.");
01177
01178 if (!IS_SPALEED_CTRL)
01179 gapp->xsm->hardware->SetOffset (R2INT (gapp->xsm->Inst->X0A2Dig (master_scan->data.s.x0)),
01180 R2INT (gapp->xsm->Inst->Y0A2Dig (master_scan->data.s.y0)));
01181 else
01182 gapp->xsm->hardware->SetOffset (R2INT(gapp->xsm->Inst->X0A2Dig (master_scan->data.s.x0)
01183 + master_scan->data.s.SPA_OrgX/gapp->xsm->Inst->XResolution ()),
01184 R2INT(gapp->xsm->Inst->Y0A2Dig (master_scan->data.s.y0)
01185 + master_scan->data.s.SPA_OrgY/gapp->xsm->Inst->YResolution ()));
01186
01187 switch (scan_dir){
01188 case SCAN_DIR_TOPDOWN:
01189 last_scan_dir = SCAN_DIR_TOPDOWN;
01190 break;
01191 case SCAN_DIR_TOPDOWN_BOTUP:
01192 last_scan_dir = last_scan_dir == SCAN_DIR_TOPDOWN ? SCAN_DIR_BOTUP : SCAN_DIR_TOPDOWN;
01193 break;
01194 case SCAN_DIR_BOTUP:
01195 last_scan_dir = SCAN_DIR_BOTUP;
01196 break;
01197 }
01198
01199 gapp->xsm->hardware->ScanDirection(last_scan_dir == SCAN_DIR_TOPDOWN? +1 : -1);
01200
01201
01202 PI_DEBUG (DBG_L2, "do_scan Moveto 0,0, Rotate, Moveto.");
01203
01204 if (last_scan_dir == SCAN_DIR_TOPDOWN){
01205 if (!IS_SPALEED_CTRL)
01206 yline = 0;
01207 else{
01208 yline = R2INT(gapp->xsm->Inst->YA2Dig((-master_scan->data.s.ny/2)*master_scan->data.s.dy));
01209 }
01210 gapp->xsm->hardware->MovetoXY(0, yline);
01211 PI_DEBUG (DBG_L2, "Moveto:0,"<<yline);
01212
01213
01214 gapp->xsm->hardware->SetAlpha(master_scan->data.s.alpha);
01215 PI_DEBUG (DBG_L2, "Set alpha: "<<master_scan->data.s.alpha);
01216 }
01217
01218
01219 g_slist_foreach ((GSList*) xp_scan_list,
01220 (GFunc) SPM_ScanControl::call_scan_start, this);
01221 g_slist_foreach ((GSList*) xm_scan_list,
01222 (GFunc) SPM_ScanControl::call_scan_start, this);
01223
01224 gapp->xsm->hardware->StartScan2D();
01225
01226 line = 0;
01227 do_scanline (TRUE);
01228 update_status_info (TRUE);
01229 autosave_check (0., xsmres.AutosaveValue);
01230 set_subscan ();
01231
01232
01233
01234 if(!xm_srcs) xm_srcs = xp_srcs;
01235 if(!xp_srcs) xp_srcs = xm_srcs;
01236
01237 PI_DEBUG (DBG_L3, "DoScan: Setup MUX");
01238
01239
01240 #ifdef XSM_DEBUG_OPTION
01241 PI_DEBUG (DBG_L3, "xp_srcs: " << xp_srcs );
01242 for(int i=0; i<16; i++) PI_DEBUG_PLAIN (DBG_L2, (int)((xp_srcs&(1<<i))?1:0)); PI_DEBUG_PLAIN (DBG_L2, std::endl);
01243 PI_DEBUG (DBG_L3, "xm_srcs: " << xm_srcs );
01244 for(int i=0; i<16; i++) PI_DEBUG_PLAIN (DBG_L2, (int)((xm_srcs&(1<<i))?1:0)); PI_DEBUG_PLAIN (DBG_L2, std::endl);
01245 #endif
01246
01247 PI_DEBUG (DBG_L3, "DoScan: Start Scan now");
01248
01249 {
01250 gchar *muxcoding = g_strdup_printf ("xp_srcs: %2X xm_srcs: %2X", xp_srcs, xm_srcs);
01251 gapp->monitorcontrol->LogEvent ("*StartScan", muxcoding);
01252 g_free (muxcoding);
01253 }
01254
01255
01256 for(line = last_scan_dir == SCAN_DIR_TOPDOWN ? 0 : master_scan->data.s.ny-1;
01257 (last_scan_dir == SCAN_DIR_TOPDOWN ? line < master_scan->data.s.ny : line >= 0)
01258 && scan_flag != SCAN_FLAG_STOP;
01259 ){
01260
01261 if (scan_flag == SCAN_FLAG_RUN){
01262
01263
01264
01265
01266 if (YOriginTop)
01267 yline = R2INT (gapp->xsm->Inst->YA2Dig (
01268 -line*master_scan->data.s.dy));
01269 else
01270 yline = R2INT (gapp->xsm->Inst->YA2Dig (
01271 -(line - master_scan->data.s.ny/2)*master_scan->data.s.dy));
01272
01273 gapp->xsm->hardware->MovetoXY (
01274 R2INT (gapp->xsm->Inst->XA2Dig (
01275 master_scan->data.s.dx
01276 * (ix0off - gapp->xsm->hardware->GetPreScanLineOffset () - master_scan->data.s.nx/2)
01277 )),
01278 yline);
01279
01280
01281
01282 do_scanline ();
01283
01284
01285 last_scan_dir == SCAN_DIR_TOPDOWN ? ++line : --line;
01286 }
01287 gapp->check_events();
01288 }
01289
01290
01291 gapp->xsm->hardware->EndScan2D ();
01292 gapp->xsm->hardware->CallIdleFunc ();
01293 gapp->xsm->hardware->SetIdleFunc (NULL, NULL);
01294
01295 if( line < master_scan->data.s.ny && line&1)
01296 line++;
01297
01298
01299
01300 g_slist_foreach ((GSList*) xp_scan_list,
01301 (GFunc) SPM_ScanControl::call_scan_stop, this);
01302 g_slist_foreach ((GSList*) xm_scan_list,
01303 (GFunc) SPM_ScanControl::call_scan_stop, this);
01304
01305 return finish_scan ();
01306 }
01307
01308 int SPM_ScanControl::do_hscapture (){
01309 if (scan_in_progress ()){
01310 PI_DEBUG (DBG_L2, "do_scan scan in progress, exiting.");
01311 return FALSE;
01312 }
01313
01314 if (prepare_to_start_scan (SCAN_FRAMECAPTURE)){
01315 PI_DEBUG (DBG_L2, "prepare scan failed, exiting.");
01316 stop_scan ();
01317 free_scan_lists ();
01318 return FALSE;
01319 }
01320
01321
01322 gapp->spm_freeze_scanparam();
01323
01324
01325 if (!IS_SPALEED_CTRL)
01326 gapp->xsm->hardware->SetOffset (R2INT (gapp->xsm->Inst->X0A2Dig (master_scan->data.s.x0)),
01327 R2INT (gapp->xsm->Inst->Y0A2Dig (master_scan->data.s.y0)));
01328 else
01329 gapp->xsm->hardware->SetOffset (R2INT(gapp->xsm->Inst->X0A2Dig (master_scan->data.s.x0)
01330 + master_scan->data.s.SPA_OrgX/gapp->xsm->Inst->XResolution ()),
01331 R2INT(gapp->xsm->Inst->Y0A2Dig (master_scan->data.s.y0)
01332 + master_scan->data.s.SPA_OrgY/gapp->xsm->Inst->YResolution ()));
01333
01334
01335 gapp->xsm->hardware->MovetoXY (0,0);
01336 gapp->xsm->hardware->SetAlpha (master_scan->data.s.alpha);
01337
01338
01339 g_slist_foreach ((GSList*) xp_scan_list,
01340 (GFunc) SPM_ScanControl::call_scan_start, this);
01341 g_slist_foreach ((GSList*) xm_scan_list,
01342 (GFunc) SPM_ScanControl::call_scan_start, this);
01343
01344 gapp->xsm->hardware->StartScan2D();
01345
01346 line = 0;
01347 do_scanline (TRUE);
01348 update_status_info (TRUE);
01349
01350
01351
01352 if(!xm_srcs) xm_srcs = xp_srcs;
01353 if(!xp_srcs) xp_srcs = xm_srcs;
01354
01355
01356 #ifdef XSM_DEBUG_OPTION
01357 PI_DEBUG (DBG_L4, "xp_srcs: " << xp_srcs );
01358 for(int i=0; i<16; i++) PI_DEBUG_PLAIN (DBG_L2, (int)((xp_srcs&(1<<i))?1:0)); PI_DEBUG_PLAIN (DBG_L2, std::endl );
01359 PI_DEBUG (DBG_L4, "xm_srcs: " << xm_srcs );
01360 for(int i=0; i<16; i++) PI_DEBUG_PLAIN (DBG_L2, (int)((xm_srcs&(1<<i))?1:0)); PI_DEBUG_PLAIN (DBG_L2, std::endl );
01361 #endif
01362
01363 {
01364 gchar *muxcoding = g_strdup_printf ("xp_srcs: %2X xm_srcs: %2X", xp_srcs, xm_srcs);
01365 gapp->monitorcontrol->LogEvent ("*StartHSCapture", muxcoding);
01366 g_free (muxcoding);
01367 }
01368
01369 if (scan_flag != SCAN_FLAG_STOP ){
01370 if (!YOriginTop){
01371 int yline = R2INT (gapp->xsm->Inst->YA2Dig (
01372 -(line - master_scan->data.s.ny/2)
01373 *master_scan->data.s.dy));
01374 gapp->xsm->hardware->MovetoXY (
01375 R2INT (gapp->xsm->Inst->XA2Dig (
01376 master_scan->data.s.dx
01377 * (ix0off - gapp->xsm->hardware->GetPreScanLineOffset ()
01378 - master_scan->data.s.nx/2)
01379 )),
01380 yline);
01381 }
01382
01383 line = -1;
01384 do_scanline ();
01385 gapp->check_events ();
01386 }
01387
01388 gapp->xsm->hardware->EndScan2D ();
01389 line = master_scan->data.s.ny;
01390 g_slist_foreach ((GSList*) xp_scan_list,
01391 (GFunc) SPM_ScanControl::call_scan_stop, this);
01392 g_slist_foreach ((GSList*) xm_scan_list,
01393 (GFunc) SPM_ScanControl::call_scan_stop, this);
01394
01395 return finish_scan ();
01396 }
01397
01398 int SPM_ScanControl::finish_scan (){
01399 int stopped;
01400 PI_DEBUG (DBG_L2, "finish_scan.");
01401
01402
01403 gapp->xsm->hardware->MovetoXY(0,0);
01404 PI_DEBUG (DBG_L2, "Return to (0,0) at the end of the scan.");
01405
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415
01416
01417
01418
01419
01420 gapp->spm_thaw_scanparam();
01421
01422 if ((stopped = scan_flag == SCAN_FLAG_STOP ? TRUE:FALSE)){
01423 gapp->SetStatus("Scan interrupted");
01424 gapp->monitorcontrol->LogEvent("*EndOfScan", "interrupted");
01425 }
01426 else{
01427 gapp->SetStatus("Scan done, ready");
01428 gapp->monitorcontrol->LogEvent("*EndOfScan", "OK");
01429 }
01430
01431 free_scan_lists ();
01432 scan_flag = SCAN_FLAG_READY;
01433
01434
01435 return !stopped;
01436 }
01437
01438 double SPM_ScanControl::update_status_info (int reset){
01439 static time_t tn, tnlog, t0;
01440 time_t t;
01441
01442 if (reset){
01443 time (&t0);
01444 tnlog=tn=t0;
01445 return 0.;
01446 }
01447
01448 time (&t);
01449
01450 if ((t-tn) > 2){
01451 double ss,s,m,h, sse,se,me,he;
01452 double n_by_lines_to_do;
01453 gchar *tt;
01454 tn=t;
01455 ss = s = tn-t0;
01456 h = floor (s/3600.);
01457 m = floor ((s-h*3600.)/60.);
01458 s-= h*3600.+m*60.;
01459
01460 n_by_lines_to_do = (double)master_scan->data.s.ny
01461 / (double)(last_scan_dir == SCAN_DIR_TOPDOWN ?
01462 line+1 : master_scan->data.s.ny-line);
01463 sse = se = (double)(tn-t0)*n_by_lines_to_do;
01464 se -= ss;
01465 he = floor (se/3600.);
01466 me = floor ((se-he*3600.)/60.);
01467 se -= he*3600.+me*60.;
01468
01469
01470 if ((sse+ss) > 600){
01471 time_t t_eta = t+(time_t)(sse-ss);
01472 char *teos = ctime(&t_eta);
01473 teos[24]=0;
01474 gapp->SetStatus ("ScanTime",
01475 tt=g_strdup_printf ("%.0f:%02.0f:%02.0f "
01476 "| ETA:%.0f:%02.0f:%02.0f | %d%%\n"
01477 "End of Scan: %s %s",
01478 h,m,s, he,me,se,
01479 (int)(100/n_by_lines_to_do), teos,
01480 gapp->xsm->hardware->GetStatusInfo()?gapp->xsm->hardware->GetStatusInfo():" "));
01481 }else
01482 gapp->SetStatus ("ScanTime",
01483 tt=g_strdup_printf ("%.0f:%02.0f:%02.0f "
01484 "| ETA:%.0f:%02.0f:%02.0f | %d%% %s",
01485 h,m,s, he,me,se,
01486 (int)(100/n_by_lines_to_do),
01487 gapp->xsm->hardware->GetStatusInfo()?gapp->xsm->hardware->GetStatusInfo():" "));
01488
01489 if ((t-tnlog) > 60 || (sse+ss) < 600){
01490 tnlog=t;
01491 gchar *nl;
01492 if ((nl=strchr (tt, '\n'))) *nl=' ';
01493 gchar *mt = g_strdup_printf ("Scan Progress [%d]", line);
01494 gapp->monitorcontrol->LogEvent (mt, tt);
01495 g_free(mt);
01496 }
01497 g_free(tt);
01498
01499 t=tn+(time_t)sse;
01500 return ss;
01501 }
01502 return 0.;
01503 }
01504
01505 void SPM_ScanControl::autosave_check (double sec, int initvalue){
01506 static int nextAutosaveEvent=0;
01507
01508 if (initvalue > 0){
01509 nextAutosaveEvent = initvalue;
01510 return;
01511 }
01512
01513 if ( (( !strncasecmp(xsmres.AutosaveUnit, "percent",2))
01514 && ((100*line/master_scan->data.s.ny) >= nextAutosaveEvent))
01515 ||
01516 (( !strncasecmp(xsmres.AutosaveUnit, "lines" ,2))
01517 && (line >= nextAutosaveEvent))
01518 ||
01519 ((!strncasecmp(xsmres.AutosaveUnit, "seconds",2))
01520 && (sec >= nextAutosaveEvent)) ){
01521
01522 nextAutosaveEvent += xsmres.AutosaveValue;
01523 if(gapp->xsm->IsMode(MODE_AUTOSAVE)){
01524 PI_DEBUG (DBG_L3, "Autosaveevent triggered.");
01525
01526 if(!strncasecmp(xsmres.AutosaveOverwritemode, "true",2))
01527 gapp->xsm->save(2, NULL, -1, TRUE);
01528 else
01529 gapp->xsm->save(2, NULL, -1, FALSE);
01530 }
01531 }
01532 }