/*->$.Q.!OvnPro.Library.!MenuLib */

int tick;

/****************************************************************/

int main_handle;

int main_flags(int entry,string & text)
{
 switch(entry)
 {
  case 3:
         text=content_name();
         break;
 }
 return(0);
}

int main_menu(int open)
{
 return(main_handle);
}

/****************************************************************/

int file_handle;

int file_entry(int entry,int subcode)
{
 switch(entry)
 {
  case 0:
         open_menu(fileinfo_box(1));
         break;
  case 1:
         if(subcode==-2) open_menu(savedocument_box(1));
         else
         if(subcode==-1) savedocument("");
         break;
 

 }
 return(0);
}

int file_flags(int entry,string & text)
{
 switch(entry)
 {
  case 0:
         return(DOTTED);
         break;
  case 2:
         return(export_name(text)?0:SHADED);
         break;
  case 4:
         return((issaved() && ischanged())?DOTTED:SHADED|DOTTED);
         break;
  case 6:
         return(DOTTED);
         break;
 }
 return(0);
}

int file_menu(int open)
{
 return(file_handle);
}


/****************************************************************/

int edit_handle;

int edit_flags(int entry,string & text)
{
 int bits;
 int ctype;

 bits=SHADED;

 switch(entry)
 {
  case 0:
         text=text+" "+undostring();
         if(canundo()) bits=0;
         break;
  case 1:
         bits=SHADED | DOTTED;
         text=text+" "+redostring();
         if(canredo()) bits=DOTTED;
         break;
  case 2:
         text=text+" "+selection_name();
         if(cancopy() && candelete()) bits=0;
         break;
  case 3:
         text=text+" "+selection_name();
         if(cancopy()) bits=0;
         break;
  case 4:
         text=text+" "+paste_name();
         ctype=cliptype();
         if(ctype>=0 && ctype!=4) bits=0;
         break;
  case 5:
         text=text+" "+selection_name();
         if(candelete()) bits=0;
         break;
  case 6:
         bits=SHADED | DOTTED;
         if(cliptype()==0) bits=DOTTED;
         break;
  case 8:
         bits=SHADED | DOTTED;
         if(nselected()) bits=DOTTED;
         break;
  case 9:
         if(activetype(TEXTFRAME)>1) bits=0;
         break;
 }
 return(bits);
}

int edit_menu(int open)
{
 return(edit_handle);
}

/****************************************************************/

int view_handle;

int view_entry(int entry,int subcode)
{
 switch(entry)
 {
  case 1:
         if(subcode==-2) open_menu(view_box(1));
         break;
  case 2:
         if(subcode==-2) open_menu(grid_box(1));
         break;
  case 3:
         if(subcode==-2) open_menu(zoom_box(1));
         break;  
 }
 return(0);
}

int view_flags(int entry,string & text)
{
 switch(entry)
 {
  case 0:
         return(DOTTED);
         break;
 }
 return(0);
}

int view_menu(int open)
{
 return(view_handle);
}

/****************************************************************/

int text_handle;

int text_flags(int entry,string & text)
{
 int bits;

 bits=(activetype(TEXTFRAME)>1)?0:SHADED;

 switch(entry)
 {
  case 4:
         bits|=DOTTED;
         break;
 }
 return(bits);
}

int text_menu(int open)
{
 return(text_handle);
}

/****************************************************************/

int case_handle;

int case_entry(int entry,int subcode)
{
 setcase(entry);
 return(0);
}

int case_flags(int entry,string & text)
{
 return(entry==getcase());
}

int case_menu(int open)
{
 return(case_handle);
}


/****************************************************************/

int remeffx_handle;

int remeffx_entry(int entry,int subcode)
{
	int n;

	if(entry==0)
	{
  cleareffects(0);
	}
	else
	{
 	n=-1;
 	while(entry-->0) n=getnexteffect(n);
  cleareffect(n,0);
	}

 return(0);
}



int remeffx_flags(int entry,string & text)
{
	int bits;
	int n;

	bits=0;

	if(entry==0)
 {
  bits=DOTTED;
  n=getnexteffect(-1);
		if(n<0) bits|=SHADED;
	}

 return(bits);
}



int remeffx_menu(int open)
{
 string s;
	int    n;

 if(remeffx_handle) delete_menu(remeffx_handle);
 remeffx_handle=create_menu("{TM11}");

 addentry_menu(remeffx_handle,"remeffx_entry","remeffx_flags","","CS_L","{RMM03}");

	n=-1;

	while(1)
	{
  n=getnexteffect(n);
		if(n<0) break;
  geteffectname(n,s);
  addentryl_menu(remeffx_handle,"remeffx_entry","remeffx_flags","","",s);
	}

 return(remeffx_handle);
}






/****************************************************************/

int tint_handle;

int tint_entry(int entry,int subcode)
{
 int utint;

 utint=stoi(string_menu(tint_handle,entry));
 settint(utint);
 return(0);
}

int tint_flags(int entry,string & text)
{
 int tint;

 tint=gettint();

 switch(entry)
 {
  case 10:
          text=tick ? "" : itos(tint);
          return((8<<24)|(8<<16)|WRITEABLE|!tick);
          break;
  case  0:
          tick=0;
  default:
          if(tint==stoi(text)) return(tick=1);
          break;
 }
 return(0);         
}

int tint_menu(int open)
{
 return(tint_handle);
}

/****************************************************************/

int ulinewidth_handle;

int ulinewidth_entry(int entry,int subcode)
{
 switch(entry)
 {
  case 0:
         setulwidth("2%");
         break;
  case 1:
         setulwidth("4%");
         break;
  case 2:
         setulwidth("8%");
         break;
  case 3:
         setulwidth(string_menu(ulinewidth_handle,3));
         break;
 }
 return(0);
}

int ulinewidth_flags(int entry,string & text)
{
 string width;

 getulwidth(width);

 switch(entry)
 {
  case 0:
         tick=0;
         if(width=="2%") return(tick=1);
         break;
  case 1:
         if(width=="4%") return(tick=1);
         break;
  case 2:
         if(width=="8%") return(tick=1);
         break;
  case 3:
         text=tick ? "" : width;
         return((8<<24)|(8<<16)|WRITEABLE|!tick);
         break;
 }
 return(0);
}

void ulinename(string & width)
{
 if(width=="2%")  width="{UWM01}";
 else
 if(width=="4%")  width="{UWM02}";
 else
 if(width=="8%")  width="{UWM03}";
 translate(width);
}

int ulinewidth_menu(int open)
{
 return(ulinewidth_handle);
}

/****************************************************************/

int font_handle;
int font_subhandle;


int font_subentry(int entry,int subcode)
{
 return(entry);
}


int font_subflags(int entry,string & text)
{
 return(menuprevious(0)==getfont() && entry==getsubfont());
}


int font_submenu(int open)
{
 int    i;
 string s;
 int    previous;
                 
 previous=menuprevious(0);

 if(font_subhandle) delete_menu(font_subhandle);

 getfontname(previous,s);
 font_subhandle=create_menu(s);

 i=0;
 while(getfontsubname(previous,i++,0,s))
   addentryl_menu(font_subhandle,"font_subentry","font_subflags","","",s);

 return(font_subhandle);
}


int font_entry(int entry,int subcode)
{
 setsubfont(entry,subcode);
 return(0);
}

int font_flags(int entry,string & text)
{
 return(entry==getfont());
}


int font_menu(int open)
{
 int    i;
 int    sub;
 string s;
 string r;

 if(fontschanged() || !font_handle)
 {
  if(font_handle) delete_menu(font_handle);
  font_handle=create_menu("{FNM00}");
  i=0;
  while(getfontname(i,s))
  {
   sub=getfontsubname(i,1,0,r);
   addentryl_menu(font_handle,"font_entry","font_flags",sub?"font_submenu":"","",s);
   i++;
  }
 }
 return(font_handle);
}

int textfont_menu(int open)
{
 caretcontext();
 return(font_menu(open));
}

/****************************************************************/

int size_handle;
int usize0,usize1,usize2,usize3,usize4,usize5,usize6;

int size_entry(int entry,int subcode)
{
 int usize;

 switch(entry)
 {
  case 0:
         usize=usize0;
         break;
  case 1:
         usize=usize1;
         break;
  case 2:
         usize=usize2;
         break;
  case 3:
         usize=usize3;
         break;
  case 4:
         usize=usize4;
         break;
  case 5:
         usize=usize5;
         break;
  case 6:
         usize=usize6;
         break;
  case 7:
         usize=stringu(string_menu(size_handle,7),2);
         break;
 }
 setfontsize(usize);
 return(0);
}

int size_flags(int entry,string & text)
{
 int size;
 int usize;

 size=getfontsize();

 switch(entry)
 {
  case 0:
         tick=0;
         usize=usize0;
         break;
  case 1:
         usize=usize1;
         break;
  case 2:
         usize=usize2;
         break;
  case 3:
         usize=usize3;
         break;
  case 4:
         usize=usize4;
         break;
  case 5:
         usize=usize5;
         break;
  case 6:
         usize=usize6;
         break;
  case 7:
         usize=size;
         break;
 }
 if(entry == 7 && size == -1) tick = 1;
 text=(entry==7 && tick) ? "" : ustring(usize,2);

 if(entry==7) return((8<<24)|(8<<16)|WRITEABLE|!tick);
 if(usize==size) return(tick=1);
 return(0);
}

int size_menu(int open)
{
 return(size_handle);
}

/***************************************************************/

int effx_handle;

int effx_entry(int entry,int subcode)
{
 seteffect(1<<entry);
 return(0);
}

int effx_flags(int entry,string & text)
{
 return((geteffect() & (1<<entry))!=0);
}

int effx_menu(int open)
{
 return(effx_handle);
}

/****************************************************************/

int bullet_handle;
int bulletformat;

int bullet_entry(int entry,int subcode)
{
 switch(entry)
 {
  case 0:
  case 1:
  case 2:
  case 3:
  case 4:
  case 5:
  case 6:
         bulletformat&=~0xF;
         bulletformat|=entry;
         break;
  case 7:
  case 8:
  case 9:
         bulletformat&=~0xF0;
         bulletformat|=(entry-7)<<4;
         break;
 }
 setnumberformat(bulletformat);
 return(0);
}

int bullet_flags(int entry,string & text)
{
 int code;
 code=0;

 if(entry==0) bulletformat=getnumberformat();

 switch(entry)
 {
  case 6:
         code=DOTTED;
  case 0:
  case 1:
  case 2:
  case 3:
  case 4:
  case 5:
         code|=(bulletformat & 0xF)==entry;
         break;
  case 7:
  case 8:
  case 9:
         code=(bulletformat & 0xF0)==((entry-7)<<4);
         break;
 }
 return(code);
}

int bullet_menu(int open)
{
 return(bullet_handle);
}

/****************************************************************/

int userstyle_handle;

int userstyle_entry(int entry,int subcode)
{
 setuserstyle(entry);
 return(0);
}

int userstyle_flags(int entry,string & text)
{
 return(isuserstyle(entry));
}

int userstyle_menu(int open)
{
 int    i;
 string s;

 if(userstyle_handle) delete_menu(userstyle_handle);
 userstyle_handle=create_menu("{BSM00}");

 i=0;
 while(getuserstyle(i++,s,0))
  addentryl_menu(userstyle_handle,"userstyle_entry","userstyle_flags","","",s);

 return(userstyle_handle);
}

/****************************************************************/

int align_handle;

int align_entry(int entry,int subcode)
{
 setalign(entry);
 return(0);
}

int align_flags(int entry,string & text)
{
 return(entry==getalign());
}

int align_menu(int open)
{
 return(align_handle);
}

/****************************************************************/

int lead_handle;

int lead_entry(int entry,int subcode)
{
 switch(entry)
 {
  case 0:
         setleading("20%");
         break;
  case 1:
         setleading("120%");
         break;
  case 2:
         setleading(string_menu(lead_handle,2));
         break;
 }
 return(0);
}

int lead_flags(int entry,string & text)
{
 string s;

 getleading(s);

 switch(entry)
 {
  case 0:
         tick=0;
         if(s=="20%") return(tick=1);
         break;
  case 1:
         if(s=="120%") return(tick=1);
         break;
  case 2: 
         text=tick ? "" : s;
         return((8<<24)|(8<<16)|WRITEABLE|!tick);
         break;
 }
 return(0);
}

int lead_menu(int open)
{
 return(lead_handle);
}

/****************************************************************/

int rulewidth_handle;
int urwidth0,urwidth1,urwidth2,urwidth3,urwidth4,urwidth5;

int rulewidth_entry(int entry,int subcode)
{
 int uwidth;

 switch(entry)
 {
  case 0:
         uwidth=urwidth0;
         break;
  case 1:
         uwidth=urwidth1;
         break;
  case 2:
         uwidth=urwidth2;
         break;
  case 3:
         uwidth=urwidth3;
         break;
  case 4:
         uwidth=urwidth4;
         break;
  case 5:
         uwidth=urwidth5;
         break;
  case 6:
         uwidth=stringu(string_menu(rulewidth_handle,6),-1);
         break;
 }
 setrulewidth(uwidth);
 return(0);
}

int rulewidth_flags(int entry,string & text)
{
 int width;
 int uwidth;

 width=getrulewidth();

 switch(entry)
 {
  case 0:
         tick=0;
         uwidth=urwidth0;
         break;
  case 1:
         uwidth=urwidth1;
         break;
  case 2:
         uwidth=urwidth2;
         break;
  case 3:
         uwidth=urwidth3;
         break;
  case 4:
         uwidth=urwidth4;
         break;
  case 5:
         uwidth=urwidth5;
         break;
  case 6:
         uwidth=width;
         break;
 }
 if(uwidth || entry==6)
  text=ustring(uwidth,-1);
 else
 {
  text="{THIN}";
  translate(text);
 }
 if(entry==6 && tick) text="";

 if(entry==6) return((8<<24)|(8<<16)|WRITEABLE|!tick);
 if(uwidth==width) return(tick=1);
 return(0);        
}

int rulewidth_menu(int open)
{
 return(rulewidth_handle);
}

/****************************************************************/

int picture_handle;

int picture_menu(int open)
{
 return(picture_handle);
}

/****************************************************************/

int style_handle;

int style_entry(int entry,int subcode)
{
 if(entry==0) openstylebox(0);
 else
 if(entry>=2) addstyle(entry-2);

 return(0);
}


int style_flags(int entry,string & text)
{
 int bits;

 bits=(activetype(TEXTFRAME)>1)?0:SHADED;

 if(entry==1) return(DOTTED|bits);
 else         return(iscurrentstyle(entry-2)|bits);
}


int style_menu(int open)
{
 int    i;
 string s;

 if(style_handle) delete_menu(style_handle);
 style_handle=create_menu("{SM00}");

 addentry_menu(style_handle,"style_entry","","","CS_E","{SM01}");
 addentry_menu(style_handle,"","style_flags","remove_menu","","{SM02}");
 i=0;
 while(getuserstyle(i++,s,1))
  addentryl_menu(style_handle,"style_entry","style_flags","","",s);

 return(style_handle);
}

/****************************************************************/

int scope_handle;

int scope_entry(int entry,int subcode)
{
 setscope(entry);
 return(0);
}

int scope_flags(int entry,string & text)
{
 return(entry==getscope());
}

int scope_menu(int open)
{
 return(scope_handle);
}

/****************************************************************/

int remove_handle;

int remove_entry(int entry,int subcode)
{
 string s;

 remstyle(entry-2);
 getcurrentstyle(0,s,2);
 rementry_menu(remove_handle,entry);
 return(0);
}

int remove_effects(int entry,int subcode)
{
 cleareffects(0);
 return(0);
}

int remove_styles(int entry,int subcode)
{
 int i = 0;
 string s;

 cleareffects(0);
 while(getcurrentstyle(i, s, 2))
 {
  remstyle(i++);
  rementry_menu(remove_handle, 2);
 }
 return(0);
}

int remove_flags(int entry,string & text)
{
 return(DOTTED);
}

int remove_menu(int open)
{
 int    i;
 string s;

 if(remove_handle) delete_menu(remove_handle);
 remove_handle = create_menu("{RMM00}");

 addentry_menu(remove_handle,"remove_styles","","","C_A","{RMM01}");
 addentry_menu(remove_handle,"remove_effects","remove_flags","","C_L","{RMM02}");
 i = 0;
 while(getcurrentstyle(i++, s, 2))
  addentryl_menu(remove_handle,"remove_entry","","","",s);

 return(remove_handle);
}

/****************************************************************/

int object_handle;

int object_entry(int entry,int subcode)
{
 switch(entry)
 {

  case 4:
         if(subcode==-1) openduplicatebox();
         else            duplicateselection(-1,0,0);
         break;
  case 5:
         if(cangroup()) groupselection();
         else           ungroupselection();
         break;
  case 6:
         if(canmakelocal()) makeselectionlocal();
         else               makeselectionmaster();
         break;
 }
 return(0);
}

int object_flags(int entry,string & text)
{
 int bits;

 bits=SHADED;

 switch(entry)
 {

  case 0:
  case 1:
  case 2:
  case 9:
         if(canmodify()) bits=0;
         break;

  case 4:
         if(canduplicate()) bits=0;
         break;

  case 3:
         if(canshape()) bits=DOTTED;
         else           bits=DOTTED|SHADED;
         break;

  case 7:
         if(cangofront()) bits=0;
         break;

  case 8:
         if(cangoback()) bits=0;
         break;

  case 5:
         if(cangroup())
         {
          text="{OM06}";
          translate(text);
         }
         else
         if(canungroup())
         {
          text="{OM11}";
          translate(text);
         }
         else                break;
         bits=0;
         break;

  case 6:
         bits|=DOTTED;
         if(canmakelocal())
         {
          text="{OM07}";
          translate(text);
         }
         else
         if(canmakemaster())
         {
          text="{OM12}";
          translate(text);
         }
         else                break;
         bits=DOTTED;
         break;
 }

 return(bits);
}

int object_menu(int open)
{
 return(object_handle);
}

/****************************************************************/

int valign_handle;

int valign_entry(int entry,int subcode)
{
 setvalign(entry);
 return(0);
}

int valign_flags(int entry,string & text)
{
 return(entry==getvalign());
}

int valign_menu(int open)
{
 return(valign_handle);
}



/****************************************************************/

int firstline_handle;

int firstline_entry(int entry,int subcode)
{
 setfirstline(entry);
 return(0);
}

int firstline_flags(int entry,string & text)
{
 return(entry==getfirstline());
}

int firstline_menu(int open)
{
 return(firstline_handle);
}



/****************************************************************/

int guidewidth_handle;
int ugwidth0,ugwidth1,ugwidth2,ugwidth3,ugwidth4,ugwidth5;

int guidewidth_entry(int entry,int subcode)
{
 int uwidth;

 switch(entry)
 {
  case 0:
         uwidth=ugwidth0;
         break;
  case 1:
         uwidth=ugwidth1;
         break;
  case 2:
         uwidth=ugwidth2;
         break;
  case 3:
         uwidth=ugwidth3;
         break;
  case 4:
         uwidth=ugwidth4;
         break;
  case 5:
         uwidth=ugwidth5;
         break;
  case 6:
         uwidth=stringu(string_menu(guidewidth_handle,6),-1);
         break;
 }
 setguidewidth(uwidth);
 return(0);
}

int guidewidth_flags(int entry,string & text)
{
 int width;
 int uwidth;

 width=getguidewidth();

 switch(entry)
 {
  case 0:
         tick=0;
         uwidth=ugwidth0;
         break;
  case 1:
         uwidth=ugwidth1;
         break;
  case 2:
         uwidth=ugwidth2;
         break;
  case 3:
         uwidth=ugwidth3;
         break;
  case 4:
         uwidth=ugwidth4;
         break;
  case 5:
         uwidth=ugwidth5;
         break;
  case 6:
         uwidth=width;
         break;
 }
 if(uwidth || entry==6)
  text=ustring(uwidth,-1);
 else
 {
  text="{THIN}";
  translate(text);
 }
 if(entry==6 && tick) text="";

 if(entry==6) return((8<<24)|(8<<16)|WRITEABLE|!tick);
 if(uwidth==width) return(tick=1);
 return(0);
}

int guidewidth_menu(int open)
{
 return(guidewidth_handle);
}

/****************************************************************/

int linewidth_handle;
int lwidth0,lwidth1,lwidth2,lwidth3,lwidth4,lwidth5;

int linewidth_entry(int entry,int subcode)
{
 int uwidth;

 switch(entry)
 {
  case 0:
         uwidth=lwidth0;
         break;
  case 1:
         uwidth=lwidth1;
         break;
  case 2:
         uwidth=lwidth2;
         break;
  case 3:
         uwidth=lwidth3;
         break;
  case 4:
         uwidth=lwidth4;
         break;
  case 5:
         uwidth=lwidth5;
         break;
  case 6:
         uwidth=stringu(string_menu(linewidth_handle,6),-1);
         break;
 }
 setlinewidth(uwidth);
 return(0);
}

int linewidth_flags(int entry,string & text)
{
 int width;
 int uwidth;

 width=getlinewidth();

 switch(entry)
 {
  case 0:
         tick=0;
         uwidth=lwidth0;
         break;
  case 1:
         uwidth=lwidth1;
         break;
  case 2:
         uwidth=lwidth2;
         break;
  case 3:
         uwidth=lwidth3;
         break;
  case 4:
         uwidth=lwidth4;
         break;
  case 5:
         uwidth=lwidth5;
         break;
  case 6:
         uwidth=width;
         break;
 }
 if(uwidth || entry==6)
  text=ustring(uwidth,-1);
 else
 {
  text="{THIN}";
  translate(text);
 }
 if(entry==6 && tick) text="";

 if(entry==6) return((8<<24)|(8<<16)|WRITEABLE|!tick);
 if(uwidth==width) return(tick=1);
 return(0);     
}

int linewidth_menu(int open)
{
 return(linewidth_handle);
}

/****************************************************************/

int linestyle_handle;

int linestyle_entry(int entry,int subcode)
{
 int ustyle;
 int l;

 switch(entry)
 {
  case 0:
         ustyle=0xFFFFFFFF;
         l = 5120;
         break;
  case 1:
         ustyle=0xFCFCFCFC;
         l = 2880;
         break;
  case 2:
         ustyle=0xEEEEEEEE;
         l = 3840;
         break;
  case 3:
         ustyle=0xAAAAAAAA;
         l = 5120;
         break;
  case 4:
         ustyle=0xFAFAFAFA;
         l = 3200;
         break;
 }
 setlinepattern(ustyle,l);
 return(0);
}

int linestyle_flags(int entry,string & text)
{
 int style;
 int scale;
 int ustyle;
 int l;

 style=getlinepattern();
 scale=getlinescale();

 switch(entry)
 {
  case 0:
         ustyle=0xFFFFFFFF;
         l = 5120;
         break;
  case 1:
         ustyle=0xFCFCFCFC;
         l = 2880;
         break;
  case 2:
         ustyle=0xEEEEEEEE;
         l = 3840;
         break;
  case 3:
         ustyle=0xAAAAAAAA;
         l = 5120;
         break;
  case 4:
         ustyle=0xFAFAFAFA;
         l = 3200;
         break;
 }
 return(style==ustyle && scale==l);
}

int linestyle_menu(int open)
{
 return(linestyle_handle);
}

/****************************************************************/

int linejoin_handle;

int linejoin_entry(int entry,int subcode)
{
 setlinejoin(entry);
 return(0);
}

int linejoin_flags(int entry,string & text)
{
 int join;
 join=getlinejoin();
 return(join==entry);
}

int linejoin_menu(int open)
{
 return(linejoin_handle);
}

/****************************************************************/

int caps_handle;
int trianglew_handle;
int triangleh_handle;
int tstart;
int theight;
int thandle;
int umult0,umult1,umult2,umult3;

int linestartcaps_handle;

int sc_entry(int entry,int subcode)
{
 setlinecaps(tstart,entry);
 return(0);
}

int sc_flags(int entry,string & text)
{
 tstart=1;
 return(getlinecaps(tstart)==entry);
}

int linestartcaps_menu(int open)
{
 return(linestartcaps_handle);
}

/****************************************************************/

int lineendcaps_handle;

int ec_entry(int entry,int subcode)
{
 setlinecaps(tstart,entry);
 return(0);
}

int ec_flags(int entry,string & text)
{
 tstart=0;
 return(getlinecaps(tstart)==entry);
}

int lineendcaps_menu(int open)
{
 return(lineendcaps_handle);
}

/****************************************************************/

int caps_menu(int open)
{
 return(caps_handle);
}

/****************************************************************/

int triangle_entry(int entry,int subcode)
{
 int umultiple;


 switch(entry)
 {
  case 0:
         umultiple=umult0;
         break;
  case 1:
         umultiple=umult1;
         break;
  case 2:
         umultiple=umult2;
         break;
  case 3:
         umultiple=umult3;
         break;
  case 4:
         umultiple=stringdp(string_menu(thandle,4));
         break;
 }
 setlinetriangle(tstart,theight,umultiple);
 return(0);
}

int triangle_flags(int entry,string & text)
{
 int umultiple;
 int multiple;

 multiple=getlinetriangle(tstart,theight);

 switch(entry)
 {
  case 0:
         tick=0;
         umultiple=umult0;
         break;
  case 1:
         umultiple=umult1;
         break;
  case 2:
         umultiple=umult2;
         break;
  case 3:
         umultiple=umult3;
         break;
  case 4:
         text=tick ? "" : dpstring(multiple,2);
         return((8<<24)|(8<<16)|WRITEABLE|!tick);
         break;
 }
 text="x"+dpstring(umultiple,2);
 if(multiple==umultiple) return(tick=1);
 return(0); 
}

/****************************************************************/

int trianglew_flags(int entry,string & text)
{
 theight=0;
 thandle=trianglew_handle;
 return(triangle_flags(entry,text));
}

int trianglew_menu(int open)
{
 return(trianglew_handle);
}

/****************************************************************/

int triangleh_flags(int entry,string & text)
{
 theight=1;
 thandle=triangleh_handle;
 return(triangle_flags(entry,text));
}

int triangleh_menu(int open)
{
 return(triangleh_handle);
}

/****************************************************************/

int page_handle;

int page_flags(int entry,string & text)
{
 switch(entry)
 {
  case 0:
  case 3:
  case 7:
  case 8:
  case 4:
         return(ismasterview()?SHADED:0);
         break;
  case 1:
         return(ismasterview()?DOTTED:SHADED | DOTTED);
         break;

  case 5:
         if(cliptype()!=4 || ismasterview()) return(SHADED);
         break;

  case 6:
         return(DOTTED);
         break;
 }

 return(0);
}

int page_entry(int entry,int subcode)
{
 switch(entry)
 {
  case 0:
         newview(1);
         break;
 }
 return(0);
}

int page_menu(int open)
{
 return(page_handle);
}

/****************************************************************/

int newpagesize_handle;

int newpagesize_entry(int entry,int subcode)
{
 string s;

 switch(entry)
 {
  case 0:
         s="{PSM01}";
         translate(s);
         setnewpagesize(841890,1190551,s,0);
         break;
  case 1:
         s="{PSM02}";
         translate(s);
         setnewpagesize(595276,841890,s,0);
         break;
  case 2:
         s="{PSM03}";
         translate(s);
         setnewpagesize(420944,595276,s,0);
         break;
  case 3:
         s="{PSM04}";
         translate(s);
         setnewpagesize(612000,792000,s,0);
         break;
  case 4:
         s="{PSM05}";
         translate(s);
         setnewpagesize(612000,1008000,s,0);
         break;
  case 5:
         s="{PSM06}";
         translate(s);
         setnewpagesize(792000,1224000,s,0);
         break;
  case 6:
         s="{PSM07}";
         translate(s);
         setnewpagesize(-1,-1,s,1);
         break;
 }
 return(0);
}

int newpagesize_flags(int entry,string & text)
{
 int x;
 int y;
 int code;

 x=getnewpagesize(0);
 y=getnewpagesize(1);

 switch(entry)
 {
  case 0:
         code=(x==841890 && y==1190551);
         break;
  case 1:
         code=(x==595276 && y==841890);
         break;
  case 2:
         code=(x==420944 && y==595276);
         break;
  case 3:
         code=(x==612000 && y==792000);
         break;
  case 4:
         code=(x==612000 && y==1008000);
         break;
  case 5:
         code=(x==792000 && y==1224000);
         break;
  case 6:
         code=(x==-1 && y==-1);
         break;
 }
 return(code);
}

int newpagesize_menu(int open)
{
 return(newpagesize_handle);
}

/****************************************************************/

int newchapter_handle;

int newchapter_entry(int entry,int subcode)
{
 opennewchapterbox(entry);
 return(0);
}

int newchapter_menu(int open)
{
 return(newchapter_handle);
}


/****************************************************************/


int pastechapter_handle;

int pastechapter_entry(int entry,int subcode)
{
 pastechapter(entry);
 return(0);
}

int pastechapter_menu(int open)
{
 return(pastechapter_handle);
}


/****************************************************************/

int misc_handle;

int misc_entry(int entry,int subcode)
{
 switch(entry)
 {
  case 4:
         openeditcolourbox(0);
         break;
 }
 return(0);
}

int misc_flags(int entry,string & text)
{
 return((activetype(TEXTFRAME)>1)?0:SHADED);
}

int misc_menu(int open)
{
 return(misc_handle);
}

/****************************************************************/

int spell_handle;

int spell_entry(int entry,int subcode)
{
 switch(entry)
 {
  case 0:
         checkstory(0);
         break;
  case 3:
         checkstory(1);
         break;
  case 4:
         setcheck(getcheck()^1);
         break;

 }
}

int spell_flags(int entry,string & text)
{
 switch(entry)
 {
  case 0:
  case 1:
  case 3:
         return((activetype(TEXTFRAME)>1)?0:SHADED);

  case 4:
         return((getcheck()&0x1)|DOTTED);
         break;
 }
 return(0);
}

int spell_menu(int open)
{
 return(spell_handle);
}

/****************************************************************/

int userdict_handle;

int userdict_entry(int entry,int subcode)
{
 setuserdict(entry);
 return(0);
}

int userdict_flags(int entry,string & text)
{
 return(isuserdict(entry));
}

int userdict_menu(int open)
{
 int    i;
 string s;

 if(userdict_handle) delete_menu(userdict_handle);
 userdict_handle=create_menu("{DM00}");

 i=0;
 while(getuserdict(i++,s))
  addentryl_menu(userdict_handle,"userdict_entry","userdict_flags","","",s);

 return(userdict_handle);
}

/****************************************************************/

int insert_handle;

int insert_entry(int entry,int subcode)
{
 switch(entry)
 {
  case 0:
         type("{chapternumber}");
         break;
  case 1:
         type("{pagenumber}");
         break;
  case 2:
         type(datestring());
         break;
  case 3:
         type("{activedate}");
         break;
  case 4:
         type(timestring());
         break;
  case 5:
         type("{newpage}");
         break;
  case 6:
         type("{newline}");
         break;
  case 7:
         type("{hardspace}");
         break;
  case 8:
         type("{hardhyphen}");
         break;
  case 9:
         type("{softhyphen}");
         break;
 }
}

int insert_flags(int entry,string & text)
{
 return((activetype(TEXTFRAME)>1)?0:SHADED);
}

int insert_menu(int open)
{
 return(insert_handle);
}

/****************************************************************/

int units_handle;

int units_entry(int entry,int subcode)
{
 setunits(entry);
 return(0);
}

int units_flags(int entry,string & text)
{
 return(getunits()==entry);
}

int units_menu(int open)
{
 return(units_handle);
}

/****************************************************************/

int colour_handle;

int colour_entry(int entry,int subcode)
{
 setcolour(entry);
 return(0);
}

int colour_menu(int open)
{
 int    i;
 string s;

 if(colour_handle) delete_menu(colour_handle);
 colour_handle=create_menu("{CLM00}");

 i=0;
 while(getcolour(i++,s,0))
  addentryl_menu(colour_handle,"colour_entry","","","",s);

 return(colour_handle);
}

/****************************************************************/

int colourchart_handle;

int colourchart_flags(int entry,string & text)
{
 return(iscurrentchart(entry));
}

int colourchart_entry(int entry,int subcode)
{
 setcolourchart(entry);
 return(0);
}

int colourchart_menu(int open)
{
 return(colourchart_handle);
}

/****************************************************************/

int info_handle;

int info_entry(int entry,int subcode)
{
 switch(entry)
 {
  case 2:
         setclipboard(getclipboard()^1);
         break;
 }
 return(0);
}

int info_menu(int open)
{
 return(info_handle);
}

/****************************************************************/

int script_handle;
int script_exists = 0;

int script_menu(int open)
{
 if(!script_handle)
  script_handle = create_menu("{APM00}");

 return(script_handle);
}

void script_menu_initialise(void)
{
 if(!(script_exists & 1))
 {
  addentry_menu(main_handle,"","","script_menu","","{APM00}");
  script_exists |= 1;
 }
}

/****************************************************************/

void main(void)
{
 remove_menu(1);
 style_menu(1);
 script_menu(1);
}
