/* 
   Everything related to representation of special points
*/

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

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

enum {		/* see setup.c, init[], /point */
  OPT_C,		/* Waiting for attributes changing */
  POINT_I,		/* Special points */
  TYPE_P,		/* Set options for points of type */
  LABEL_B,		/* Label */
  MARKER_B,		/* marker */
  SETCOLOR_B,		/* Set color */
  DEFCOLOR_B,		/* Default color */
  SAMPLE_T,		/* Sample */
  SCALE_T		/* Scale factor */
} PointTxtIndex;

#define SIDE	9	/* canonical size of a marker is SIDExSIDE */
#define HALF	(SIDE/2)

/***********************/
/* List of curve types */
/***********************/

typedef struct {
  CharPtr title;	/* full name */
  CharPtr label;	/* short label */
  Int2 type;		/* code */
  Color color;		/* -1 - default */
  Int1 marker;		/* -1 - default */
  Boolean labelyes;	/* FALSE - no label */
} SPType, PNTR SPTypePtr;

Local(Int2) SPTypeNum=0;
Local(SPTypePtr) SPTypes=NULL;

/* Returns label and color for special points */
Global(Boolean) GetSPAttr(Int2 type, CharPtr PNTR Label, ColorPtr Color) {
  Int2 i;
  for (i=0; i<SPTypeNum; i++)
    if (SPTypes[i].type==type) {
      if (Color) *Color=SPTypes[i].color;
      if (Label) *Label=SPTypes[i].labelyes ? SPTypes[i].label : "";
      return TRUE;
    }
  return FALSE;
}

/* EnumSpecialPoints callback creates SPTypes list */
Local(void) AddToListProc(CharPtr Title, CharPtr Label, Int2 Type) {
  if (SPTypeNum) {
    SPTypes=_MemMore(SPTypes,ARRAYSIZE(SPType,SPTypeNum+1));
  } else {
    SPTypes=_MemNew(sizeof(SPType));
  }
  SPTypes[SPTypeNum].title=Title;
  SPTypes[SPTypeNum].label=Label;
  SPTypes[SPTypeNum].type=Type;
  SPTypes[SPTypeNum].marker=-1;
  SPTypes[SPTypeNum].color=-1;
  SPTypes[SPTypeNum].labelyes=FALSE;
  SPTypeNum++;
}


/***********/
/* Markers */
/***********/

/* A list of markers available */
Local(CharPtr) PNTR Marker=NULL;
Local(Int2) MarkerNum;

Local(Int1) Scale=0;	/* current index to scale array */

/* Reads descriptions of markers */
Global(void) ReadMarkers(Int2 num) {
  Char buf[100];
  Int2 i;
  MarkerNum=num;
  if (num) {
    Marker=_MemNew(ARRAYSIZE(CharPtr,num));
    for (i=0; i<MarkerNum; i++) {
      GetLine(buf);
      StrTrim(buf);
      Marker[i]=_StringSave(buf);
    }
  }
  EnumSpecialPoints(AddToListProc);
}

/* Frees memory associated with markers */
Global(void) FreeMarkers(void) {
  Int2 i;
  if (Marker) {
    for (i=0; i<MarkerNum; i++)
      _MemFree(Marker[i]);
    _MemFree(Marker);
  }
  SPTypeNum=0;
  SPTypes=_MemFree(SPTypes);
}

Local(FloatLo) scale[]={
  0,	/* ignored */
  0.5,
  0.75,
  1.0,
  1.25,
  1.5,
  1.75
};

/* Is a point 'near' a special point? */
Global(Boolean) PtNearSpecial(PoinT pt, PoinT sppt) {
  RecT r;
  Int2 off=HALF*scale[Scale];
  LoadRect(&r,sppt.x-off,sppt.y-off,sppt.x+off,sppt.y+off);
  return PtInRect(pt,&r);
}

/* Draw marker using current position, color and pen */
/* # in following comments denote a digit (1-9) -
   the number of units (in general, unit!=pixel) */
/*
   Marker description is a string of commands.
   Commands:
	c#
	C#
	s#
	S#
	l#u#
	l#d#
	r#u#
	r#d#
	p#...
	P#...
   ... denotes a sequence of l#u#,l#d#,r#u#,r#d# commands.
*/

#define ScaleAndRound(x) ((Int1)((x)*Scale[scale]))	/* to the nearest integer */

Local(PoinT) Poly[30];

Local(void) DrawMarker(Int2 num) {
  CharPtr p;
  RecT r;
  PoinT pt;
  Int1 i,n,ns,n1;
  Char c,c1;
  GetPen(&pt);
  if (num>=0 && num<MarkerNum) {
    for (p=Marker[num]; *p; ) {
      c=*p++;
      n=ScaleAndRound(ns=*p++-'0');
      switch (c) {
	case 'c':	/* c# - frame a circle with radius # */
	case 'C':	/* C# - paint (i.e. fill in) a circle with radius # */
	  r.left=pt.x-n;
	  r.right=pt.x+n+1;
	  r.bottom=pt.y+n+1;
	  r.top=pt.y-n;
	  if (c=='c') lInvertColors();
	  lPaintOval(&r);
	  if (c=='c') lInvertColors();
	  lFrameOval(&r);
	  break;
	case 's':	/* s# - frame a square */
	case 'S':	/* S# - paint a square */
	  LoadPt(Poly+0,pt.x-n,pt.y-n);
	  LoadPt(Poly+1,pt.x+n,pt.y-n);
	  LoadPt(Poly+2,pt.x+n,pt.y+n);
	  LoadPt(Poly+3,pt.x-n,pt.y+n);
	  if (c=='s') lInvertColors();
	  lPaintPoly(4,Poly);
	  if (c=='s') lInvertColors();
	  lFramePoly(4,Poly);
	  break;
	case 'l':	/* l# - move # pixels leftwards */
	  pt.x-=n;
	 ud:
	  c1=*p++;
	  n1=ScaleAndRound(*p++-'0');
	  if (c1=='u') pt.y-=n1;
	  if (c1=='d') pt.y+=n1;
	  SetPen(pt);
	  break;
	case 'r':	/* r# - move # pixels rightwards */
	  pt.x+=n;
	  goto ud;
	case 'p':	/* p#... P#... - frame/paint poligon consisting */
	case 'P':	/*  from # points; ... is a sequence of l/r */
			/* does not change current position */
	  Poly[0]=pt;
	  for (i=0; i<ns; i++) {
	    c1=*p++;
	    n1=ScaleAndRound(*p++-'0');
	    switch (c1) {
	      case 'l':	/* l# - move leftwards */
		Poly[i].x-=n1;
	       ud1:
		c1=*p++;
		n1=(Int1)((*p++-'0')*scale[Scale]);
		if (c1=='u') Poly[i].y-=n1;
		if (c1=='d') Poly[i].y+=n1;
		break;
	      case 'r':	/* r# - move rightwards */
		Poly[i].x+=n1;
		goto ud1;
	    }
	    Poly[i+1]=Poly[i];
	  }
	  if (c=='p') lInvertColors();
	  lPaintPoly(ns,Poly);
	  if (c=='p') lInvertColors();
	  lFramePoly(ns,Poly);
	  break;
      }
    }
  }
}

Local(FloatHi) dx,dy;	/* ix-ipx and iy-ipy (used to draw label) */
Local(Boolean) pb=FALSE;

Global(void) SpecialPointPrev(Int2 idX, Int2 idY,
			      FloatHi fdX, FloatHi fdY,
			      FloatHi deltaX, FloatHi deltaY) {
  dx=idX;
  dy=idY;
  if (idX*idY==0) {
    dx=fdX*deltaX;
    dy=fdY*deltaY;
  }
  pb=TRUE;
}

Global(Boolean) IsMarker(Int2 pointtype) {
  Int2 i;
  for (i=0; i<SPTypeNum; i++)
    if (SPTypes[i].type==pointtype)
      return SPTypes[i].marker>=0 || (pb && SPTypes[i].labelyes);
  return FALSE;
}

/* Hardcopy data (see llString & STRMARKER in visual.c) */
Local(float) Q1[6]={ 0.25, 0.25, 0, 0, HALF, HALF};
Local(float) Q2[6]={-0.25, 0.25,-1, 0,-HALF, HALF};
Local(float) Q3[6]={-0.25,-0.25,-1,-1,-HALF,-HALF};
Local(float) Q4[6]={ 0.25,-0.25, 0,-1, HALF,-HALF};

/* Draws Special Point using its current attributes */
Global(void) DrawSpecialPoint(Int2 x, Int2 y, Int2 pointtype, Color bg, Boolean labelyes) {
  CharPtr lp;
  Int2 i,w,h;
  Int2 off,lx,ly;
  float PNTR Qp;
  DrawAttr attr;
  for (i=0; i<SPTypeNum; i++)
    if (SPTypes[i].type==pointtype) {
      ColorSet(attr.color=SPTypes[i].color);
      if (SPTypes[i].marker>=0 || SPTypes[i].labelyes) {
	if (SPTypes[i].marker>=0) {
	  InvertColors();
	  ColorSet(bg);
	  InvertColors();
	  lMoveTo(x,y);
	  attr.style=1;
	  attr.width=1;
	  SetCurrentPen(&attr);
	  DrawMarker(SPTypes[i].marker);
	}
	/* Label */
	if (pb && SPTypes[i].labelyes && labelyes) {
	  lp=ccd.localpointType&USERPOINT ?
	     GetSPname(ccd.localpointType,FALSE) :
	     SPTypes[i].label;
	  h=LineHeight()-Descent();
	  w=StringWidth(lp)+2;
	  off=HALF*scale[Scale]+1;	/* canonical size of marker is 9x9 */
	  if (dx*dy<0) {		/* [0,90]+[180,270] */
	    if (dx>-dy) {		/* [0,45]+[225,270] */
	      lx=x-off-w;
	      ly=y-off;
	      Qp=Q2;
	    } else {			/* (45,90]+[180,225) */
	      lx=x+off;
	      ly=y+off+h;
	      Qp=Q4;
	    }
	  } else {			/* (90,180)+(270,360) */
	    if (dx>dy) {		/* (90,135]+[315,360) */
	      lx=x-off-w;
	      ly=y+off+h;
	      Qp=Q3;
	    } else {			/* (135,180)+(270,315) */
	      lx=x+off;
	      ly=y-off;
	      Qp=Q1;
	    }
	  }
	  llString(lx,ly,lp,Qp);
	}
	goto done;
      } else break;
    }
  lPoint(x,y);
 done:
  pb=FALSE;
}

Local(ButtoN) cbLabel;
Local(ButtoN) cbMarker;
Local(ButtoN) cbDefColor;
Local(ButtoN) btSetColor;
Local(PopuP) plTypes;		/* Names of special points */
Local(PaneL) paMarkers;		/* Markers */
Local(PaneL) paCurType;		/* name of current type */
Local(PaneL) paCurMarker;	/* panel with current marker */
Local(PaneL) paCurLabel;	/* current label */
Local(BaR) mbar;		/* marker panel's bar */
Local(Int2) CurType;		/* currently selected list item-1 */

Local(void) RedrawCurrent(void);

/* Type of special point callback */
/* 
   Note that index zero to SPTypes corresponds
   to ordinary points which aren't represented
   in plTypes list
*/
Local(void) TypeProc(PopuP pl) {
  CurType=GetValue(pl);
  RedrawCurrent();
}

/* Label yes/no callback */
Local(void) LabelProc(ButtoN b) {
  SPTypes[CurType].labelyes=GetStatus(b);
  RedrawCurrent();
}

/* Marker draw callback */
Local(void) MarkerDrawProc(PaneL marker) {
  RecT r,rr;
  PoinT pt;
  Int2 l,i,n,o;
  o=GetValue(mbar);
  Select(marker);
  GetPosition(marker,&r);
  l=r.bottom-r.top-1;
  n=(r.right-r.left)/l;
  rr.top=r.top+1;
  rr.bottom=r.bottom-1;
  if (o+n>=MarkerNum) n=MarkerNum-o;
  for (i=0; i<n; i++) {
    rr.left=r.left+i*l+1;
    rr.right=rr.left+l;
    FrameRect(&rr);
    pt.x=(rr.left+rr.right)>>1;
    pt.y=(rr.top+rr.bottom)>>1;
    SetPen(pt);
    DrawMarker(o+i);
  }
}

#if _WIN
#pragma argsused
#endif
/* Marker scroll calback */
Local(void) MarkerScrollProc(BaR bar, GraphiC g, Int2 new, Int2 old) {
  Redraw(paMarkers);
}

/* Marker selection callback */
Local(void) MarkerSelProc(PaneL marker, PoinT pt) {
  RecT r;
  Int2 l;
  Select(marker);
  GetPosition(marker,&r);
  l=r.bottom-r.top-1;
  SPTypes[CurType].marker=(pt.x-r.left)/l+GetValue(mbar);
  SetStatus(cbMarker,TRUE);
  RedrawCurrent();
}

/* Marker chechbox callback */
Local(void)  MarkerProc(ButtoN cb) {
  SPTypes[CurType].marker=GetStatus(cb) ? 0 : -1;
  RedrawCurrent();
}

Local(void) DefColorProc(ButtoN cb) {
  if (GetStatus(cb)) SPTypes[CurType].color=-1;
  else SPTypes[CurType].color=ColorAsk(SPTypes[CurType].color);
  RedrawCurrent();
}

#if _WIN
#pragma argsused
#endif
Local(void) ColorProc(ButtoN bt) {
  SPTypes[CurType].color=ColorAsk(SPTypes[CurType].color);
  SetStatus(cbDefColor,FALSE);
  RedrawCurrent();
}

Local(void) ScaleProc(GrouP gScale) {
  Scale=GetValue(gScale);
  Redraw(paMarkers);
  RedrawCurrent();
}

Local(void) PrepRect(PaneL p, RectPtr r) {
  Int2 h;
  Select(p);
  SelectFont(SystemFont);
  GetPosition(p,r);
  h=(r->bottom-r->top)>>1;
  r->top+=h-((sysAscent>>1)+sysLeading);
  r->bottom-=h-((sysAscent>>1)+sysDescent);
}

Local(void) CurTypeProc(PaneL paCurType) {
  RecT r;
  PrepRect(paCurType,&r);
  DrawString(&r,SPTypes[CurType].title,'l',FALSE);
}

Local(void) CurMarkerProc(PaneL paCurMarker) {
  RecT r;
  PoinT pt;
  Select(paCurMarker);
  GetPosition(paCurMarker,&r);
  ColorSet(SPTypes[CurType].color);
  InvertColors();
  PaintRect(&r);
  InvertColors();
  if (SPTypes[CurType].marker>=0) {
    pt.x=(r.left+r.right)>>1;
    pt.y=(r.top+r.bottom)>>1;
    SetPen(pt);
    DrawMarker(SPTypes[CurType].marker);
  }
}

Local(void) CurLabelProc(PaneL paCurLabel) {
  RecT r;
  PrepRect(paCurLabel,&r);
  ColorSet(SPTypes[CurType].color);
  DrawString(&r,SPTypes[CurType].labelyes ?
			SPTypes[CurType].label : "",'l',FALSE);
}

/* Reads diagram related map type-marker-color-label;
   Otherwise [creates and] reads default map */
Global(void) ReadMarkerMap(void) {
  FloatLo sc=0;
  Int2 i,j,num;
  SPType sp;
  Int1 n;
  Boolean lib;
  if (CurDiagram) {
    DataLibSavePos(&DiagramLib);
    while (!DataLibUp(&DiagramLib));
    lib=DataLibFind(&DiagramLib,CURM_PART)==0;
    if (lib) {
      DataLibRead(&DiagramLib,(CharPtr)(&sc),
				sizeof(scale[0]));
      for (; DataLibRead(&DiagramLib,(CharPtr)&n,sizeof(n))==sizeof(n); ) {
	/* entry 0 is unused (ordinaty points) */
	DataLibRead(&DiagramLib,(CharPtr)&SPTypes[0].marker,
				sizeof(SPTypes[0].marker));
	DataLibRead(&DiagramLib,(CharPtr)&SPTypes[0].color,
				sizeof(SPTypes[0].color));
	DataLibRead(&DiagramLib,(CharPtr)&SPTypes[0].labelyes,
				sizeof(SPTypes[0].labelyes));
	for (i=0 ; i<SPTypeNum; i++)
	  if (n==SPTypes[i].type) {
	    SPTypes[i].marker=SPTypes[0].marker;
	    SPTypes[i].color=SPTypes[0].color;
	    SPTypes[i].labelyes=SPTypes[0].labelyes;
	    break;
	  }
      }
    }
    DataLibRestorePos(&DiagramLib);
    if (lib) goto set_scale;
  }
  lib=DataLibIsClosed(&ArchivesLib);
  if (lib) DataLibOpen(&ArchivesLib,ArchivesName);
  DataLibSavePos(&ArchivesLib);
  while (ArchivesLib.Depth>1) DataLibUp(&ArchivesLib);
  if (DataLibFind(&ArchivesLib,PART_DEFM)==0) {
    DataLibRead(&ArchivesLib,(CharPtr)&sc,sizeof(sc));
    DataLibRead(&ArchivesLib,(CharPtr)&num,sizeof(num));
    for (i=0; i<num; i++) {
      DataLibRead(&ArchivesLib,(CharPtr)&sp.type,sizeof(sp.type));
      DataLibRead(&ArchivesLib,(CharPtr)&sp.marker,sizeof(sp.marker));
      DataLibRead(&ArchivesLib,(CharPtr)&sp.color,sizeof(sp.color));
      DataLibRead(&ArchivesLib,(CharPtr)&sp.labelyes,sizeof(sp.labelyes));
      for (j=0; j<SPTypeNum; j++)
	if (SPTypes[j].type==sp.type) {
	  SPTypes[j].marker=sp.marker;
	  SPTypes[j].color=sp.color;
	  SPTypes[j].labelyes=sp.labelyes;
	  break;
	}
    }
  } else {	/* Build default */
    sc=1.0;
    for (i=0; i<SPTypeNum; i++) {
      SPTypes[i].marker=0;	/* first marker */
      SPTypes[i].color=-1;	/* defaul color (as a curve) */
      SPTypes[i].labelyes=TRUE;
    }
  }
  DataLibRestorePos(&ArchivesLib);
  if (lib) DataLibClose(&ArchivesLib);
 set_scale:
  if (sc<=0) sc=1;
  for (Scale=1; Scale<DIM(scale) ; Scale++)
    if (sc==scale[Scale]) break;
}

/* Writes default map type-marker-color-label */
Local(void) WriteMap(void) {
  Int2 i;
  Int1 n;
  if (CurDiagram) {
    DataLibSavePos(&DiagramLib);
    while (!DataLibUp(&DiagramLib));
    DataLibDeletePartitions(&DiagramLib,CURM_PART,NULL);
    DataLibCreate(&DiagramLib,CURM_PART);
    DataLibWrite(&DiagramLib,(CharPtr)(scale+Scale),
				sizeof(scale[0]));
    for (i=0; i<SPTypeNum; i++) {
      n=SPTypes[i].type;
      DataLibWrite(&DiagramLib,(CharPtr)&n,sizeof(n));
      DataLibWrite(&DiagramLib,(CharPtr)&SPTypes[i].marker,
			     sizeof(SPTypes[i].marker));
      DataLibWrite(&DiagramLib,(CharPtr)&SPTypes[i].color,
			     sizeof(SPTypes[i].color));
      DataLibWrite(&DiagramLib,(CharPtr)&SPTypes[i].labelyes,
			     sizeof(SPTypes[i].labelyes));
    }
    DataLibRestorePos(&DiagramLib);
  }
  DataLibOpen(&ArchivesLib,ArchivesName);
  DataLibSavePos(&ArchivesLib);
  while (ArchivesLib.Depth>1) DataLibUp(&ArchivesLib);
  if (DataLibFind(&ArchivesLib,PART_DEFM)==0)
    DataLibDelete(&ArchivesLib);
  DataLibCreate(&ArchivesLib,PART_DEFM);
  DataLibWrite(&ArchivesLib,(CharPtr)&scale[Scale],sizeof(scale[Scale]));
  DataLibWrite(&ArchivesLib,(CharPtr)&SPTypeNum,sizeof(SPTypeNum));
  for (i=0; i<SPTypeNum; i++) {
    DataLibWrite(&ArchivesLib,(CharPtr)&SPTypes[i].type,sizeof(SPTypes[i].type));
    DataLibWrite(&ArchivesLib,(CharPtr)&SPTypes[i].marker,sizeof(SPTypes[i].marker));
    DataLibWrite(&ArchivesLib,(CharPtr)&SPTypes[i].color,sizeof(SPTypes[i].color));
    DataLibWrite(&ArchivesLib,(CharPtr)&SPTypes[i].labelyes,sizeof(SPTypes[i].labelyes));
  }
  DataLibRestorePos(&ArchivesLib);
  DataLibClose(&ArchivesLib);
}

/* Terminal buttons */

Local(WindoW) parent;

Local(void) PointCancelProc(ButtoN b) {
  ReadMarkerMap();	/* restore from dl/defaults */
  Select(parent);
  Remove(ParentWindow(b));
  UnlockAll();
  PopContext();
}

Local(void) PointOkProc(ButtoN b) {
  WriteMap();
  Select(parent);
  Remove(ParentWindow(b));
  UnlockAll();
  PopContext();
}

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

/* Redraws the current settings */
Local(void) RedrawCurrent(void) {
  SetStatus(cbLabel,SPTypes[CurType].labelyes);
  SetStatus(cbMarker,SPTypes[CurType].marker!=-1);
  SetStatus(cbDefColor,SPTypes[CurType].color==-1);
  if (GetStatus(cbLabel) || GetStatus(cbMarker)) {
    Enable(cbDefColor);
    Enable(btSetColor);
  } else {
    Disable(cbDefColor);
    Disable(btSetColor);
  }
  Redraw(paCurMarker);
  Redraw(paCurLabel);
  Redraw(paCurType);
}

#if _WIN
#pragma argsused
#endif
/* Sets options of special points */
Global(void) PointOptProc(Int2 index) {
  WindoW optwin;
  GrouP g0,g,gg;
  RecT r;
  PoinT pt;
  Int2 num,i;
  Int2 SampleWidth;
  Char buf[10];
  LockAll();	/* lock second time because otherwise it would be unlocked
		   immediatedly after return */
  parent=CurrentWindow();
  /* Create controls */
  optwin=FixedWindow(-50,-50,-sysCharWidth,-sysCharWidth,
		     PointTxt[POINT_I],NULL);
  g0=HiddenGroup(optwin,0,10,NULL);
  SetGroupMargins(g0,0,0);
  SetGroupSpacing(g0,0,sysLineHeight);
  g=HiddenGroup(g0,2,0,NULL);
    StaticPrompt(g,PointTxt[TYPE_P],0,popupMenuHeight,NULL,'l');
    plTypes=PopupList(g,FALSE,TypeProc);
    SampleWidth=4;
    CurType=0;
    for (i=1; i<SPTypeNum; i++) {	/* ignore 'orbit' */
      PopupItem(plTypes,SPTypes[i].title);
      if (SampleWidth<StringWidth(SPTypes[i].title))
	SampleWidth=StringWidth(SPTypes[i].title);
      CurType=1;
    }
    SetValue(plTypes,CurType);
  gg=HiddenGroup(g0,4,0,NULL);
    SetGroupSpacing(gg,sysCharWidth,0);
    cbLabel=CheckBox(gg,PointTxt[LABEL_B],LabelProc);
    cbMarker=CheckBox(gg,PointTxt[MARKER_B],MarkerProc);
    cbDefColor=CheckBox(gg,PointTxt[DEFCOLOR_B],DefColorProc);
    btSetColor=PushButton(gg,PointTxt[SETCOLOR_B],ColorProc);
  GetPosition(g0,&r);
  paMarkers=SimplePanel(g0,r.right-r.left,2*FontHeight(),MarkerDrawProc);
  SetPanelClick(paMarkers,MarkerSelProc,NULL,NULL,NULL);
  GetNextPosition(g0,&pt);
  pt.y-=sysLineHeight;
  SetNextPosition(g0,pt);
  mbar=ScrollBar(g0,1,0,MarkerScrollProc);
  num=MarkerNum-((r.right-r.left)/(2*FontHeight()));
  SetRange(mbar,1,1,num);
  SetValue(mbar,0);
  g=NormalGroup(g0,3,0,PointTxt[SAMPLE_T],SystemFont,NULL);
    paCurType=SimplePanel(g,SampleWidth,dialogTextHeight,CurTypeProc);
    paCurMarker=SimplePanel(g,2*sysCharWidth,dialogTextHeight,CurMarkerProc);
    paCurLabel=SimplePanel(g,5*sysCharWidth,dialogTextHeight,CurLabelProc);
  g=NormalGroup(g0,DIM(scale),0,PointTxt[SCALE_T],
		SystemFont,ScaleProc);
  SetGroupSpacing(g,sysCharWidth,0);
  for (i=1; i<DIM(scale); i++) {
    sprintf(buf,"%g",scale[i]);
    RadioButton(g,buf);
    if (!Scale && scale[i]==1.0) Scale=(Int1)i;
  }
  SetValue(g,Scale);
  RedrawCurrent();
  PushContext(HLP_POINTOPT,NULL,PointTxt[OPT_C]);
  /* Create terminal buttons group */
  TermButtons(g0,g0,PointOkProc,PointCancelProc,PointHelpProc);
  Show(optwin);
}

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


/*****************/
/* Export/Import */
/*****************/

Global(void) ExportMarkers(DataLibPtr dgm, FILE PNTR out) {
  Int1 n;
  DataLibRead(dgm,(CharPtr)(scale+0),sizeof(scale[0]));
  fprintf(out,"   %g\n",scale[0]);
  for (; DataLibRead(dgm,(CharPtr)&n,sizeof(n))==sizeof(n); ) {
    /* entry 0 is unused (ordinaty points) */
    DataLibRead(dgm,(CharPtr)&SPTypes[0].marker,sizeof(SPTypes[0].marker));
    DataLibRead(dgm,(CharPtr)&SPTypes[0].color,sizeof(SPTypes[0].color));
    DataLibRead(dgm,(CharPtr)&SPTypes[0].labelyes,sizeof(SPTypes[0].labelyes));
    fprintf(out,"   %i %i %li %i\n",(int)n,			/* type */
			   (int)SPTypes[0].marker,
			   ColorOut(SPTypes[0].color),
			   (int)SPTypes[0].labelyes);
  }
  fprintf(out,"   -1\n");
}

Global(void) ImportMarkers(DataLibPtr dgm, FILE PNTR in) {
  long rgb;
  int i,l;
  Int1 n;
  fscanf(in,"   %g\n",scale+0);
  DataLibWrite(dgm,(CharPtr)(scale+0),sizeof(scale[0]));
  while (fscanf(in," %i ",&i)==1 && i>=0) {
    n=(Int1)i;
    fscanf(in," %i %li %i\n",&i,&rgb,&l);
    /* entry 0 is unused (ordinaty points) */
    SPTypes[0].marker=(Int1)i;
    SPTypes[0].color=ColorIn(rgb);
    SPTypes[0].labelyes=(Boolean)l;
    DataLibWrite(dgm,(CharPtr)&n,sizeof(n));
    DataLibWrite(dgm,(CharPtr)&SPTypes[0].marker,sizeof(SPTypes[0].marker));
    DataLibWrite(dgm,(CharPtr)&SPTypes[0].color,sizeof(SPTypes[0].color));
    DataLibWrite(dgm,(CharPtr)&SPTypes[0].labelyes,sizeof(SPTypes[0].labelyes));
  }
}