/*
   Diagram management
*/

#include "common.h"
#include "help.h"
#include "file.h"
#include "datalib.h"
#include "archive.h"
#include "function.h"
#include "visual.h"
#include "diagram.h"
#include "curve.h"
#include "point.h"
#include "param.h"

extern Global(CharPtr PNTR) DiagramTxt;	/* defined in text.c */

enum {		/* see setup.c, init[], /diagram */
  SELDIAG_C,
  REDRAW_C,
  EXPORT_C,	/* Waiting for Export parameters */
  IMPORT_C,	/* Waiting for Import parameters */
  EXPORTING_C,
  IMPORTING_C,
  SEL_T,
  EXPORT_T,	/* Export to file */
  IMPORT_T,	/* Import from file */
  EXPORTOF_B,	/* File list */
  IMPORTOF_B,	/* File list */
  EXPORTC_T,	/* Export curves */
  EXPORTCI_B,	/* initial points only */
  EXPORTCF_B	/* everything */
} DiagramTxtIndex;

/* Export/Import */
/*
   1 - don't export,
   2 - initial points only,
   3 - everything.
*/
Local(Int2) outlevel;
Local(FILE PNTR) file;

Local(Int2) ExportDiagram(DataLibPtr arch);

/*------------------------*/
/* Select Current Diagram */


/*
   FilePtr to Selected Functions Partition;
   it is the parent of all the Diagram Child Dir Entries.
*/
Local(FilePtr) SavedSelectedDirPtr;

/* Create routine (DataLibShow) */
Global(Int2) dCreate(DataLibPtr dlArch, DataLibNotify post) {
  size_t fl;
  DataLibVar(dlDiag);
  Int2 rc=0;
  if (AssignFileName()) {
    GetParamAppend(SFS_EXTENSIONS,"DIAG");
    fl=StrLen(ParBuf)+1;
    if (!DataLibWriteVRecord(dlArch,NULL,ParBuf,fl)) {
      if (DataLibOpen(&dlDiag,ParBuf)) {
	FreeFileName(ParBuf);
	rc=3;
      } else
	DataLibClose(&dlDiag);
    } else rc=2;
  } else rc=1;
  if (!rc && post) post(dlArch,0);
  return rc;
}

/* Delete routine (DataLibShow) */
Local(Int2) dDelete(DataLibPtr dlArch, DataLibNotify post) {
  CharPtr pfn;
  /* Is the active diagram deleting? */
  if (dlArch->SelectedDirPtr==dlArch->CurDirPtr) {
    DataLibSetUserPtr(dlArch,SavedSelectedDirPtr,0);
    dlArch->SelectedDirPtr=0;
    DataLibSetSelected(dlArch);
    DeactivateDiagram(FALSE);
  }
  /* Delete diagram file and free file number */
  pfn=DataLibReadVRecord(dlArch,NULL);
  if (pfn && *pfn) {
    ParamEraseLibs(pfn,FALSE);	/* first free diagram-related file(s) */
    unlink(pfn);
    FreeFileName(pfn);		/* Free unique filename */
  }
  _MemFree(pfn);
  /* Notify DataLibShow that custom deletion has been made */
  /* DataLibShow will delete partition by itself */
  if (post) post(dlArch,0);
  /* Force graphics windows to forget about special points */
  ClearAllWindows(0);
  return 0;
}

/*==============================*/
/* Import routine (DataLibShow) */

typedef struct {
  DataLibNotify Post;		/* pointer to DataLibShow's Post routine */
  DataLibPtr DataLib;		/* DataLib  */
  TexT file;
  GrouP btns;
} ImportWork, PNTR ImportWorkPtr;


Local(void) dImportTerm(ButtoN b, Int2 res) {
  WindoW w;
  ImportWorkPtr wp;
  w=ParentWindow(b);
  wp=GetWindowExtra(w);
  if (wp->Post) wp->Post(wp->DataLib,res);
  PopContext();
  _MemFree(wp);
  Remove(w);
}

Local(void) dImportOk(ButtoN b) {
  WindoW w;
  ImportWorkPtr wp;
  w=ParentWindow(b);
  wp=GetWindowExtra(w);
  Disable(wp->btns);
  GetTitle(wp->file,ParBuf,PAR_BUF);
  StrTrim(ParBuf);
  file=fopen(ParBuf,"rt");
  if (!file) {
    myWarning("_Open",ParBuf);
    Enable(wp->btns);
    return;
  }
  if (ImportFuncCode(file,TRUE)) {	/* Check file header */
    Enable(wp->btns);
    return;
  }
  if (fscanf(file,"Diagram: %[^\n]\n",ParBuf)!=1) {
    myWarning("IF_NOT",20);
    Enable(wp->btns);
    return;
  }
  DiagramsImport(wp->DataLib,file,TRUE);
  fclose(file);
  /* That's all */
  dImportTerm(b,0);
}

Local(void) dImportCancel(ButtoN b) {
  dImportTerm(b,1);
}

#if _WIN
#pragma argsused
#endif
Local(void) dImportHelp(ButtoN b) {
  Help(NULL);
}

Local(void) dImportInFile(ButtoN b) {
  WindoW w;
  Char ext[20];
  ImportWorkPtr wp;
  w=ParentWindow(b);
  wp=GetWindowExtra(w);
  StrCpy(ext,GetParam(SFS_EXTENSIONS,"ED"));
  *ParBuf='\0';
  if (myGetInputFileName(ParBuf,PAR_BUF,ext)) {
    SetTitle(wp->file,ParBuf);
  }
  Select(w);
}

Local(Int2) dImport(DataLibPtr dlArch, DataLibNotify post) {
  WindoW wE;
  GrouP g;
  ImportWorkPtr wp;
  wp=_MemNew(sizeof(*wp));
  wp->Post=post;
  wp->DataLib=dlArch;
  PushContext(HLP_IMPORTDGM,NULL,DiagramTxt[IMPORT_C]);
  wE=FixedWindow(-50,-50,-sysCharWidth,-sysLineHeight,"",NULL);
  SetWindowExtra(wE,wp,NULL);
  g=NormalGroup(wE,3,0,DiagramTxt[IMPORT_T],NULL,NULL);
  SetGroupMargins(g,sysCharWidth,sysLineHeight2);
  SetGroupSpacing(g,sysCharWidth,sysLineHeight2);
  wp->file=DialogText(g,"",25,NULL);
  PushButton(g,DiagramTxt[IMPORTOF_B],dImportInFile);
  wp->btns=TermButtons(wE,g,dImportOk,dImportCancel,dImportHelp);
  Show(wE);
  SelectText(wp->file,0,0);
  return 0;
}

/*===============================*/
/* Export routines (DataLibShow) */


typedef struct {
  DataLibNotify Post;		/* pointer to DataLibShow's Post routine */
  DataLibPtr DataLib;		/* DataLib  */
  TexT file;
  GrouP curves;
  GrouP btns;			/* to avoid nested calls to callbacks */
} ExportWork, PNTR ExportWorkPtr;

Local(void) dExportTerm(ButtoN b, Int2 res) {
  WindoW w;
  ExportWorkPtr wp;
  w=ParentWindow(b);
  wp=GetWindowExtra(w);
  if (wp->Post) wp->Post(wp->DataLib,res);
  PopContext();
  _MemFree(wp);
  Remove(w);
}

Local(void) dExportOk(ButtoN b) {
  WindoW w;
  ExportWorkPtr wp;
  w=ParentWindow(b);
  wp=GetWindowExtra(w);
  Disable(wp->btns);
  GetTitle(wp->file,ParBuf,PAR_BUF);
  StrTrim(ParBuf);
  file=fopen(ParBuf,"wt");
  if (!file) {
    myWarning("_Open",ParBuf);
    Enable(wp->btns);
    return;
  }
  outlevel=1+GetValue(wp->curves);	/* there is no "don't" */
  ExportFuncCode(file,TRUE);	/* Create export file header */
  fprintf(file,"Diagram: %s\n",wp->DataLib->DirName+1);
  fprintf(file," outlevel=%i\n",(int)outlevel);
  ExportDiagram(wp->DataLib);
  fclose(file);
  /* That's all */
  dExportTerm(b,0);
}

Local(void) dExportCancel(ButtoN b) {
  dExportTerm(b,1);
}

#if _WIN
#pragma argsused
#endif
Local(void) dExportHelp(ButtoN b) {
  Help(NULL);
}

Local(void) dExportOutFile(ButtoN b) {
  WindoW w;
  Char def[PAR_BUF];
  ExportWorkPtr wp;
  w=ParentWindow(b);
  wp=GetWindowExtra(w);
  GetTitle(wp->file,def,PAR_BUF);
  *ParBuf='\0';
  if (myGetOutputFileName(ParBuf,PAR_BUF,def)) {
    SetTitle(wp->file,ParBuf);
  }
  Select(w);
}

Local(Int2) dExport(DataLibPtr dlArch, DataLibNotify post) {
  WindoW wE;
  GrouP g,gf,gd;
  ExportWorkPtr wp;
  CharPtr p;
  wp=_MemNew(sizeof(*wp));
  wp->Post=post;
  wp->DataLib=dlArch;
  PushContext(HLP_EXPORTDGM,NULL,DiagramTxt[EXPORT_C]);
  wE=FixedWindow(-50,-50,-sysCharWidth,-sysLineHeight,dlArch->DirName,NULL);
  SetWindowExtra(wE,wp,NULL);
  g=HiddenGroup(wE,0,5,NULL);
  SetGroupMargins(g,0,0);
  SetGroupSpacing(g,sysCharWidth,sysLineHeight2);
  gf=NormalGroup(g,2,0,DiagramTxt[EXPORT_T],NULL,NULL);
  SetGroupMargins(gf,sysCharWidth,sysLineHeight2);
  SetGroupSpacing(gf,sysCharWidth,sysLineHeight2);
  StrCpy(ParBuf,dlArch->DirName+1);
  p=StrChr(ParBuf,' ');
  if (p) *p='\0';
  GetParamAppend(SFS_EXTENSIONS,"ED");
  wp->file=DialogText(gf,ParBuf,25,NULL);
  PushButton(gf,DiagramTxt[EXPORTOF_B],dExportOutFile);
  wp->curves=gd=NormalGroup(g,3,0,DiagramTxt[EXPORTC_T],NULL,NULL);
  SetGroupMargins(gd,sysCharWidth,sysLineHeight2);
  SetGroupSpacing(gd,sysCharWidth,sysLineHeight2);
  RadioButton(gd,DiagramTxt[EXPORTCI_B]);
  RadioButton(gd,DiagramTxt[EXPORTCF_B]);
  SetValue(gd,2);
  wp->btns=TermButtons(wE,g,dExportOk,dExportCancel,dExportHelp);
  Show(wE);
  SelectText(wp->file,0,0);
  return 0;
}

/* Two local subroutines for dNotify and SelectDiagram */

Local(Int2) saveMinDepth;

Local(FilePtr) SaveLib(DataLibPtr dlArch) {
  SavedSelectedDirPtr=dlArch->SelectedDirPtr; /* diagram selection will change it */
  dlArch->SelectedDirPtr=DataLibGetUserPtr(dlArch,SavedSelectedDirPtr);
  DataLibDown(dlArch);	/* goto diagram list level */
  saveMinDepth=dlArch->MinDepth;
  dlArch->MinDepth=dlArch->Depth;
  if (dlArch->SelectedDirPtr) {
    dlArch->CurDirPtr=dlArch->SelectedDirPtr;
    DataLibSeekDir(dlArch,dlArch->CurDirPtr);
  }
  return dlArch->SelectedDirPtr;
}

Local(void) RestoreLib(DataLibPtr dlArch) {
  DataLibUp(dlArch);		/* return to the level of current system */
  dlArch->MinDepth=saveMinDepth;
  dlArch->SelectedDirPtr=SavedSelectedDirPtr;
  DataLibSeekDir(dlArch,dlArch->SelectedDirPtr);	/* restore function selection */
}

/* Notification routine called by DataLibShow when the user selects or cancels */
Local(void) dNotify(DataLibPtr dlArch, Int2 res) {
  switch (res) {
    case NOTIFY_CANCEL:
/***      if (dlArch->SelectedDirPtr==0) DeactivateDiagram();***/
      UpdateInfoInMainWindow(MWI_DIAGRAM,dlArch->DirName+1);	/* might be renamed */
      RestoreLib(dlArch);
      PopContext();		/* waiting selection */
      goto term;
    case NOTIFY_DESELECT:
      DeactivateDiagram(FALSE);
      PopContext();		/* waiting selection */
      break;
    case NOTIFY_SELECT:
      DataLibSetUserPtr(dlArch,SavedSelectedDirPtr,dlArch->SelectedDirPtr);
      RestoreLib(dlArch);
      ActivateDiagram(dlArch);
     term:
      DataLibClose(dlArch);
      UnlockAll();
    }
}


Local(DataLib) ArchLib;

/* Called from the Main Menu */
#if _WIN
#pragma argsused
#endif
Global(void) SelectDiagram(Int2 index) {
  LockAll();	/* lock second time because otherwise it would be unlocked
		   immediatedly after return */
  if (DataLibOpen(&ArchLib,ArchivesName)) return;
  SaveLib(&ArchLib);
  PushContext(HLP_DIAGRAM,NULL,DiagramTxt[SELDIAG_C]);
  if (DataLibShow(&ArchLib,DiagramTxt[SEL_T],dNotify,"n-r-d-ie-g",
		  dCreate,NULL,dDelete,dImport,dExport)) {	/* failed */
    dNotify(&ArchLib,NOTIFY_CANCEL);
  }
}

/* Determines status of menu item */
#if _WIN
#pragma argsused
#endif
Global(Boolean) SelectDiagram_Status(Int2 index) {
  return FunctionsHandle!=NULL;		/* functions are selected */
}


/*------------------------*/
/* Redraw current diagram */

/* ..._Status is the same as for Curve Selection - see mainwin.c */

#if _WIN
#pragma argsused
#endif
Local(Int2) redrawCurve(DataLibPtr diagramLib) {
  return RedrawCurve();
}

#if _WIN
#pragma argsused
#endif
Global(void) RedrawDiagram(Int2 index) {
  ccd.Computing=TRUE;
  ClearAllWindows(0);
  DataLibSavePos(&DiagramLib);
  while(!DataLibUp(&DiagramLib));
  PushContext(0,RedrawKey,DiagramTxt[REDRAW_C]);
  DataLibEnumIgnore(COMMENT_STR);
  DataLibEnumEx++;
  DataLibEnum(&DiagramLib,redrawCurve,TRUE);
  DataLibEnumEx--;
  DataLibEnumIgnore(NULL);
  PopContext();
  DataLibRestorePos(&DiagramLib);
  ccd.Computing=FALSE;
}


/*-----------------------------*/
/* Activate/Deactivate Diagram */

Global(DataLibVar(DiagramLib));
Global(Boolean) CurDiagram=FALSE;
Global(Int2) MaxUntitled;	/* max number of untitled curves per diagram */
Global(CharPtr) Untitled=NULL;	/* title of untitled curves */

/* Activate diagram */
Global(void) ActivateDiagram(DataLibPtr dlArch) {
  CharPtr pDiagramFile;
  CharPtr p;
/***  CurDiagram=FALSE;***/
  /* UserPtr of the function's DirEntry points to current diagram */
  if (SaveLib(dlArch)) {
    pDiagramFile=DataLibReadVRecord(dlArch,NULL);
    if (!DataLibOpen(&DiagramLib,pDiagramFile)) {
      CurDiagram=TRUE;
      ParBuf[0]=NAMEDIR_CHAR;
      ParBuf[1]='\0';
      Untitled=_StringSave(GetParamAppend(SFS_CURVES,"UNTITLED"));
      DataLibSavePos(&DiagramLib);
      while(!DataLibUp(&DiagramLib));
      p=DataLibReadVRecord(&DiagramLib,MAXUNT_PAR);
      if (DataLibLastVRecLen==0)
	StrToInt(GetParam(SFS_CURVES,"UNTITLEDMAX"),&MaxUntitled);
      else
	MaxUntitled=*(Int2Ptr)p;
      _MemFree(p);
      DataLibRestorePos(&DiagramLib);
      ParamLoadLibs();
      UpdateInfoInMainWindow(MWI_DIAGRAM,dlArch->DirName+1);
    }
    _MemFree(pDiagramFile);
  }
  ReadMarkerMap();	/* from DiagramLib if opened */
  ActivateCurve();
  RestoreLib(dlArch);
}

/* Deactivtae diagram */
Global(void) DeactivateDiagram(Boolean full) {
  DeactivateCurve(full);
  if (CurDiagram) {
    Untitled=_MemFree(Untitled);
    ParamUnloadLibs(TRUE);	/* decrease usage counts of func params */
    DataLibSavePos(&DiagramLib);
    while(!DataLibUp(&DiagramLib));
    DataLibWriteVRecord(&DiagramLib,MAXUNT_PAR,(CharPtr)&MaxUntitled,sizeof(MaxUntitled));
    DataLibRestorePos(&DiagramLib);
    DataLibClose(&DiagramLib);
    UpdateInfoInMainWindow(MWI_DIAGRAM,"");
  }
  CurDiagram=FALSE;
  ReadMarkerMap();	/* reset defaults */
}

/*------------------------*/
/* Export/import diagrams */


/* DataLibEnum callback for curves */
Local(FilePtr PNTR) ulp;
Local(Int2) uln;
Local(Int2) exportCurve(DataLibPtr dgm) {
  int ui;
  Char c;
  switch (DataLibEnumEvent) {
    case 1:	/* entry to group */
      fprintf(file,"  g %s\n",dgm->DirName+1);
      return 0;
    case 2:	/* exit from group */
      fprintf(file,"  g !\n");
      return 0;
  }
  c=dgm->SelectedDirPtr==dgm->CurDirPtr ? 'C' : 'c';
  for (ui=0; ui<uln; ui++)
    if (ulp[ui]==dgm->CurDirPtr) break;
  /* the above is correct for uln==0 also */
  fprintf(file,"  %c%i %s\n",c,ui,dgm->DirName);
  ExportCurve(dgm,file,outlevel);
  return 0;
}

/* Export one diagram */
Local(Int2) ExportDiagram(DataLibPtr arch) {
  DataLibVar(dgm);
  Int2 res;
  CharPtr p;
  char c;
  Char buf[20];
  /* Open the diagram */
  p=DataLibReadVRecord(arch,NULL);
  res=DataLibOpen(&dgm,p);
  _MemFree(p);
  if (res) return 0;	/* cannot be opened */
  sprintf(ParBuf,"%s '%s'...",DiagramTxt[EXPORTING_C],arch->DirName+1);
  PushContext(NULL,NULL,ParBuf);
  DataLibSavePos(&dgm);
  while(!DataLibUp(&dgm));
  /* 'd' and 'D' reserved for diagrams */
  c=DataLibGetUserPtr(arch,arch->ParentDirPtr)==arch->CurDirPtr ? 'D' : 'd';
  fprintf(file," %c %s\n",c,arch->DirName+1);
  /* (u) Max number of untitled curves */
  if (DataLibFind(&dgm,MAXUNT_PAR)==0) {
    p=DataLibReadVRecord(&dgm,NULL);
    fprintf(file,"  u %s\n   unt=%i\n",MAXUNT_PAR+1,(int)*(Int2Ptr)p);
    _MemFree(p);
  }
  /* (l) Real number of untitled curves */
  if (DataLibFind(&dgm,UNTLST)==0) {
    ulp=(FilePtr PNTR)DataLibReadVRecord(&dgm,NULL);
    uln=DataLibLastVRecLen/sizeof(FilePtr);
    fprintf(file,"  l %s\n   untcurves=%i\n",UNTLST+1,(int)uln);
  } else uln=0;
  /* (m) Markers */
  if (DataLibFind(&dgm,CURM_PART)==0) {
    fprintf(file,"  m %s\n",CURM_PART+1);
    ExportMarkers(&dgm,file);
  }
  /* (t) Default starter and generator */
  if (DataLibFind(&dgm,SG_PART)==0) {
    fprintf(file,"  t %s\n",SG_PART+1);
    ExportDefStaGen(&dgm,file);
  }
  /* (U) Unique numbers of func pars */
  if (DataLibFind(&dgm,UNIQUE_PART)==0) {
    fprintf(file,"  U %s\n",UNIQUE_PART+1);
    ExportUnique(&dgm,file);
  }
  /* (f) Functional parameters' source */
  if (DataLibFind(&dgm,FUNPAR_PART)==0) {
    fprintf(file,"  f %s\n",FUNPAR_PART+1);
    ExportFunPar(&dgm,file);
  }
  /* (F) Filters */
  if (DataLibFindBySubstr(&dgm,FILTER_PRE,TRUE)==0)
    do {
      fprintf(file,"  F %s\n",dgm.DirName+1);
      p=StrChr(dgm.DirName+StrLen(FILTER_PRE),' ');
      if (p) *p='\0';
      ExportFilter(&dgm,dgm.DirName+StrLen(FILTER_PRE),file);
      if (p) *p=' ';
    } while (DataLibFindBySubstr(&dgm,FILTER_PRE,FALSE)==0);
  /* (p) Default parameters of starters and generators */
  StrCpy(buf,GetParam(SFS_EXTENSIONS,"H"));
  if (DataLibFindBySubstr(&dgm,buf,TRUE)==0 &&
      dgm.DirName[0]==HIDDEN_CHAR)
    do {
      fprintf(file,"  p %s\n",dgm.DirName+1);
      ExportParams(&dgm,dgm.DirName+1,file,TRUE);
    } while (DataLibFindBySubstr(&dgm,buf,FALSE)==0 &&
	     dgm.DirName[0]==HIDDEN_CHAR);
  /* (S) Starter method */
  if (DataLibFindBySubstr(&dgm,ICS_PRE,TRUE)==0) {
    Int2 method;
    do {
      DataLibRead(&dgm,(CharPtr)&method,sizeof(method));
      fprintf(file,"  S %i %s\n",(int)method,dgm.DirName+1);
    } while (DataLibFindBySubstr(&dgm,ICS_PRE,FALSE)==0);
  }
  /* (G) Generator method */
  if (DataLibFindBySubstr(&dgm,ICG_PRE,TRUE)==0) {
    Int2 method;
    do {
      DataLibRead(&dgm,(CharPtr)&method,sizeof(method));
      fprintf(file,"  G %i %s\n",(int)method,dgm.DirName+1);
    } while (DataLibFindBySubstr(&dgm,ICG_PRE,FALSE)==0);
  }
  /* (c/C) curves */
  DataLibEnumEx++;	/* extended enumeration */
  DataLibEnum(&dgm,exportCurve,TRUE);
  DataLibEnumEx--;
  if (uln) _MemFree(ulp);
  /* Close the diagram */
  DataLibRestorePos(&dgm);
  DataLibClose(&dgm);
  fprintf(file,"  e -\n");	/* mark the end diagram */
  PopContext();
  return 0;
}

/* Export current diagram */
Local(Int2) ExportCurDiagram(DataLibPtr arch) {
  switch (DataLibEnumEvent) {
    case 1:	/* entry to group */
      fprintf(file," dg %s\n",arch->DirName+1);
      return 0;
    case 2:	/* exit from group */
      fprintf(file," dg !\n");
      return 0;
  }
  return ExportDiagram(arch);
}

Global(void) DiagramsExport(DataLibPtr arch, FILE PNTR out, Int2 level) {
  outlevel=level;
  file=out;
  fprintf(out," outlevel=%i\n",(int)outlevel);
  DataLibEnumEx++;	/* extended enumeration */
  DataLibEnumIgnore(COMMENT_STR);
  DataLibEnum(arch,ExportCurDiagram,TRUE);
  DataLibEnumIgnore(NULL);
  DataLibEnumEx--;
}

Global(void) DiagramsImport(DataLibPtr arch, FILE PNTR in, Boolean singledgm) {
  DataLibVar(dgm);
  CharPtr p;
  int l,n;
  Int2 rc,m;
  char c;
  Boolean goon;
  Char buf[PATH_MAX];
  /* singledgm==TRUE: import a diagram, otherwise import a system */
  fscanf(in," outlevel=%i\n",&l);
  outlevel=(Int2)l;
  while (fscanf(in," %c %[^\n]\n",&c,ParBuf+1)==2 && (c=='d' || c=='D')) {
    if (ParBuf[1]=='g') {	/* group */
      if (ParBuf[3]=='!') DataLibUp(arch);
      else {
	ParBuf[2]=SUBDIR_CHAR;
	DataLibCreate(arch,ParBuf+2);
	DataLibDown(arch);
      }
      continue;
    }
    ParBuf[0]=NAMEDIR_CHAR;
    if (singledgm) {
      StrCat(ParBuf," (imported ");
      DayTimeStr(ParBuf+StrLen(ParBuf),TRUE,TRUE);
      StrCat(ParBuf,")");
    }
    if (DataLibCreate(arch,ParBuf)) {
      myWarning("ID_CREATE",ParBuf);
      return;
    }
    rc=dCreate(arch,NULL);
    if (rc) {
      myWarning("ID_FILE",(int)rc);
      return;
    }
    if (c=='D') DataLibSetUserPtr(arch,arch->ParentDirPtr,arch->CurDirPtr);
    DataLibSeekDir(arch,arch->CurDirPtr);	/* a'la rewind the partition */
    p=DataLibReadVRecord(arch,NULL);
    rc=DataLibOpen(&dgm,p);
    _MemFree(p);
    if (rc) return;	/* cannot be opened */
    sprintf(ParBuf,"%s '%s'...",DiagramTxt[IMPORTING_C],arch->DirName+1);
    PushContext(NULL,NULL,ParBuf);
    if (!singledgm) {
      /* Save position in archlib and psudo-activate visualizer */
      DataLibSavePos(arch);
      DataLibUp(arch);
      VisFull=FALSE;
      ActivateVisualizer(arch);
    }
    goon=TRUE;
    uln=0;
    while (goon && fgets(ParBuf,PAR_BUF,in)) {
      StrTrim(ParBuf);
      switch (ParBuf[0]) {
	case 'g':	/* group entry/exit */
	  if (ParBuf[2]=='!') DataLibUp(&dgm);
	  else {
	    ParBuf[1]=SUBDIR_CHAR;
	    DataLibCreate(&dgm,ParBuf+1);
	    DataLibDown(&dgm);
	  }
	  break;
	case 'u':	/* Max number of untitled curves */
	  fscanf(in,"   unt=%i",&n);
	  MaxUntitled=(Int2)n;
	  DataLibWriteVRecord(&dgm,MAXUNT_PAR,(CharPtr)&MaxUntitled,sizeof(MaxUntitled));
	  break;
	case 'l':	/* Number of untitled curves */
	  fscanf(in,"   untcurves=%i\n",&n);
	  uln=(Int2)n;
	  ulp=_MemNew(ARRAYSIZE(FilePtr,uln));
	  break;
	case 'm':	/* Markers */
	  DataLibCreate(&dgm,CURM_PART);
	  ImportMarkers(&dgm,in);
	  break;
	case 't':	/* Default starter and generator */
	  DataLibCreate(&dgm,SG_PART);
	  ImportDefStaGen(&dgm,in);
	  break;
	case 'U':	/* Unique numbers of func pars */
	  DataLibCreate(&dgm,UNIQUE_PART);
	  ImportUnique(&dgm,in);
	  break;
	case 'f':	/* Functional parameters' source */
	  DataLibCreate(&dgm,FUNPAR_PART);
	  ImportFunPar(&dgm,in);
	  /* allocate a file for lib and write it */
	  AssignFileName();	/* this fills in ParBuf */
	  GetParamAppend(SFS_EXTENSIONS,"LIB");
	  DataLibWriteVRecord(&dgm,LIB_PART,ParBuf,StrLen(ParBuf)+1);
	  break;
	case 'F':	/* Filter */
	  ParBuf[1]=HIDDEN_CHAR;
	  DataLibCreate(&dgm,ParBuf+1);
	  sscanf(ParBuf+1," "FILTER_PRE"%s",buf);
	  ImportFilter(&dgm,buf,in);
	  break;
	case 'p':	/* Default parameters of starters and generators */
	  ParBuf[1]=HIDDEN_CHAR;
	  DataLibCreate(&dgm,ParBuf+1);
	  ImportParams(&dgm,dgm.DirName+1,in,TRUE);
	  break;
	case 'S':	/* Starter metod */
	case 'G':	/* Generator metod */
	  sscanf(ParBuf,"%*c %i %n",&n,&l);
	  m=(Int2)n;
	  ParBuf[l-1]=HIDDEN_CHAR;
	  DataLibCreate(&dgm,ParBuf+l-1);
	  DataLibWrite(&dgm,(CharPtr)&m,sizeof(m));
	  break;
	case 'C':	/* Curve (Selected) */
	case 'c':	/* Curve */
	  DataLibCreate(&dgm,StrChr(ParBuf,' ')+1);
	  if (ParBuf[0]=='C') {
	    dgm.SelectedDirPtr=dgm.CurDirPtr;
	    DataLibSetSelected(&dgm);
	  }
	  sscanf(ParBuf+1,"%i",&n);
	  if (n<uln) ulp[n]=dgm.CurDirPtr;
	  ImportCurve(&dgm,in,outlevel);
	  break;
	case 'e':	/* End of diagram */
	  goon=FALSE;
	  break;
      }
    }
    if (uln) {
      DataLibWriteVRecord(&dgm,UNTLST,(CharPtr)ulp,ARRAYSIZE(FilePtr,uln));
      _MemFree(ulp);
    }
    DataLibClose(&dgm);
    if (!singledgm) {
      /* Restore position in archlib and psudo-deactivate visualizer */
      DeactivateVisualizer(arch);
      VisFull=TRUE;
      DataLibRestorePos(arch);
    }
    PopContext();
  }
}