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 #include <iostream>
00029 #include <fstream>
00030
00031 #include <cstring>
00032
00033 #include <dirent.h>
00034 #include <fnmatch.h>
00035
00036 #include "surface.h"
00037 #include "xsmmasks.h"
00038 #include "glbvars.h"
00039 #include "action_id.h"
00040
00041 #include "dataio.h"
00042 #include "app_profile.h"
00043
00044 #include "epsfutils.h"
00045
00046
00047
00048
00049
00050 #define SET_CHANNEL_SCAN_MODE(X, M) X = ((X) > 0 ? M : -M)
00051
00052 Surface::Surface() : Xsm(){
00053 StopScanFlg= TRUE;
00054 ActiveScan = NULL;
00055
00056 ScanList = NULL;
00057 ProfileList = NULL;
00058 DelProfileList = NULL;
00059
00060 for(int i=0; i<MAX_CHANNELS; i++){
00061 scan[i] = NULL;
00062 ChannelView[i] = ID_CH_V_GREY;
00063 ChannelMode[i] = ID_CH_M_OFF;
00064 ChannelScanMode[i] = ID_CH_M_OFF;
00065 }
00066 SetRedraw();
00067 }
00068
00069 Surface::~Surface(){
00070 XSM_DEBUG (DBG_L2, "Surface Destructor");
00071 RemoveAllProfiles();
00072 for(int i=0; i<MAX_CHANNELS; i++)
00073 if(scan[i]){
00074 XSM_DEBUG (DBG_L2, "killing Scan " << i);
00075 delete scan[i];
00076 }
00077 }
00078
00079 void Surface::hide(){;}
00080
00081 int Surface::draw(){ return 0; }
00082
00083 void Surface::CleanupProfiles(){
00084 g_slist_foreach ((GSList*) DelProfileList,
00085 (GFunc) Surface::remove_profile, this);
00086 g_slist_free (DelProfileList);
00087 DelProfileList = NULL;
00088 }
00089
00090 int Surface::AddProfile(gchar *filename){
00091 CleanupProfiles ();
00092 ProfileList = g_slist_prepend (ProfileList,
00093 new ProfileControl (filename, "ProfileFromFile"));
00094 return 0;
00095 }
00096
00097 int Surface::AddProfile(ProfileControl *pc){
00098 CleanupProfiles ();
00099 ProfileList = g_slist_prepend (ProfileList, pc);
00100 return 0;
00101 }
00102
00103 int Surface::RemoveProfile(ProfileControl *pc){
00104 ProfileList = g_slist_remove((GSList*) ProfileList, pc);
00105 DelProfileList = g_slist_prepend(DelProfileList, pc);
00106
00107 return 0;
00108 }
00109
00110 void Surface::remove_profile(ProfileControl *pc, gpointer data){ delete pc; }
00111
00112 void Surface::RemoveAllProfiles(){
00113 g_slist_foreach((GSList*) ProfileList,
00114 (GFunc) Surface::remove_profile, this);
00115 g_slist_free(ProfileList);
00116 ProfileList = NULL;
00117 }
00118
00119
00120 int Surface::SetView(int Channel, int choice){
00121 XSM_DEBUG (DBG_L2, "SetView " << Channel << " " << choice );
00122 if(Channel < 0 || Channel >= MAX_CHANNELS) return 1;
00123 if(scan[Channel]){
00124 if(ChannelView[Channel] != choice){
00125 ChannelView[Channel] = scan[Channel]->SetView(choice);
00126 }
00127 gapp->channelselector->SetView(Channel, choice);
00128 }
00129 else
00130 ChannelView[Channel] = choice;
00131 return 0;
00132 }
00133
00134 void Surface::AutoDisplay(double hi, double lo){
00135 if (ActiveScan){
00136 ActiveScan->AutoDisplay(hi, lo, xsmres.HiLoDelta);
00137 SetVM ();
00138 gapp->spm_update_all ();
00139 }
00140 }
00141
00142 int Surface::SetVM(int mode){
00143
00144 if (mode)
00145 data.display.ViewFlg = mode;
00146
00147 if (ActiveScan && redrawflg)
00148 ActiveScan->SetVM (data.display.ViewFlg, &data, xsmres.HiLoDelta);
00149
00150 return 0;
00151 }
00152
00153 int Surface::SetSDir(int Channel, int choice){
00154 if(Channel < 0 || Channel >= MAX_CHANNELS) return -1;
00155 if(abs(ChannelScanMode[Channel]) == ID_CH_M_OFF) return -1;
00156 switch(choice){
00157 case ID_CH_D_P:
00158 ChannelScanMode[Channel] = abs(ChannelScanMode[Channel]);
00159 break;
00160 case ID_CH_D_M:
00161 ChannelScanMode[Channel] = -abs(ChannelScanMode[Channel]);
00162 break;
00163 case ID_CH_D_2ND_P:
00164 ChannelScanMode[Channel] = ID_CH_M_2ND_OFFSET + abs(ChannelScanMode[Channel]);
00165 break;
00166 case ID_CH_D_2ND_M:
00167 ChannelScanMode[Channel] = -ID_CH_M_2ND_OFFSET -abs(ChannelScanMode[Channel]);
00168 break;
00169 }
00170 XSM_DEBUG (DBG_L2, "Surface::SetSDir: " << Channel << " " << choice << " ChScM: " << ChannelScanMode[Channel]);
00171
00172 return 0;
00173 }
00174
00175 int Surface::SetMode(int Channel, int choice, int force){
00176 int lastmode;
00177 XSM_DEBUG (DBG_L2, "Surface::SetMode: " << Channel << " " << choice);
00178 if (Channel == -1) Channel = ActiveChannel;
00179 if (Channel < 0 || Channel >= MAX_CHANNELS) return -1;
00180 lastmode=ChannelMode[Channel];
00181
00182 switch (choice){
00183 case ID_CH_M_ACTIVE:
00184 XSM_DEBUG (DBG_L2, "Surface::SetMode: ACTIVE " << Channel);
00185 ActivateChannel (Channel);
00186 ChannelMode[Channel] = choice;
00187 return 0;
00188 case ID_CH_M_ON:
00189 if (scan[Channel]){
00190 if (ChannelMode[Channel] == ID_CH_M_ACTIVE)
00191 ActiveScan = NULL;
00192 ChannelMode[Channel] = choice;
00193 }
00194 else{
00195 gapp->channelselector->SetMode(Channel, ID_CH_M_OFF);
00196 return 0;
00197 }
00198 gapp->channelselector->SetMode (Channel, ChannelMode[Channel]);
00199 return 0;
00200 }
00201 XSM_DEBUG (DBG_L2, "Surface::SetMode: CH " << Channel << ":" << choice);
00202 ChannelMode[Channel] = choice;
00203 switch (choice){
00204 case ID_CH_M_OFF:
00205 if (scan[Channel])
00206 if (! (scan[Channel]->get_refcount ())){
00207 if (force || XSM_SHOW_QUESTION(Q_KILL_SCAN, 0)){
00208 if (ActiveScan == scan[Channel]){
00209 ActiveScan = NULL;
00210 }
00211 delete scan[Channel];
00212 scan[Channel] = NULL;
00213 SET_CHANNEL_SCAN_MODE(ChannelScanMode[Channel], choice);
00214 }else{
00215 ChannelMode[Channel] = ID_CH_M_ON;
00216 SET_CHANNEL_SCAN_MODE(ChannelScanMode[Channel], ID_CH_M_ON);
00217 }
00218 }
00219 break;
00220 case ID_CH_M_X:
00221 SET_CHANNEL_SCAN_MODE(ChannelScanMode[Channel], choice);
00222 break;
00223 case ID_CH_M_MATH:
00224 SET_CHANNEL_SCAN_MODE(ChannelScanMode[Channel], choice);
00225 break;
00226 default:
00227 if(choice > ID_CH_M_X){
00228 SET_CHANNEL_SCAN_MODE(ChannelScanMode[Channel], choice);
00229 }
00230 else
00231 XSM_DEBUG (DBG_L2, "Surface::SetMode: wrong Mode !");
00232 break;
00233 }
00234 gapp->channelselector->SetMode(Channel, ChannelMode[Channel]);
00235 return 0;
00236 }
00237
00238 Scan* Surface::NewScan(int vtype, int vflg, int ChNo, SCAN_DATA *vd){
00239
00240
00241 if (!strncasecmp (xsmres.InstrumentType, "SPALEED",7))
00242 return ( new SpaScan (vtype, vflg, ChNo, vd));
00243 else
00244 return ( new TopoGraphicScan (vtype, vflg, ChNo, vd));
00245 }
00246
00247 int Surface::ActivateFreeChannel(){
00248 int Ch=0;
00249
00250 if((Ch=FindChan(ID_CH_M_OFF)) < 0){
00251 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOFREECHAN,"View in new Channel",1);
00252 return 1;
00253 }
00254 if(ActivateChannel(Ch))
00255 return 1;
00256 return 0;
00257 }
00258
00259 int Surface::ActivateChannel(int NewActiveChannel){
00260 int Ch;
00261
00262 ActiveChannel=NewActiveChannel;
00263 if(ActiveScan)
00264 ActiveScan->draw(1,0);
00265 ActiveScan = NULL;
00266
00267
00268 if((Ch=FindChan(ID_CH_M_ACTIVE)) >= 0){
00269 gapp->channelselector->SetMode(Ch, ID_CH_M_ON);
00270 ChannelMode[Ch] = ID_CH_M_ON;
00271 if((Ch=FindChan(ID_CH_M_ACTIVE)) >= 0)
00272 XSM_DEBUG (DBG_L2, "zu viele Active Channels !!!!");
00273 }
00274
00275 if(scan[ActiveChannel]){
00276 ActiveScan = scan[ActiveChannel];
00277 scan[ActiveChannel]->Activate();
00278 gapp->channelselector->SetMode(ActiveChannel, ID_CH_M_ACTIVE);
00279 ChannelMode[ActiveChannel] = ID_CH_M_ACTIVE;
00280 ActiveScan->draw(1,0);
00281 return 0;
00282 }
00283
00284
00285 scan[ActiveChannel] = NewScan(ChannelView[ActiveChannel], data.display.ViewFlg, ActiveChannel, &data);
00286
00287
00288 if(!scan[ActiveChannel]){
00289 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOMEM,"",1);
00290 return 1;
00291 }
00292
00293
00294 ActiveScan = scan[ActiveChannel];
00295 gapp->channelselector->SetMode(ActiveChannel, ID_CH_M_ACTIVE);
00296 ChannelMode[ActiveChannel] = ID_CH_M_ACTIVE;
00297 ActiveScan->draw();
00298
00299 return 0;
00300 }
00301
00302
00303 int Surface::FindChan(int fid){
00304 int i;
00305 for(i=0; i<MAX_CHANNELS; i++){
00306 if(ChannelMode[i] == fid){
00307
00308 return i;
00309 }
00310 else
00311 if(fid != ID_CH_M_OFF && ChannelScanMode[i] == fid){
00312
00313 ChannelMode[i] = abs(fid);
00314 gapp->channelselector->SetMode(i, abs(fid));
00315 return i;
00316 }
00317 }
00318
00319
00320 return -1;
00321 }
00322
00323 int Surface::load(const char *rname){
00324 int Ch;
00325 std::ifstream f;
00326 static gchar *path = NULL;
00327 gchar *cname = NULL;
00328 gchar *fname = NULL;
00329 gchar *ffname;
00330
00331 XSM_DEBUG (DBG_L2, "load: " << rname);
00332
00333 if(! path)
00334 path = g_strdup(xsmres.DataPath);
00335
00336
00337 if(! rname){
00338 ffname = gapp->file_dialog("NC/asc file to load",path,
00339 "*.[na][cs]*", NULL, "normalload");
00340 if (! ffname){
00341 gapp->SetStatus("load aborted.");
00342 return 1;
00343 }
00344 fname = g_strdup(ffname);
00345 }else{
00346 if(!strrchr(rname, '/'))
00347 fname = g_strconcat("./",rname,NULL);
00348 else
00349 fname = g_strdup(rname);
00350 }
00351
00352
00353 if (strstr(fname, ".asc")){
00354 int ret = AddProfile (fname);
00355 g_free (fname);
00356 return ret;
00357 }
00358
00359
00360 if (!( strstr(fname, ".nc") || strstr(fname, ".NC"))){
00361
00362 int ret = gapp->xsm->gnuimport (fname) ;
00363 g_free (fname);
00364 return ret;
00365 }
00366
00367
00368 if(strlen(fname) <= 3){
00369 gapp->SetStatus(N_("invalid filename, load aborted."));
00370 g_free (fname);
00371 return 1;
00372 }
00373
00374
00375 g_free(path);
00376 path = g_strndup(fname, strrchr(fname, '/')-fname);
00377
00378
00379 if(!ActiveScan){
00380 if((Ch=FindChan(ID_CH_M_OFF)) < 0){
00381 gapp->SetStatus (ERR_SORRY, ERR_NOFREECHAN);
00382 XSM_SHOW_ALERT (ERR_SORRY, ERR_NOFREECHAN, fname, 1);
00383 g_free (fname);
00384 return 1;
00385 }
00386 if(ActivateChannel(Ch)){
00387 gapp->SetStatus(N_("Load: Error activating channel"));
00388 g_free (fname);
00389 return 1;
00390 }
00391 }
00392
00393
00394
00395
00396 if(!strncasecmp(fname+strlen(fname)-3,".gz",3) ||
00397 !strncasecmp(fname+strlen(fname)-4,".bz2",4)){
00398 FILE *cmd;
00399 int fd;
00400 gchar *cmdstr;
00401 gapp->SetStatus(N_("Load: unpacking..."), strrchr(fname,'/'));
00402 # define GXSMTMPDIRPREFIX "/tmp/GxsmUnzipdir"
00403 char *gxsmtmpdir = g_strdup(GXSMTMPDIRPREFIX"_XXXXXX");
00404
00405 if (!(fd=mkstemp(gxsmtmpdir))){
00406 g_warning (N_("Could not generate temporary filename: %s\n"),
00407 g_strerror(errno));
00408 XSM_DEBUG(DBG_L2, "ErrorTmpFn: " << g_strerror(errno) );
00409 }
00410 if(fd) close(fd);
00411 cmd = popen("rm -rf " GXSMTMPDIRPREFIX "*", "w");
00412 if(cmd)
00413 pclose(cmd);
00414
00415
00416 if ((mkdir(gxsmtmpdir, 0755) != 0)){
00417 g_warning (N_("Could not generate temporary directory: %s\n"),
00418 g_strerror(errno));
00419 XSM_DEBUG(DBG_L2, "Error: " << g_strerror(errno) );
00420 }
00421
00422 XSM_DEBUG(DBG_L2, "MkTmpdir: " << gxsmtmpdir );
00423 XSM_DEBUG(DBG_L2, "FileName:" << fname );
00424
00425 cmdstr = g_strconcat("cp ", fname, " ", gxsmtmpdir,
00426 strrchr(fname, '/'), NULL);
00427 cmd = popen(cmdstr, "w");
00428 if(cmd)
00429 pclose(cmd);
00430 else{
00431 gapp->SetStatus(N_("error executing"), cmdstr);
00432 XSM_SHOW_ALERT(ERR_SORRY, ERR_CPTMP, fname,1);
00433 g_free(fname);
00434 g_free(gxsmtmpdir);
00435 g_free(cmdstr);
00436 return 0;
00437 }
00438 g_free(cmdstr);
00439
00440 cname = g_strconcat(gxsmtmpdir, strrchr(fname,'/'), NULL);
00441 if (!strncasecmp(fname+strlen(fname)-3,".gz",3))
00442 cmdstr = g_strconcat("gunzip ", cname, NULL);
00443 else
00444 cmdstr = g_strconcat("bunzip2 ", cname, NULL);
00445 g_free(fname);
00446 fname = g_strndup(cname, strrchr(cname,'.')-cname);
00447
00448 cmd = popen(cmdstr, "w");
00449 gapp->SetStatus("sh", cmdstr);
00450 g_free(cmdstr);
00451
00452 g_free(gxsmtmpdir);
00453 if(cmd)
00454 pclose(cmd);
00455 else{
00456 gapp->SetStatus(N_("error while unzipping"));
00457 XSM_SHOW_ALERT(ERR_SORRY, ERR_UNZIP, fname,1);
00458 g_free(fname);
00459 return 0;
00460 }
00461 }
00462
00463 ActiveScan->CpyDataSet(data);
00464
00465 Dataio *Dio = NULL;
00466
00467 if (!strncasecmp(fname+strlen(fname)-3,".nc",3))
00468 Dio = new NetCDF(ActiveScan, fname);
00469
00470 if (Dio){
00471 Dio->Read();
00472 if(Dio->ioStatus())
00473 XSM_SHOW_ALERT(ERR_SORRY, Dio->ioStatus(), fname,1);
00474
00475 delete Dio;
00476 }
00477
00478
00479 g_free(fname);
00480
00481 ActiveScan->GetDataSet(data);
00482
00483
00484 gapp->spm_update_all();
00485 ActiveScan->draw();
00486
00487 if (xsmres.LoadDelay>0){
00488 clock_t t=clock()+xsmres.LoadDelay*CLOCKS_PER_SEC/10;
00489 gapp->xsm->AutoDisplay();
00490 do {
00491 gapp->check_events();
00492 } while(t < clock());
00493 }
00494 return 0;
00495 }
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511 int Surface::save(int autoon, char *rname, int chidx, int forceOverwrite){
00512 int si,i,ii;
00513 std::ofstream f;
00514 gchar *fname = NULL;
00515 gchar *defaultname = NULL;
00516 gchar *basename = NULL;
00517 gchar *ffname;
00518 static gchar *digits = NULL;
00519 static gchar *path = NULL;
00520 gchar *stype = NULL;
00521 #define CHMAX (1+2*PIDCHMAX+2*DAQCHMAX)
00522 int Ch[CHMAX];
00523
00524 if(!path)
00525 path = g_strdup(xsmres.DataPath);
00526
00527 if(chidx >= 0){
00528 for(si=0; si<CHMAX; si++) Ch[si] = -1;
00529 Ch[0] = chidx;
00530 }
00531 else{
00532 si=0;
00533
00534
00535 Ch[si++] = FindChan(ID_CH_M_ACTIVE);
00536
00537
00538 for(i=0; i<PIDCHMAX; ++i){
00539 Ch[si++] = FindChan(xsmres.pidchno[i]);
00540 Ch[si++] = FindChan(-xsmres.pidchno[i]);
00541 }
00542
00543 for(i=0; i<DAQCHMAX; ++i){
00544 Ch[si++] = FindChan(xsmres.daqchno[i]);
00545 Ch[si++] = FindChan(-xsmres.daqchno[i]);
00546 }
00547
00548 for(ii=si=0; si<CHMAX; si++)
00549 if(Ch[0] == Ch[si]){ Ch[0] = -1; break; }
00550
00551 for(ii=si=0; si<CHMAX; si++)
00552 if(Ch[si] != -1){ ii++; break; }
00553
00554 if(!ii){
00555 gapp->SetStatus(ERR_SORRY, ERR_NOACTIVESCAN);
00556 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOACTIVESCAN,HINT_ACTIVATESCAN,1);
00557 return 1;
00558 }
00559 }
00560
00561 if (digits)
00562 g_free (digits);
00563 digits = NULL;
00564
00565
00566 if( IS_FILENAME_CONVENTION_ALPHA ) {
00567 int cbase = (int)'z'-(int)'a'+1;
00568 int tmp = counter/cbase/cbase;
00569 digits = g_strdup_printf ("%c%c%c",
00570 (char)('a'+ tmp % cbase),
00571 (char)('a'+ ((counter - tmp*cbase*cbase) / cbase) % cbase),
00572 (char)('a'+ counter % cbase ));
00573 } else if( IS_FILENAME_CONVENTION_DIGIT ){
00574 digits = g_strdup_printf ("%03d",counter+1);
00575 } else {
00576 for(si=0; si<CHMAX; si++) if(Ch[si] == -1) continue; else break;
00577 struct tm *ts = localtime (&scan[Ch[si]]->data.s.tStart);
00578 digits = g_strdup_printf ("%04d%02d%02d%02d%02d%02d",
00579 1900+ts->tm_year, ts->tm_mon, ts->tm_mday,
00580 ts->tm_hour, ts->tm_min, ts->tm_sec);
00581 }
00582
00583
00584 if( autoon == 2 ){
00585 gchar *suffix = NULL;
00586 if( IS_FILENAME_CONVENTION_ALPHA) {
00587 int cbase = (int)'z'-(int)'a'+1;
00588 int tmp = subcounter/cbase/cbase;
00589 suffix = g_strdup_printf ("_%c%c%c",
00590 (char)('a'+ tmp % cbase),
00591 (char)('a'+ ((subcounter - tmp*cbase*cbase) / cbase) % cbase),
00592 (char)('a'+ subcounter % cbase ));
00593 } else suffix = g_strdup_printf ("_%03d", subcounter+1);
00594 gchar *tmp=digits;
00595 digits = g_strconcat (tmp, suffix, NULL);
00596 g_free (tmp); g_free (suffix);
00597 }
00598
00599 for(si=0; si<CHMAX; si++){
00600 if(Ch[si] == -1) continue;
00601
00602
00603
00604
00605 if(rname)
00606 basename = g_strdup(rname);
00607 else
00608 basename = g_strconcat(data.ui.basename, digits, NULL);
00609
00610
00611
00612 if(si > 0){
00613 if (! strncmp (scan[Ch[si]]->data.ui.type, "not set", 7)){
00614 if (! strncmp (scan[Ch[si]]->data.ui.title, "title not set", 13))
00615 stype = g_strdup_printf ("ch%02d ", Ch[si]);
00616 else
00617 stype = g_strdup (scan[Ch[si]]->data.ui.title);
00618 } else
00619 stype = g_strdup (scan[Ch[si]]->data.ui.type);
00620
00621 g_strdelimit (stype, "+",'p');
00622 g_strdelimit (stype, "-",'m');
00623 g_strdelimit (stype, " ",'-');
00624
00625 gchar *p = strchr (stype, ',');
00626 if(p)
00627 *p=0;
00628 defaultname = g_strdup_printf ("%s-%s",basename,stype);
00629 if(p)
00630 *p = ',';
00631
00632 g_free(stype);
00633 }
00634 else
00635 defaultname = g_strdup(basename);
00636
00637 g_free(basename);
00638
00639 int overwrite;
00640 do{
00641
00642
00643 if(autoon){
00644 fname = g_strconcat(path, "/", defaultname, NULL);
00645
00646
00647 if( autoon == 2 )
00648 fname = g_strconcat(path, "/", defaultname, ".autosave", NULL);
00649
00650 }else{
00651 ffname = gapp->file_dialog(N_("NC file to save"), path,
00652 "*.nc", defaultname, "normalsave");
00653 if(! ffname){
00654 gapp->SetStatus(N_("Save aborted by user."));
00655 return 1;
00656 }
00657 fname = g_strdup(ffname);
00658 g_free(path);
00659 path = g_strndup(fname, strrchr(fname, '/')-fname);
00660 }
00661 XSM_DEBUG (DBG_L2, "Save: Name is:<" << fname << ">");
00662 XSM_DEBUG (DBG_L2, "Save: Path is:<" << path << ">");
00663
00664 if (strncasecmp(fname+strlen(fname)-3,".nc",3)){
00665 gchar *fnamebase = g_strdup(fname);
00666 g_free(fname);
00667 fname = g_strconcat(fnamebase, ".nc", NULL);
00668
00669 g_free(fnamebase);
00670 }
00671
00672 g_free(defaultname);
00673
00674 overwrite = GTK_RESPONSE_YES;
00675
00676 f.open(fname, std::ios::in);
00677 if(f.good()){
00678 f.close();
00679
00680 if(forceOverwrite == FALSE){
00681 GtkWidget *dialog = gtk_message_dialog_new (NULL,
00682 GTK_DIALOG_DESTROY_WITH_PARENT,
00683 GTK_MESSAGE_WARNING,
00684 GTK_BUTTONS_YES_NO,
00685 N_("File '%s' exists, overwrite?"),
00686 fname);
00687 overwrite = gtk_dialog_run (GTK_DIALOG (dialog));
00688 gtk_widget_destroy (dialog);
00689 if (overwrite != GTK_RESPONSE_YES){
00690 gapp->SetStatus(N_("File exists, save aborted by user."));
00691 return 1;
00692 }
00693 }else{
00694 XSM_DEBUG (DBG_L2, "forceOverwrite enabled: overwriting file!");
00695 gapp->SetStatus(N_("File overwrite forced by default."));
00696 }
00697 }
00698 }while (overwrite != GTK_RESPONSE_YES);
00699
00700 gapp->monitorcontrol->LogEvent("*Save", fname);
00701
00702
00703 {
00704 Dataio *Dio = NULL;
00705 scan[Ch[si]]->CpyUserEntries(data);
00706
00707
00708 if(!strncasecmp(fname+strlen(fname)-3,".nc",3))
00709 Dio = new NetCDF(scan[Ch[si]], fname);
00710
00711 if (Dio){
00712 Dio->Write();
00713 if(Dio->ioStatus()){
00714 gapp->SetStatus(N_("Error"), Dio->ioStatus());
00715 XSM_SHOW_ALERT(ERR_SORRY, Dio->ioStatus(), fname,1);
00716 }
00717 else{
00718 scan[Ch[si]]->Saved();
00719 gapp->SetStatus(N_("Saving done "), fname);
00720 }
00721
00722 delete Dio;
00723 }
00724 else
00725 gapp->SetStatus(N_("Error, not saved "), fname);
00726 }
00727
00728 g_free(fname);
00729 }
00730
00731 if( autoon != 2){
00732 ++counter;
00733 subcounter = 0;
00734 }
00735 else{
00736 ++subcounter;
00737 }
00738
00739 gapp->spm_update_all();
00740
00741 return 0;
00742 }
00743
00744 int Surface::gnuimport(const char *rname){
00745
00746 if(! GetActiveScan())
00747 return 1;
00748
00749 XSM_DEBUG(DBG_L2, "Checking file with Import Plugins!" );
00750 gchar *ret;
00751 gchar *nametocheck = g_strdup(rname);
00752 ret = nametocheck;
00753 gapp->SignalLoadFileEventToPlugins(&ret);
00754 XSM_DEBUG(DBG_L2, "Result: " << (ret==NULL? "MATCHING IMPORT PLUGIN FOUND":"unknown file type") );
00755 g_free (nametocheck);
00756
00757 return ret==NULL?0:1;
00758 }
00759
00760 int Surface::gnuexport(const char *rname){
00761
00762 if(!ActiveScan){
00763 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOACTIVESCAN,HINT_ACTIVATESCAN,1);
00764 return 1;
00765 }
00766 if(!ActiveScan->mem2d){
00767 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOACTIVESCAN,HINT_ACTIVATESCAN,1);
00768 return 1;
00769 }
00770
00771 XSM_DEBUG(DBG_L2, "Checking file with Export Plugins!" );
00772 gchar *ret;
00773 gchar *nametocheck = g_strdup(rname);
00774 ret = nametocheck;
00775 gapp->SignalSaveFileEventToPlugins(&ret);
00776 XSM_DEBUG(DBG_L2, "Result: " << (ret==NULL? "MATCHING EXPORT PLUGIN FOUND":"unknown file type") );
00777 g_free (nametocheck);
00778
00779 return 0;
00780 }
00781
00782 Scan* Surface::GetActiveScan(){
00783 int Ch;
00784 if (!ActiveScan){
00785 if ((Ch=FindChan (ID_CH_M_OFF)) < 0){
00786 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOFREECHAN,"",1);
00787 return NULL;
00788 }
00789 if (ActivateChannel (Ch)){
00790 return NULL;
00791 }
00792 }
00793 return ActiveScan;
00794 }
00795
00796
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
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
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
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
00921
00922
00923
00924
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035
01036
01037
01038 void Surface::MathOperationNoDest(gboolean (*MOp)(MATHOPPARAMSNODEST)){
01039
01040
01041 int Merr;
01042 if(ActiveScan){
01043
01044 if( (Merr=(*MOp)(ActiveScan)) )
01045 XSM_SHOW_ALERT(ERR_MATH, MathErrString[Merr], "", 1);
01046 }
01047 else{
01048 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOACTIVESCAN,HINT_ACTIVATESCANMATH,1);
01049 }
01050 }
01051
01052 void Surface::MathOperation(gboolean (*MOp)(MATHOPPARAMS)){
01053
01054
01055
01056 int Merr;
01057 int ChDest;
01058 if(ActiveScan){
01059 if((ChDest=FindChan(ID_CH_M_MATH)) < 0){
01060 if((ChDest=FindChan(ID_CH_M_OFF)) < 0){
01061
01062 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOFREECHAN,"",1);
01063 return;
01064 }
01065 }
01066
01067 gapp->channelselector->SetMode(ChDest, ID_CH_M_MATH);
01068 ChannelMode[ChDest] = ID_CH_M_MATH;
01069 if(! scan[ChDest]){
01070
01071 scan[ChDest] = new Scan(ChannelView[ChDest], data.display.ViewFlg, ChDest, &data, ActiveScan->mem2d->GetTyp());
01072
01073 if(!scan[ChDest]){
01074 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOMEM,"",1);
01075 return;
01076 }
01077 }
01078
01079 scan[ChDest]->create();
01080 G_FREE_STRDUP_PRINTF(scan[ChDest]->data.ui.name, ActiveScan->data.ui.name);
01081
01082 if( (Merr=(*MOp)(ActiveScan, scan[ChDest])) ){
01083 XSM_SHOW_ALERT(ERR_MATH, MathErrString[Merr], "", 1);
01084 SetMode (ChDest, ID_CH_M_OFF, TRUE);
01085 }
01086 else
01087 scan[ChDest]->draw();
01088 }
01089 else{
01090 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOACTIVESCAN,HINT_ACTIVATESCANMATH,1);
01091 }
01092 }
01093
01094 void Surface::MathOperationX(gboolean (*MOp)(MATH2OPPARAMS), int IdSrc2, gboolean size_matching){
01095
01096
01097
01098
01099 int Merr;
01100 int ChDest;
01101 int ChSrc2;
01102 if(ActiveScan){
01103 if((ChSrc2=FindChan(IdSrc2))>=0){
01104 if(!scan[ChSrc2]){
01105 XSM_DEBUG (DBG_L2, "Scr2==0");
01106 XSM_SHOW_ALERT(ERR_SORRY, ERR_NO2SRC,HINT_MAKESRC2,1);
01107 return;
01108 }
01109 if (size_matching)
01110
01111 if(scan[ChSrc2]->mem2d->GetNx() != ActiveScan->mem2d->GetNx()
01112 || scan[ChSrc2]->mem2d->GetNy() != ActiveScan->mem2d->GetNy()
01113 ){
01114 XSM_SHOW_ALERT(ERR_SORRY, ERR_SIZEDIFF,HINT_SIZEEQ,1);
01115 return;
01116 }
01117 if((ChDest=FindChan(ID_CH_M_MATH)) < 0){
01118 if((ChDest=FindChan(ID_CH_M_OFF)) < 0){
01119
01120 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOFREECHAN,"",1);
01121 return;
01122 }
01123 }
01124
01125 gapp->channelselector->SetMode(ChDest, ID_CH_M_MATH);
01126 ChannelMode[ChDest] = ID_CH_M_MATH;
01127 if(! scan[ChDest]){
01128
01129 scan[ChDest] = new Scan(ChannelView[ChDest], data.display.ViewFlg, ChDest, &data, ActiveScan->mem2d->GetTyp());
01130
01131 if(!scan[ChDest]){
01132 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOMEM,"",1);
01133 return;
01134 }
01135 }
01136
01137 scan[ChDest]->create();
01138
01139 if( (Merr=(*MOp)(ActiveScan, scan[ChSrc2], scan[ChDest])) ){
01140 XSM_SHOW_ALERT(ERR_MATH, MathErrString[Merr], "", 1);
01141 SetMode (ChDest, ID_CH_M_OFF, TRUE);
01142 }
01143 else
01144 scan[ChDest]->draw();
01145 }
01146 else{
01147 XSM_SHOW_ALERT(ERR_SORRY, ERR_NO2SRC,HINT_MAKESRC2,1);
01148 }
01149 }
01150 else{
01151 XSM_SHOW_ALERT(ERR_SORRY, ERR_NOACTIVESCAN,HINT_ACTIVATESCANMATH,1);
01152 }
01153 }
01154
01155