/*
   Scroll table window's class functions.
   They need not to be reenterable
   but MUST be reusable.
*/

#include "common.h"

#if LINKIN
#include "large.h"
#include "tsprintf.h"
#undef MemNew
#undef MemMore
#undef MemFree
#undef StringSave
#define MemNew     _MemNew
#define MemMore    _MemMore
#define MemFree    _MemFree
#define StringSave _StringSave
#else	/* LINKIN */
#include "corefunc.h"
#include "inter.h"
#endif	/*LINKIN */

#define GET_CLASS_TABLE	tab_GetClassTable	/* Unique name of the 'Get Class Table' function */
#include "window.h"

/* GetClassTable is generated by window.h */

/* Texts */
Local(CharPtr) Text[]={
  "Compute{",
  "Forward",
  "Backward",
  "Extend",
  "Window{",
  "Redraw diagram",
  "Redraw curve",
  "Clear",
  "Layout",
  "Hardcopy",
  "Hide",
  "Help{",
  "This window",
  "Search",
  "-",
  "}",
  "Waiting for attributes setting",
  "Attributes of the table",
  "20,(7,13)",		/* TextLen,(ListLines,LineLen) */
  "List of expressions",
  "Options",
  "Number of lines",
  "Precision",
  "Show heading line",
  "Right-justify numbers",
  "Mark special points",
  "Sample of window",
  "Hardcopy options",
  "File",
  "Copy",
  "current curve only",
  "all curves from the current diagram",
  "Waiting for hardcopy options",
  "Browse",
  "Window title",
  NULL
};

enum {
  COMPUTE_M,
  FORWARD_I,
  BACKWARD_I,
  EXTEND_I,
  WINDOW_M,
  REDRAWD_I,
  REDRAWC_I,
  CLEAR_I,
  GAATTRA_I,
  HARDCOPY_I,
  HIDE_I,
  HELP_M,
  HELP_I,
  SEARCH_I,
  SEPARATOR_I,
  DUMMYEND_I,
  WAITATTR_C,	/* Waiting for attributes setting */
  BOX_TITLE,	/* Attributes */
  DBSIZES,	/* 20,(6,12) ! TextLen,(ListLines,LineLen) */
  EXPR_P,	/* Expressions */
  OPTIONS_T,	/* Options */
  NLINES_P,	/* Number of lines */
  PRECISION_P,	/* Precision */
  SHOWTITLE_B,	/* Show title */
  ALIGNRIGHT_B,	/* Align right */
  POINTTYPE_B,	/* Indicate point type */
  SAMPLE_WIN,	/* Sample of window */
  HARDCOPY_T,	/* Hardcopy options */
  HCFILE_G,	/* File */
  HCCOPY_G,	/* Copy */
  HCTACTIVE_B,	/* current curve only */
  HCTALL_B,	/* all curves from current diagram */
  HARDCOPY_C,	/* Waiting for hardcopy options */
  FILELIST_B,	/* Browse */
  WINTITLE_P,	/* Window title */
  _L_A_S_T_
};


#define DEFAULT_TITLE	"Table"			/* default title of window */

#define HK_TABLEWIN	"kh_TableWin"		/* Help key for table window */
#define HK_LAYOUTWIN	"kh_TableWinLayout"	/* Help key for layout dialog box */
#define HK_HARDCOPYWIN	"kh_TableWinHardcopy"	/* Help key for hardcopy dialog box */

/* Settings file section name */
#define SECTION		"Window_ScrollTable"

/*
   AutonomousPanel increases width and height.
   We must neutralize this.
*/
#define W_AUTOPAN	(vScrollBarWidth+8)
#define H_AUTOPAN	(8)

/* Width of the column with labels */
#define SPEC_WIDTH	(StringWidth("WWWW"))

/* Window function */
#define WIN_HEAD				\
  "void"					\
  " $("SFS_COMPILER".RHSATTR)"			\
  " %s"						\
  " (double * * * $("SFS_VISUAL".WINPAR),"	\
  " char * _buf,"				\
  " char * _fmt,"				\
  " char * _pointtype) {"STR_NL			\
  "  sprintf(_buf,_fmt,"

#define WIN_TAIL				\
  ",_pointtype);"STR_NL"}"STR_NL

typedef EntryPtr(void,WinFuncPtr,(FloatHiPtr PNTR PNTR ptr,
				  CharPtr buf,
				  CharPtr fmt,
				  CharPtr pointtype));

/* Private data structure which describes window's controls */
typedef struct {
  /* Description of controls */
  CharPtr ExprList;	/* List of exprs for sprintf */
  int Precision;	/* of each column */
  int MaxLines;		/* in the table */
  Boolean Heading;	/* of the table */
  Boolean JustRight;	/* otherwise left */
  Boolean MarkSpecial;	/* indicate point type */
  /* Work area */
  int ColNum;		/* Number of columns */
  int CurLines;
  DoC Doc;		/* Table itself */
  BaR Bar;		/* of Doc */
  Int2 VisLines;	/* number of visible lines */
  ColPtr ColFmt;	/* for Append/Replace Item */
  ParData ParFmt;	/* --- " --- */
  CharPtr PrintBuf;	/* buffer for window function */
  CharPtr PrintFmt;	/* Format for window function */
  ColorPtr LineColor;	/* Color (<0 for ordinary points) */
  Int2 CurLineColor;	/* LineColor[CurLineColor] corresponds to 1st item */
  WinFuncPtr WinFunc;	/* window function entry point */
  FILE PNTR HardFile;	/* output for hardcopy */
  Boolean Hardcopy;	/* set when in hardcopy progress for this window */
  Boolean HardDiagram;	/* otherwise curve */
} TabData, PNTR TabDataPtr;

#define INSET	2

#if _WIN
#pragma argsused
#endif
Local(Boolean) AlwaysStatus(Int2 indx) {
  return TRUE;
}

Callback(void) lRedrawD(Int2 indx);
Callback(void) lRedrawC(Int2 indx);

Callback(void) lClear(Int2 indx);

Callback(void) lLayout(Int2 indx);

Callback(void) lHardCopy(Int2 indx);

Callback(void) lHelp(Int2 indx);

Callback(void) lHelpSearch(Int2 indx);

/* Menu */
Local(MenuItem) TableMenu[]={
  {COMPUTE_M,		NULL,		NULL},
  {  FORWARD_I,		NULL,		NULL},
  {  BACKWARD_I,	NULL,		NULL},
  {  SEPARATOR_I,	NULL,		NULL},
  {  EXTEND_I,		NULL,		NULL},
  {  DUMMYEND_I,	NULL,		NULL},
  {WINDOW_M,		NULL,		NULL},
  {  REDRAWD_I,		lRedrawD,	NULL,0,MNFL_ACTIVEINPAUSE},
  {  REDRAWC_I,		lRedrawC,	NULL,0,MNFL_ACTIVEINPAUSE},
  {  SEPARATOR_I,	NULL,		NULL},
  {  CLEAR_I,		lClear,		AlwaysStatus,0,MNFL_ACTIVEINPAUSE},
  {  SEPARATOR_I,	NULL,		NULL},
  {  GAATTRA_I,		lLayout,	AlwaysStatus},
  {  SEPARATOR_I,	NULL,		NULL},
  {  HARDCOPY_I,	lHardCopy,	NULL},
  {  SEPARATOR_I,	NULL,		NULL},
  {  HIDE_I,		NULL,		AlwaysStatus,0,MNFL_ACTIVEINPAUSE},
  {  DUMMYEND_I,	NULL,		NULL},
  {HELP_M,		NULL,		NULL},
  {  HELP_I,		lHelp,		AlwaysStatus,0,MNFL_ACTIVEINPAUSE},
  {  SEPARATOR_I,	NULL,		NULL},
  {  SEARCH_I,		lHelpSearch,	AlwaysStatus,0,MNFL_ACTIVEINPAUSE},
  {  DUMMYEND_I,	NULL,		NULL}
};

Local(ParData) ParFmt={FALSE,FALSE,FALSE,FALSE,FALSE,0,0};
Local(ColData) ColFmt[1]={{0,INSET,0,0,NULL,'l',FALSE,TRUE,FALSE,FALSE,FALSE}}; /* inset and bar */

/*
   Computes the max width of
   - real number with precision prec (prec>0), or
   - int number with prec digits (prec<0).
*/
Local(Char) cotest[2]="?";
Local(Char) cochars[]="0123456789.+-e";
Local(int) NumberWidth(int prec) {
  int i,w,maxw;
  for (i=maxw=0; i<DIM(cochars); i++) {
    cotest[0]=cochars[i];
    w=StringWidth(cotest);
    if (w>maxw) maxw=w;
  }
  return maxw*(prec<0 ? -prec : prec+6);
}

/* Appends heading item */
Local(Int2) AppendHeading(TabDataPtr td) {
  CharPtr p;
  Int2 i;
  if (!td->ColNum) return 0;
  p=MemNew(StrLen(td->ExprList)+3);
  sprintf(p,"%s\t ",td->ExprList);
  p=StrSubstitute(p,",","\t",FALSE,NULL);
  for (i=0; i<td->ColNum; i++) {
    td->ColFmt[i].underline=TRUE;
    td->ColFmt[i].just='c';
  }
  AppendText(td->Doc,p,&td->ParFmt,td->ColFmt,ProgramFont);
  UpdateDocument(td->Doc,1,1);
  MemFree(p);
  td->CurLines++;
  td->LineColor[td->CurLineColor++]=-1;
  for (i=0; i<td->ColNum; i++) {
    td->ColFmt[i].underline=FALSE;
    td->ColFmt[i].just=td->JustRight ? 'r' : 'l';
  }
  return td->ParFmt.minHeight;
}

Local(Int2) CountExpr(CharPtr ExprList) {
  Int2 i,n;
  n=0;
  if (ExprList && *ExprList)
    for (i=0,n=1; ExprList[i]; i++)
      if (ExprList[i]==',') n++;
  return n;
}

/* Builds unique window function's name */
Local(void) BuildFuncName(CharPtr buf, Int1 unique) {
  sprintf(buf,"_tab_%i",(int)unique);
}

ClassMember(void) BuildDefaultDescription(WinComDataPtr wcd) {
  TabDataPtr td;
  CharPtr p;
  Char ch,cj,cs;
  wcd->WinTitle=StringSave(DEFAULT_TITLE);
  if (!wcd->Private)
    wcd->Private=MemNew(sizeof(TabData));
  td=(TabDataPtr)wcd->Private;
  td->ColNum=0;
  p=GetParamString(SECTION,"OPTIONS");
  sscanf(p,"%i,%i,%c,%c,%c",&td->MaxLines,&td->Precision,&ch,&cj,&cs);
  td->Heading=ch=='t';
  td->JustRight=cj=='t';
  td->MarkSpecial=cs=='t';
}

ClassMember(void) ReadDescription(WinComDataPtr wcd, DataLibPtr arch){
  TabDataPtr td;
  if (!wcd->Private)
    wcd->Private=MemNew(sizeof(TabData));
  td=(TabDataPtr)wcd->Private;
  td->ExprList=DataLibReadVRecord(arch,NULL);
  DataLibRead(arch,(CharPtr)&td->Precision,sizeof(td->Precision));
  DataLibRead(arch,(CharPtr)&td->MaxLines,sizeof(td->MaxLines));
  DataLibRead(arch,(CharPtr)&td->Heading,sizeof(td->Heading));
  DataLibRead(arch,(CharPtr)&td->JustRight,sizeof(td->JustRight));
  DataLibRead(arch,(CharPtr)&td->MarkSpecial,sizeof(td->MarkSpecial));
}

ClassMember(void) WriteDescription(WinComDataPtr wcd, DataLibPtr arch) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  DataLibWriteVRecord(arch,NULL,td->ExprList,StringLen(td->ExprList)+1);
  DataLibWrite(arch,(CharPtr)&td->Precision,sizeof(td->Precision));
  DataLibWrite(arch,(CharPtr)&td->MaxLines,sizeof(td->MaxLines));
  DataLibWrite(arch,(CharPtr)&td->Heading,sizeof(td->Heading));
  DataLibWrite(arch,(CharPtr)&td->JustRight,sizeof(td->JustRight));
  DataLibWrite(arch,(CharPtr)&td->MarkSpecial,sizeof(td->MarkSpecial));
  MemFree(td->ExprList);
}

/* Color proc */
#if _WIN
#pragma argsused
#endif
Callback(Boolean) DocColorProc(DoC Doc, Int2 Item, Int2 Row, Int2 Col) {
  WinComDataPtr wcd=(WinComDataPtr)(GetWindowExtra(ParentWindow(Doc)));
  TabDataPtr td=(TabDataPtr)wcd->Private;
  Int2 h=td->Heading?1:0;
  Int2 ml=td->MaxLines+h;
  Int2 n=(td->CurLineColor+Item-1-h);
  if (Item==1 && h) return FALSE;
  if (n>=ml) n-=ml-h;
  if (td->LineColor[n]>=0) {
    ColorSet(td->LineColor[n]);
    return TRUE;
  } else return FALSE;
}

ClassMember(void) CreateControls(WinComDataPtr wcd) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  RecT rd,rw;
  Int2 d,m,mbw;
  Int2 i,h;
  Char buf[50];
  h=wcd->Height;
  SelectFont(ProgramFont);
  ParFmt.minHeight=FontHeight()+1;
  if (wcd->flags&WFL_RESIZE) {	/* resize in progress - just resize controls */
    GetPosition(td->Doc,&rd);
    rd.right=rd.left+wcd->Width;
    rd.bottom=rd.top+h;
    SetPosition(td->Doc,&rd);
    SetValue(td->Bar,0);	/* to avoid a message about scroll slider under Motif */
    AdjustDocScroll(td->Doc);
    UpdateDocument(td->Doc,1,td->CurLines);
    GetPosition(td->Doc,&rd);
    UpsetRect(&rd,0,0,-2*(WHM+1),-2*(WVM+1));	/* hide window's margins and panel's frame */
    SetPosition(td->Doc,&rd);
  } else {
    /* Create DocumentPanel */
    td->Doc=DocumentPanel(wcd->Win,
			  wcd->Width-W_AUTOPAN,
			  wcd->Height-H_AUTOPAN);
    SetDocShade(td->Doc,NULL,NULL,NULL,DocColorProc);
    td->LineColor=NULL;
    td->CurLineColor=0;
    td->Bar=GetSlateVScrollBar((SlatE)td->Doc);
    td->CurLines=0;
    Hide(td->Doc); /* MUST be hidden for the following SetPositions be successful (X11) */
    RealizeWindow(wcd->Win);
    /* Count expressions in the list */
    td->ColNum=CountExpr(td->ExprList);
    if (td->ColNum) {
      /* Prepare data structure for Append/Replace Item */
      td->ColFmt=MemNew(ARRAYSIZE(ColData,td->ColNum+1));
      ColFmt[0].pixWidth=NumberWidth(td->Precision)+2*INSET;
      ColFmt[0].font=ProgramFont;
      ColFmt[0].just=td->JustRight ? 'r' : 'l';
      for (i=0; i<=td->ColNum; i++) {
	MemMove(td->ColFmt+i,ColFmt,sizeof(ColFmt));
      }
      td->ColFmt[td->ColNum].last=TRUE;
      td->ColFmt[td->ColNum].pixWidth=td->MarkSpecial ? SPEC_WIDTH : 0;
      td->ColFmt[td->ColNum].just='c';
      MemMove(&td->ParFmt,&ParFmt,sizeof(ParFmt));
      /* Memory for line marks (allocate before AppendHeading!) */
      td->LineColor=MemNew(ARRAYSIZE(Color,td->MaxLines+(td->Heading?1:0)));
      /* Column headings */
      if (td->Heading) h-=AppendHeading(td);
      /* Allocate print buffer used by the window function */
      i=td->ColNum*((td->Precision+6)+1+(td->MarkSpecial?50:0));	/* ColNum-1 tabs and \0 */
      td->PrintBuf=MemNew(i);
      /* Format string */
      sprintf(buf,"%%#.%ig",td->Precision);
      td->PrintFmt=MemNew(td->ColNum*(StringLen(buf)+1)+3+1);	/* p[0]=='\0'! */
      for (i=0; i<td->ColNum; i++)
	sprintf(td->PrintFmt+StringLen(td->PrintFmt),"%s\t",buf);
      StrCat(td->PrintFmt,"%s ");	/* blank: to make last col non-empty => draw bar in it */
      /* Resize window horizontally */
      GetPosition(wcd->Win,&rw);
      GetPosition(td->Doc,&rd);
      AppendText(td->Doc,NULL,&td->ParFmt,td->ColFmt,ProgramFont);
      GetDocParams(td->Doc,&m,NULL);	/* m is 1 or 2 */
      GetColParams(td->Doc,m,td->ColNum+1,&d,&i,NULL,NULL);
      DeleteItem(td->Doc,m);
      d+=i+W_AUTOPAN;
      /*
	d is the width we need.
	Increase it if menu bar is wider.
      */
      for (mbw=vScrollBarWidth, i=0; i<wcd->MenuDesc.Num; i++)
	if (wcd->MenuDesc.Menu[i].Kind==MENU_PULLDOWN)
	  mbw+=StringWidth(Text[wcd->MenuDesc.Menu[i].Title])+sysCharWidth;
      if (mbw>d) d=mbw;
      /* now resize */
      d-=rd.right-rd.left;
      rd.right+=d;
      rw.right+=d;
      d=screenRect.right-rw.right;
      if (d<0) {
	rw.right+=d;
	rd.right+=d;
      }
      SetPosition(wcd->Win,&rw);
      SetPosition(td->Doc,&rd);
      wcd->Width=(rw.right-rw.left+1)-wcd->BorderWidth;
    }
    GetPosition(td->Doc,&rd);
    InsetRect(&rd,-(WHM+1),-(WVM+1));	/* hide window's margins and panel's frame */
    SetPosition(td->Doc,&rd);
  }
  Show(td->Doc);
  if (td->MaxLines<h/ParFmt.minHeight) {
    Int2 hd=td->Heading?1:0;
    Int2 old=td->MaxLines+hd;
    Int2 new,i,j;
    td->MaxLines=h/ParFmt.minHeight+1;
    if (td->LineColor) {
      new=td->MaxLines+hd;
      td->LineColor=MemMore(td->LineColor,ARRAYSIZE(Color,new));
      /* resize: */
      j=hd;
      for (i=old; i<new && j<td->CurLineColor; i++,j++) {
        td->LineColor[i]=td->LineColor[hd];
	MemMove(td->LineColor+hd,td->LineColor+hd+1,ARRAYSIZE(Color,td->CurLineColor-1-hd));
      }
      for (; i<new; i++)
        td->LineColor[i]=wcd->Foreground;
    }
  }
  GetPosition(td->Doc,&rd);
  td->VisLines=(rd.bottom-rd.top+1)/ParFmt.minHeight;
}

ClassMember(void) RemoveControls(WinComDataPtr wcd) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  if (wcd->flags&WFL_RESIZE) {	/* resize in progress - just hide controls */
    Hide(td->Doc);
  } else {
    td->Doc=Remove(td->Doc);
    td->ColFmt=MemFree(td->ColFmt);
    td->PrintBuf=MemFree(td->PrintBuf);
    td->PrintFmt=MemFree(td->PrintFmt);
    td->LineColor=MemFree(td->LineColor);
  }
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) ManageControls(WinComDataPtr wcd, Boolean enable) {
  /* Nothing. Status function for this window is always "1" */
}

ClassMember(void) BuildMenu(WinComDataPtr wcd) {
  MenuItemPtr ip;
  Int2 i;
  wcd->MenuDesc.Menu=ip=MemNew(sizeof(TableMenu));
  wcd->MenuDesc.Num=DIM(TableMenu);
  wcd->MenuDesc.Lock=0;
  wcd->MenuDesc.Texts=Text;
  MemCopy(ip,TableMenu,sizeof(TableMenu));
  for (i=0; i<wcd->MenuDesc.Num; i++) {
    if (ip[i].Title==FORWARD_I) {
      ip[i].Action=Forward;
      ip[i].EnableDisable=FBStatus;
      continue;
    }
    if (ip[i].Title==BACKWARD_I) {
      ip[i].Action=Backward;
      ip[i].EnableDisable=FBStatus;
      continue;
    }
    if (ip[i].Title==EXTEND_I) {
      ip[i].Action=Extend;
      ip[i].EnableDisable=ExtendStatus;
      continue;
    }
    if (ip[i].Title==REDRAWD_I) {
/***      ip[i].Action=RedrawDiagram;***/
      ip[i].EnableDisable=RedrawDStatus;
      continue;
    }
    if (ip[i].Title==REDRAWC_I) {
/***      ip[i].Action=RedrawCurve;***/
      ip[i].EnableDisable=RedrawCStatus;
      continue;
    }
    if (ip[i].Title==HARDCOPY_I) {
      ip[i].EnableDisable=HardcopyStatus;
      continue;
    }
    if (ip[i].Title==HIDE_I) {
      ip[i].Action=HideWin;
      continue;
    }
  }
}

ClassMember(void) NewInitPoint(WinComDataPtr wcd) {
  ClearWindow(wcd);
}

ClassMember(void) ClearWindow(WinComDataPtr wcd) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  ResetClip();	/* Does not work without this (in Unix at least) */
  ColorSet(wcd->Background);
  InvertColors();
  ColorSet(wcd->Foreground);
  Reset((PaneL)td->Doc);
  td->CurLines=0;
  td->CurLineColor=0;
  if (td->Heading) AppendHeading(td);
}

ClassMember(Boolean) SimpleFunctions(WinComDataPtr wcd) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  CharPtr p,q;
  Int2 i;
  Boolean res;
  wcd->flags|=WFL_GDIM1;
  for (i=0, p=td->ExprList; i<td->ColNum; i++) {
    q=StrChr(p,',');
    if (q) *q='\0';
    res=GdimEq1(p);
    if (q) { *q=','; p=q+1;}
    if (!res) {
      wcd->flags&=~WFL_GDIM1;
      break;
    }
  }
  return (Boolean)(td->ColNum==0);	/* compile if there is the list */
}

ClassMember(void) PutFunctions(WinComDataPtr wcd, FILE PNTR Source, Int2Ptr LineNum) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  CharPtr p;
  Char buf[15];
  if (!SimpleFunctions(wcd)) {
    /* Header */
    SetParam("TMP","TMP",WIN_HEAD);	/* Force replacement */
    p=GetParamString("TMP","TMP");	/* of symbolical references */
    BuildFuncName(buf,wcd->Unique);
    p=(CharPtr)TSPrintf(p,buf);
    fputs(CountLinesAndErase_r(p,'\n',LineNum),Source);
    /* Expressions list */
    fprintf(Source,"%s",td->ExprList);
    /* Tail */
    SetParam("TMP","TMP",WIN_TAIL);	/* Force replacement */
    p=GetParamString("TMP","TMP");	/* of symbolical references */
    fputs(CountLinesAndErase_r(p,'\n',LineNum),Source);
  }
}

ClassMember(void) SetFunctions(WinComDataPtr wcd, LibHandle hWinLib) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  Char buf[15];
  td->WinFunc=NULL;
  if (td->ColNum) {
    /* Entry point */
    BuildFuncName(buf,wcd->Unique);
    if (hWinLib && !SimpleFunctions(wcd))
      td->WinFunc=(WinFuncPtr)LibraryFuncAddress(hWinLib,buf);
  }
}

#define IMPEXP_FORMAT						\
	"   exprlist=%s\n"					\
	"   prec=%i lines=%i heading=%i just=%i mark=%i\n"

ClassMember(void) ExportDescription(WinComDataPtr wcd, DataLibPtr arch, FILE PNTR out) {
  TabDataPtr td;
  ReadDescription(wcd,arch);
  td=(TabDataPtr)wcd->Private;
  fprintf(out,IMPEXP_FORMAT,
		td->ExprList,
		td->Precision,
		td->MaxLines,
		td->Heading,
		td->JustRight,
		td->MarkSpecial);
  WriteDescription(wcd,NULL);	/* free mem only */
  MemFree(td);
}

ClassMember(void) ImportDescription(WinComDataPtr wcd, DataLibPtr arch, FILE PNTR in) {
  TabData td;
  int h,j,m;
  MemFill(&td,0,sizeof(td));
  wcd->Private=&td;
  td.ExprList=MemNew(1000);
  fscanf(in,IMPEXP_FORMAT,
		td.ExprList,
		&td.Precision,
		&td.MaxLines,
		&h,
		&j,
		&m);
  td.Heading=h!=0;
  td.JustRight=j!=0;
  td.MarkSpecial=m!=0;
  WriteDescription(wcd,arch);
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) SaveAttr(WinComDataPtr wcd, DataLibPtr arch,
		ByteStorePtr from,  ByteStorePtr to, Boolean freemem) {
  /* nothing */
}
		
#if _WIN
#pragma argsused
#endif
ClassMember(void) RestoreAttr(WinComDataPtr wcd, DataLibPtr arch,
		ByteStorePtr from,  ByteStorePtr to, Boolean skip) {
  /* nothing */
}
		
#if _WIN
#pragma argsused
#endif
ClassMember(void) ExportAttr(WinComDataPtr wcd, DataLibPtr dgm, FILE PNTR out) {
  /* nothing */
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) ImportAttr(WinComDataPtr wcd, DataLibPtr dgm, FILE PNTR in) {
  /* nothing */
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) PushAttr(WinComDataPtr wcd, Boolean freemem) {
  /* nothing */
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) PopAttr(WinComDataPtr wcd) {
  /* nothing */
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) SpecialAction(WinComDataPtr wcd, VisualSpecAction vsa) {
  /* nothing */
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) FreeCurveData(WinComDataPtr wcd, FilePtr fp) {
  /* nothing */
}

ClassMember(void) GInit(WinComDataPtr wcd) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  if (!td->ColNum) return;
  UseWindow(wcd->Win);
  ClearWindow(wcd);
  if (td->Hardcopy)
    if (td->HardDiagram) {	/* all curves */
      fprintf(td->HardFile,"%%BeginCurve: %s\n",DiagramLib.DirName);
    }
}

ClassMember(void) GTerm(WinComDataPtr wcd) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  if (!td->ColNum) return;
  if (td->Hardcopy)
    if (td->HardDiagram) {	/* all curves */
      fprintf(td->HardFile,"%%EndCurve: %s\n",DiagramLib.DirName);
    }
}

ClassMember(void) MInit(WinComDataPtr wcd) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  if (!td->ColNum) return;
  UseWindow(wcd->Win);
  if (ccd.curveDimG>1) ClearWindow(wcd);
  td->PrintBuf[0]='\0';
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) MTerm(WinComDataPtr wcd) {
  /* nothing */
}

ClassMember(void) MProcess(WinComDataPtr wcd) {
  TabDataPtr td=(TabDataPtr)wcd->Private;
  CharPtr ptype="";
  Int2 ml;
  Color lcol=wcd->Foreground;
  if (td->ColNum && td->WinFunc) {
    if (ccd.localpointType && !ccd.lastPoint) {
      if (td->MarkSpecial)
	GetSPAttr(ccd.pointType,&ptype,&lcol);
    }
    td->WinFunc(IndirectValues,td->PrintBuf,td->PrintFmt,ptype);
  } else return;
  UseWindow(wcd->Win);
#if _UNIX
  ResetClip();	/* Does not work properly under Motif without this */
#endif
  ml=td->MaxLines;
  if (td->Heading) ml++;
  /* Store point type before AppendText/DeleteItem */
  if (td->CurLines<ml) {
    td->LineColor[td->CurLines]=lcol;
    AppendText(td->Doc,td->PrintBuf,&td->ParFmt,td->ColFmt,ProgramFont);
    SetValue(td->Bar,td->CurLines);
    td->CurLines++;
    UpdateDocument(td->Doc,td->CurLines,td->CurLines);
  } else {
    td->LineColor[td->CurLineColor++]=lcol;
    if (td->CurLineColor>=ml) td->CurLineColor=td->Heading ? 1 : 0;
#if _UNIX
    CorrectBarValue(td->Bar,ml-1-td->VisLines);
#endif
    DeleteItem(td->Doc,td->Heading ? 2 : 1);
    CorrectBarValue(td->Bar,ml-2);
    AppendText(td->Doc,td->PrintBuf,&td->ParFmt,td->ColFmt,ProgramFont);
    SetValue(td->Bar,ml-1);
    UpdateDocument(td->Doc,ml,ml);
  }
  if (td->Hardcopy) {
    CharPtr p;
    Int2 i;
    for (i=0,p=td->PrintBuf; i<td->ColNum; i++,p++)
      p=StrChr(p,'\t');
    p[-1]='\0';
    fprintf(td->HardFile,"%s\n",td->PrintBuf);
  }
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) hcPen(WinComDataPtr wcd, DrawAttrPtr attr) {
  /* nothing */
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) hcString(WinComDataPtr wcd, CharPtr str, float PNTR data) {
  /* nothing */
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) hcPaintOval(WinComDataPtr wcd, RectPtr r) {
  /* nothing */
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) hcFrameOval(WinComDataPtr wcd, RectPtr r) {
  /* nothing */
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) hcPaintPoly(WinComDataPtr wcd, Int2 num, PointPtr poly) {
  /* nothing */
}

#if _WIN
#pragma argsused
#endif
ClassMember(void) hcFramePoly(WinComDataPtr wcd, Int2 num, PointPtr poly) {
  /* nothing */
}

/******************/
/* Menu callbacks */

#define GetComDataI ((WinComDataPtr)GetWindowExtra(CurrentWindow()))

/*---------------------------------------*/
/* Menu callback: Redraw current diagram */
#if _WIN
#pragma argsused
#endif
Callback(void) lRedrawD(Int2 indx) {
  WinComDataPtr wcd=GetComDataI;
  DeactivateWindows(wcd);
  RedrawDiagram(0);
  ActivateWindows();
}

/*-------------------------------------*/
/* Menu callback: Redraw current curve */
#if _WIN
#pragma argsused
#endif
Callback(void) lRedrawC(Int2 indx) {
  WinComDataPtr wcd=GetComDataI;
  DeactivateWindows(wcd);
  RedrawCurve(0);
  ActivateWindows();
}

/*---------------------------------*/
/* Menu callback: Clear the window */

#if _WIN
#pragma argsused
#endif
Callback(void) lClear(Int2 indx) {
  ClearWindow(GetComDataI);
}

/*----------------------------------*/
/* Menu callback: Layout dialog box */

typedef struct {
  WinComDataPtr Com;
  TexT Title;			/* WinTitle */
  TexT ExprList;
  TexT Lines;			/* in the table */
#if MYSWITCH
  Switch Precision;		/* of numbers in column(s) */
#else
  SwitcH Precision;		/* of numbers in column(s) */
#endif
  ButtoN Heading;
  ButtoN JustRight;
  ButtoN MarkSpecial;
  PaneL Sample;			/* of window's layout */
  Boolean Recompile;
} LayoutData, PNTR LayoutDataPtr;

#define GetLayoutDataC(h) ((LayoutDataPtr)GetWindowExtra(ParentWindow(h)))

/* Cancel callback */
Callback(void) LayoutCancel(ButtoN bt) {
  LayoutDataPtr layout=GetLayoutDataC(bt);
  WinComDataPtr wcd=layout->Com;
  PopContext();
  MemFree(layout);
  Select(wcd->Win);
  Remove(ParentWindow(bt));
  UnlockMenus();
}

/* Ok callback */
Callback(void) LayoutOk(ButtoN bt) {
  LayoutDataPtr layout=GetLayoutDataC(bt);
  WinComDataPtr wcd=layout->Com;
  TabDataPtr td=(TabDataPtr)wcd->Private;
  CharPtr p;
  /* Remove old controls (they may depend on old options) */
  RemoveControls(wcd);
  /* Title */
  GetTitleAndSave(layout->Title,&wcd->WinTitle);
  /* Get expressions list */
  GetTitleAndSave(layout->ExprList,&td->ExprList);
  StrTrim(td->ExprList);
  /* Get lines number */
  p=NULL;
  GetTitleAndSave(layout->Lines,&p);
  sscanf(p," %i",&td->MaxLines);
  if (td->MaxLines<=0 || td->MaxLines>32000)
    td->MaxLines=100;
  MemFree(p);
  /* Precision */
#if MYSWITCH
  td->Precision=SwitchGetValue(layout->Precision);
#else
  td->Precision=GetValue(layout->Precision);
#endif
  /* Toggles */
  td->Heading=GetStatus(layout->Heading);
  td->JustRight=GetStatus(layout->JustRight);
  td->MarkSpecial=GetStatus(layout->MarkSpecial);
  /* Store as default options */
  p=MemNew(100);
  sprintf(p,"%i,%i,%c,%c,%c",td->MaxLines,td->Precision,
				td->Heading ? 't' : 'f',
				td->JustRight ? 't' : 'f',
				td->MarkSpecial ? 't' :'f');
  SetParam(SECTION,"OPTIONS",p);
  MemFree(p);
  /* Recompile flag */
  if (layout->Recompile) wcd->flags|=WFL_FUNC_EDITED;
  else wcd->flags&=~WFL_FUNC_EDITED;
  /* Rebuild all */
  RecreateWindow(wcd);
  /* Clean up */
  LayoutCancel(bt);
}

/* Help callback */
#if _WIN
#pragma argsused
#endif
Callback(void) LayoutHelp(ButtoN bt) {
  Help(NULL);
}

/* ExprList callback (just records change in the expressions list) */
#if _WIN
#pragma argsused
#endif
Callback(void) RecordChange(TexT t) {
  LayoutDataPtr layout=GetLayoutDataC(t);
  layout->Recompile=TRUE;
}

/* Sample callback */
Callback(void) DrawSample(PaneL p) {
  LayoutDataPtr layout=GetLayoutDataC(p);
  WinComDataPtr wcd=layout->Com;
  FloatLo x;
  RecT r;
  int prec,lines,lp1,rp1,lp2,rp2;
  Int2 i,lh;
  Boolean align;
  Select(p);
  SelectFont(ProgramFont);
  lh=ParFmt.minHeight;
  GetPosition(p,&r);
  ColorSet(wcd->Foreground);
  ClipRect(&r);
  InvertColors();
  PaintRect(&r);
  InvertColors();
  ColorSet(wcd->Foreground);
#if MYSWITCH
  prec=(int)SwitchGetValue(layout->Precision);
#else
  prec=(int)GetValue(layout->Precision);
#endif
  align=GetStatus(layout->JustRight);
  sscanf(Text[DBSIZES],"%*i,(%i,%*i)",&lines);
  if (GetStatus(layout->Heading)) {
    MoveTo(r.left,r.top+=lh);
    lp1=(prec+3)/2; rp1=lp1; if ((prec+3)&1) lp1++;
    lp2=(prec-2)/2; rp2=lp2; if ((prec-2)&1) lp2++;
    if (rp2<0) rp2=0;
    if (lp2<0) lp2=0;
    PaintText("|%*s%*.*s|%*s%*.*s|",
		lp1+1,"x",rp1,rp1,"",
		lp2+6,"log(x)",rp2,rp2,"");
  }
  for (i=0,x=0.12345678910111213; i<lines; i++, x+=0.1111111111111111) {
    MoveTo(r.left,r.top+=lh);
    PaintText("|%s% #*.*g%s|%s% #*.*g%s|%s",
		align?" ":"",prec+3,prec,x,align?"":" ",
		align?" ":"",prec+3,prec,log(x),align?"":" ",
		GetStatus(layout->MarkSpecial)&&i==1?"SP":"");
  }

}

/* Precision callback */
#if _WIN
#pragma argsused
#endif
#if MYSWITCH
Callback(void) PrecisionProc(GraphiC sw, Int2 new, Int2 old) {
#else
Callback(void) PrecisionProc(SwitcH sw, Int2 new, Int2 old) {
#endif
  LayoutDataPtr layout=GetLayoutDataC(sw);
  Redraw(layout->Sample);
}

/* Align and Title callbacks */
Callback(void) ToggleProc(ButtoN bt) {
  LayoutDataPtr layout=GetLayoutDataC(bt);
  Redraw(layout->Sample);
}

/* NamesList callback */
Callback(void) NamesListProc(LisT l, Int2 var) {
  LayoutDataPtr layout=GetLayoutDataC(l);
  CharPtr p;
  CharPtr t;
  CharPtr PNTR pn;
  size_t len;
  Int2 b,e;
  pn=(CharPtr PNTR)GetObjectExtra(l);
  p=StringSave(pn[var-1]);	/* name to insert */
  len=TextLength(layout->ExprList)+StrLen(p)+1;
  t=MemNew(len);
  GetTitle(layout->ExprList,t,len);
  TextSelectionRange(layout->ExprList,&b,&e);
  if (b>0)
    if (t[b-1]!=',') {t=StrInsert(t,b,","); b++;}
  t=StrInsert(t,b,p);
  SetTitle(layout->ExprList,t);
  len=b+StrLen(p);
  SelectText(layout->ExprList,(Int2)len,(Int2)len);
  MemFree(t);
  MemFree(p);
  layout->Recompile=TRUE;
}

/* Menu callback */
#if _WIN
#pragma argsused
#endif
Callback(void) lLayout(Int2 indx) {
  WinComDataPtr wcd=GetComDataI;
  TabDataPtr td=(TabDataPtr)wcd->Private;
  LayoutDataPtr layout;
  WindoW db;
  GrouP MainGroup,g,gT,gg,gO,gOO,gON;
  LisT list;
  RecT rp,rg,rs;
  int TextLen,ListLines,LineLen;
  Char buf[10];
  layout=MemNew(sizeof(LayoutData));
  layout->Com=wcd;
  LockMenus();	/* will not wait */
  PushContext(HK_LAYOUTWIN,NULL,Text[WAITATTR_C]);
  db=FixedWindow(-50,-50,-sysCharWidth,-sysLineHeight,Text[BOX_TITLE],NULL);
  SetWindowExtra(db,layout,NULL);
  MainGroup=InitLargeWindow(db);
  SetGroupSpacing(MainGroup,0,sysLineHeight/2);
  SetGroupMargins(MainGroup,0,0);
  sscanf(Text[DBSIZES],"%i,(%i,%i)",&TextLen,&ListLines,&LineLen);
    g=CreateHiddenGroup(MainGroup,0,10,1);
      gT=CreateHiddenGroup(g,2,0,0);
        StaticPrompt(gT,Text[WINTITLE_P],0,dialogTextHeight,NULL,'l');
	layout->Title=DialogText(gT,wcd->WinTitle,1,NULL);
      gg=CreateHiddenGroup(g,2,0,0);
	StaticPrompt(gg,Text[EXPR_P],0,dialogTextHeight,NULL,'l');
	layout->ExprList=DialogText(gg,"",TextLen,RecordChange);
	SetTitle(layout->ExprList,td->ExprList);
      gON=CreateHiddenGroup(g,2,0,0);
	gO=CreateNormalGroup(gON,0,2,Text[OPTIONS_T]);
	  gOO=CreateHiddenGroup(gO,2,0,1);
	    StaticPrompt(gOO,Text[NLINES_P],0,dialogTextHeight,NULL,'l');
	    sprintf(buf,"%i",td->MaxLines);
	    layout->Lines=DialogText(gOO,buf,5,NULL);
#if MYSWITCH
	    StaticPrompt(gOO,Text[PRECISION_P],0,SwitchHeight(),NULL,'l');
	    layout->Precision=SwitchCreate(gOO,10,PrecisionProc);
	    SwitchSetParams(layout->Precision,td->Precision,DBL_DIG);
#else
	    StaticPrompt(gOO,Text[PRECISION_P],0,dialogTextHeight,NULL,'l');
	    layout->Precision=LeftRightSwitch(gOO,TRUE,PrecisionProc);
	    SetSwitchParams(layout->Precision,td->Precision,DBL_DIG);
#endif
	  gOO=CreateHiddenGroup(gO,0,3,1);
	    layout->Heading=CheckBox(gOO,Text[SHOWTITLE_B],ToggleProc);
	    SetStatus(layout->Heading,td->Heading);
	    layout->JustRight=CheckBox(gOO,Text[ALIGNRIGHT_B],ToggleProc);
	    SetStatus(layout->JustRight,td->JustRight);
	    layout->MarkSpecial=CheckBox(gOO,Text[POINTTYPE_B],ToggleProc);
	    SetStatus(layout->MarkSpecial,td->MarkSpecial);
	list=CreateNamesList(gON,LineLen,ListLines,NamesListProc,NULL);
      gg=CreateNormalGroup(g,0,0,Text[SAMPLE_WIN]);
	layout->Sample=SimplePanel(gg,1,ListLines*ParFmt.minHeight,DrawSample);
	/* extend panel */
        GetPosition(list,&rp);
	GetPosition(Parent(list),&rs);
	rs.right-=rp.right;	/* margins in a group */
	GetPosition(layout->Sample,&rp);
	GetPosition(Parent(layout->Sample),&rg);
	rp.right=rg.right-rs.right;
	SetPosition(layout->Sample,&rp);
      AlignObjects(ALIGN_RIGHT,(HANDLE)gg,(HANDLE)layout->ExprList,
		  (HANDLE)Parent(list),(HANDLE)layout->Title,NULL);
      AlignObjects(ALIGN_LOWER,(HANDLE)gO,(HANDLE)Parent(list),NULL);
  TerminalButtons((WindoW)MainGroup,MainGroup,LayoutOk,LayoutCancel,LayoutHelp);
  ShowLargeWindow(MainGroup);
  SelectText(layout->ExprList,32000,32000);
}

/*------------------------------------*/
/* Menu callback: Hardcopy dialog box */

typedef struct {
  WindoW ParentWin;
  TexT File;		/* 'File name' prompt */
  GrouP Copy;		/* copy Current/All curve(s) */
} HardcopyData, PNTR HardcopyDataPtr;

Callback(void) HardcopyCancel(ButtoN b) {
  WindoW optwin;
  HardcopyDataPtr data;
  optwin=ParentWindow(b);
  data=(HardcopyDataPtr)GetWindowExtra(optwin);
  Select(data->ParentWin);
  MemFree(data);
  Remove(optwin);
  UnlockMenus();
  PopContext();
}

Callback(void) HardcopyOk(ButtoN b) {
  WindoW optwin;
  HardcopyDataPtr data;
  WinComDataPtr wcd;
  TabDataPtr td;
  int n;
  Char buf[PATH_MAX+100];
  optwin=ParentWindow(b);
  data=(HardcopyDataPtr)GetWindowExtra(optwin);
  wcd=(WinComDataPtr)GetWindowExtra(data->ParentWin);
  td=(TabDataPtr)wcd->Private;
  Hide(optwin);
  /* file name */
  GetTitle(data->File,buf,PATH_MAX);
  td->HardFile=fopen(buf,"wt");
  if (!td->HardFile) Warning("HC_OPEN",buf);
  /* copy current/all curve(s) */
  n=GetValue(data->Copy);
  td->HardDiagram=n==2;
  sprintf(buf+StrLen(buf)," %i",n);
  /* Save current settings */
  SetParam(SECTION,"HARDCOPY",buf);
  /* Create ASCII file */
  if (td->HardFile) {
    td->Hardcopy=TRUE;
    if (td->HardDiagram) {	/* all curves */
      RedrawDiagram(0);
    } else {	/* 1 - curren curve */
      FilePtr fp;
      fp=DiagramLib.CurDirPtr;
      DiagramLib.CurDirPtr=DiagramLib.SelectedDirPtr;
      RedrawCurve(0);
      DiagramLib.CurDirPtr=fp;
    }
    td->Hardcopy=FALSE;
    fclose(td->HardFile);
  }
  HardcopyCancel(b);
}

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

Callback(void) HardcopyOutFile(ButtoN b) {
  WindoW optwin;
  HardcopyDataPtr data;
  Char def[PATH_MAX],file[PATH_MAX];
  optwin=ParentWindow(b);
  data=(HardcopyDataPtr)GetWindowExtra(optwin);
  GetTitle(data->File,def,sizeof(def));
  *file='\0';
  if (GetOutputFileName(file,sizeof(file),def))
    SetTitle(data->File,file);
}

#if _WIN
#pragma argsused
#endif
Callback(void) lHardCopy(Int2 indx) {
  WindoW optwin;
  HardcopyDataPtr data;
  GrouP gFile;
  CharPtr p,Par;
  int pos,n;
  ButtoN bt;
  LockMenus();	/* lock second time because otherwise it would be unlocked
		   after return from here */
  data=MemNew(sizeof(HardcopyData));
  data->ParentWin=CurrentWindow();
  optwin=FixedWindow(-50,-50,-sysCharWidth,-sysLineHeight,
		     Text[HARDCOPY_T],NULL);
  SetWindowExtra(optwin,data,NULL);
  /* Create controls */
  gFile=CreateNormalGroup(optwin,2,0,Text[HCFILE_G]);
  SetGroupSpacing(gFile,sysCharWidth,0);
  SetGroupMargins(gFile,sysCharWidth,sysLineHeight/2);
  sscanf(Text[DBSIZES],"%i",&n);
  data->File=DialogText(gFile,"",(Int2)n,NULL);
  PushButton(gFile,Text[FILELIST_B],HardcopyOutFile);
  data->Copy=CreateNormalGroup(optwin,0,2,Text[HCCOPY_G]);
  bt=RadioButton(data->Copy,Text[HCTACTIVE_B]);
  RadioButton(data->Copy,Text[HCTALL_B]);
  /* and set default values: */
  Par=GetParamString(SECTION,"HARDCOPY");
  /* - file name */
  StrTrim(Par);
  p=StrChr(Par,' ');
  if (p) *p++='\0';
  SetTitle(data->File,Par);
  StrCpy(Par,p);
  /* - copy current/all */
  sscanf(Par," %i%n",&n,&pos);
  if (DiagramLib.SelectedDirPtr==0) {
    Disable(bt);
    n=2;
  }
  SetValue(data->Copy,n);
  StrCpy(Par,Par+pos);
  /* Align */
  AlignObjects(ALIGN_RIGHT,(HANDLE)gFile,(HANDLE)data->Copy,NULL);
  PushContext(HK_HARDCOPYWIN,NULL,Text[HARDCOPY_C]);
  TerminalButtons(optwin,gFile,HardcopyOk,HardcopyCancel,HardcopyHelp);
  Show(optwin);
  SelectText(data->File,0,0);
}

/*----------------*/
/* Help callbacks */

#if _WIN
#pragma argsused
#endif
Callback(void) lHelp(Int2 indx) {
  Help(HK_TABLEWIN);
}

#if _WIN
#pragma argsused
#endif
Callback(void) lHelpSearch(Int2 indx) {
  HelpSearch(HK_TABLEWIN);
}