 
\section{Carrying On}
\subsection{Text}\index{text}
\label{sec:text}
 Text can be added to a figure using the {\tt text();} command. The first 
 two parameters are a coordinate pair giving the position at which the text 
 should start. For subsequent lines of text the coordinates can be omitted 
 in which case the line is positioned below the previous line. The third 
 parameter is the actual text to be printed. There is also an optional 
 fourth parameter which allows the text to be centered on the coordinates 
 or end at the coordinates. Specialized text labels are also generated 
 using the {\tt label();}\index{label} and {\tt ticklabel( 
 );}\index{ticklabel} commands and the following discussion applies to them 
 as well. 

 The appearance of the text is affected by several set-able parameters. The 
 size of the letters is determined by {\tt set(FONTWIDTH , 
 size\_in\_cm);}\index{set, FONTWIDTH} while the ratio of height to width 
 is set using {\tt set(FONTASPECT , height\_div\_width);}\index{set, 
 FONTASPECT}. Alternatively, the size of the text can be changed from its 
 current value by using {\tt set(FONTMULT , multiplier);}\index{set, 
 FONTMULT}. The spacing between letters can be modified using {\tt 
 set(FONTSPACE , space\_in\_cm);}\index{set, FONTSPACE}. The text is 
 ordinarily printed horizontally but this may be changed by using {\tt 
 set(FONTDIR , angle\_in\_deg);}.\index{set, FONTDIR} The width of the line 
 used to draw the text is set using {\tt set(LINEWIDTH , 
 width);}\index{set, LINEWIDTH} and the colour is set using {\tt 
 set(LINECOLOUR , colour\_number );}\index{set, LINECOLOUR}. The text is 
 printed using Hershey stroked fonts. There are two available font families 
 simplex and complex. The complex font is chosen using {\tt set(FONT , 
 COMPLEX);}\index{set, FONT}. Greek\index{greek} and Italic\index{italic} 
 text is selected by using special characters in the text string. Thus 
 Greek may be selected by enclosing a string with '!' as in '!abc! while 
 italics are selected using '\#'. Super and sub scripts are handled in the 
 same way by enclosing the super/sub\index{superscript}\index{subscript} 
 script with '$\wedge$' or '\_' respectively. The position and size of the 
 super/sub script relative to ordinary text may be modified using the {\tt 
 set(SCRIPTSCALE , ratio);}\index{set, SCRIPTSCALE} and {\tt 
 set(SCRIPTSHIFT , fraction );}\index{set, SCRIPTSHIFT} commands 
 respectively. Characters from the symbol font may be included in the
 text string by enclosing the symbol number with '\$'.

 The various text possibilities are explored in the two following demo 
 files. The third demo file is a table of all the available text characters 
 included in the font files. 

{\tt
\begin{verbatim}
/* This file illustrates some of the capabilities of the */
/* text() command to annotate figures */
/* Several fonts are available including full Greek. */
/* Text can be any size, orientation and colour. */ 
 
#include <splot.h>
main()
   {
   text(2.63,23,"The default position for the next line");
   /* change to complex font for next line */
   set(FONT,COMPLEX);
   text("right below the previous line");
   set(FONT,SIMPLEX);
   text("There is a complete set of Greek characters"); 
   text("!abcdefghijklmnopqrstuvxyz!");
   set(FONT,COMPLEX);
   text("!ABCDEFGHIJKLMNOPQRSTUVWXYZ!");
   set(FONT,SIMPLEX);
   set(LINECOLOUR,GREEN);
   /* optional change of script scale and position */
   set(SCRIPTSCALE,1);
   set(SCRIPTSHIFT,1);
   text("Here are ^super^ and _sub_ scripts");
   set(LINECOLOUR,RED);
   text("and #Italics# in different colours");
   set(LINECOLOUR,BLACK);
   text("Letters can be large, small, tall, short");
   text("fat, thin, vertical and angled.");
   set(FONTMULT,2);
   text(2.94,9.56,"Large");
   set(FONTMULT,0.30);
   text(8.90,9.71,"small");
   set(FONTWIDTH,1.0);
   set(FONTASPECT,3);
   text(13.10,9.71,"Tall");
   set(FONTASPECT,0.5);
   text(17.05,9.71,"Short");
   set(FONTASPECT,2);
   set(LINEWIDTH,0.01);
   text(2.94,7.29,"Thin");
   set(LINEWIDTH,0.2);
   text(9.02,7.29,"Fat"); 
   set(LINEWIDTH,0.05);
   set(FONTDIR,90);
   text(3.63,1.26,"Vertical");
   set(FONTDIR,130);
   text(11.28,1.44,"Angled");
   }
\end{verbatim}
}

\newpage
\vspace*{25cm}
\special{psfile=text.eps hscale=80 vscale=80 hoffset=-30 voffset=75}

{\tt
\begin{verbatim}
/* This file illustrates some of the capabilities of the */
/* text() command to annotate figures */
 
#include <splot.h>
main()
   {
   text(2,23,"The spacing between letters can be changed");
   set(FONTSPACE,0.5);
   text("to be further apart than usual");
   set(FONTSPACE,-0.2);
   text("or closer together.");
   set(FONTSPACE,0);
   text("The size and position of super/sub scripts can");
   text(2,17.38,"be varied as in");
   set(SCRIPTSHIFT,0.7);
   set(SCRIPTSCALE,0.5);
   text(8.94,17.38,"X_1_\b^2^,");
   set(SCRIPTSHIFT,1.0);
   set(SCRIPTSCALE,0.7);
   text(10.19,17.38,"X_1_\b^2^,");
   set(SCRIPTSHIFT,1.5);
   set(SCRIPTSCALE,1.0);
   text(11.4,17.38,"X_1_\b^2^.");
   text(2.10,15.81,"Note how the superscript was placed above");
   text("the subscript using the backspace char \\b.");
   text("Enter degree sign using '<ALT X> 127'");
   text("Use a \\ before special characters: \_\^\$\#\!\"");
   text("Symbols: $0 1 2 3 4 5 6 7 8 9 : ; < = > $"); 
  
   text(2,8,"The default text insertion point is LEFT");
   text(17,6,"but can be set to RIGHT",RIGHT);
   text(10,4,"Or CENTER",CENTER);
   }
\end{verbatim}
}

\newpage
\vspace*{25cm}
\special{psfile=text2.eps hscale=80 vscale=80 hoffset=-30 voffset=75}
	   
\index{text, character table}
{\tt
\begin{verbatim}
/* This file displays all the available characters */
 
#include <splot.h>       
#define ROMAN 1
#define GREEK 0
#define ITALIC 0
int i,j;
char c[10];

main()
   {
   set(PAGEROT,ON);
#if ROMAN
   text(13.67,19.14,"Roman",CENTER);
   text(7.5,18,"Simplex",CENTER);
   text(19,18,"Complex",CENTER);
   gsave();
   scale(1.2,1.2);
   translate(1,-11);
   set(FONTWIDTH,0.5);
   set(FONTASPECT,1.5);
   table(0);
   translate(10,0);
   set(FONT,COMPLEX);
   table(0);
   set(FONT,SIMPLEX);
#endif
#if GREEK
   text(13.67,19.14,"Greek",CENTER);
   text(7.5,18,"Simplex",CENTER);
   text(19,18,"Complex",CENTER);
   gsave();
   scale(1.2,1.2);
   translate(1,-11);
   set(FONTWIDTH,0.5);
   set(FONTASPECT,1.5);
   table(1);
   translate(10,0);
   set(FONT,COMPLEX);
   table(1);
   set(FONT,SIMPLEX);
#endif
#if ITALIC
   text(7.5,18,"Italics Simplex/Complex",CENTER);
   text(19,18,"Symbols",CENTER);
   gsave();
   scale(1.2,1.2);
   translate(1,-11);
   set(FONTWIDTH,0.5);
   set(FONTASPECT,1.5);
   table(2);
   translate(10,0);
   table(3);
#endif
   grestore();
   }

table(int special)
   {
   /* label rows and columns */
   c[1] = '\0';
   for (i = 0; i < 10;i++)
      {
      c[0] = '0' + i;
      tputs(2 + i * 0.7,24.5,c,0);
      }
   c[0] = ' ';
   c[2] = '0';
   c[3] = '\0';
   for (j = 3;j < 10;j++)
      {
      c[1] = '0' + j;
      tputs(0,26 - j,c,0);
      }
   c[0] = '1';
   c[2] = '0';
   c[3] = '\0';
   for (j = 10;j < 13;j++)
      {
      c[1] = '0' + j - 10;
      tputs(0,26 - j,c,0);
      }
   /* prepend each char with '\' so that even special chars get printed */
   c[0] = '\\';
   c[2] = '\0';
   box(1.29,23.77,9.07,13.36);
   stroke();
   /* fill in table */
   for (j = 3;j < 13;j++)
      {
      for (i = 0; i < 10;i++)
	 {
	 c[1] = j * 10 + i;
	 if (c[1] == 'b')
	    tputs(2 + i * 0.7,26 - j,"b",special);
	 else
	    tputs(2 + i * 0.7,26 -j,c,special);
	 }
      }
   }

tputs(double x,double y,char *c,int special) 
   {
   char tmp[10];
   switch(special)
      {
      case 0:
	 text(x,y,c);
	 break;
      case 1:
	 /* greek */
	 strcpy(tmp,"!");
	 strcat(tmp,c);
	 strcat(tmp,"!");
	 text(x,y,tmp);
	 break;
      case 2:
	 /* italics */
	 strcpy(tmp,"#");
	 strcat(tmp,c);
	 strcat(tmp,"#");
	 text(x,y,tmp);
	 break;
      case 3:
	 /* symbols */
	 strcpy(tmp,"$");
	 strcat(tmp,c);
	 strcat(tmp,"$");
	 text(x,y,tmp);
	 break;
      }
   }
 
\end{verbatim}
}

\newpage
\vspace*{22cm}
\special{psfile=chartabl.eps hscale=80 vscale=80 hoffset=0 voffset=0}

\newpage
\vspace*{22cm}
\special{psfile=chartab1.eps hscale=80 vscale=80 hoffset=0 voffset=0}

\newpage
\vspace*{22cm}
\special{psfile=chartab2.eps hscale=80 vscale=80 hoffset=0 voffset=0}

\subsection{Symbols}\index{symbols}
 Symbols can optionally be drawn at every data point by setting {\tt 
 set( PLOTTYPE , SYMBOLS);}\index{set, PLOTTYPE} or {\tt set( PLOTTYPE , 
 SYM\_LINES);}. The actual symbol used is set using {\tt set( CURSYMBOL , 
 sym\_number );}\index{set, CURSYMBOL} Symbols are just a special font and 
 much of the above discussion on how to change a letter's appearance 
 applies also to symbols. There is, however, no complex version of the 
 symbols. Additionally, the size of the symbols can be adjusted relative to 
 the current font size using {\tt set( SYMMULT ,multiplier);}\index{set, 
 SYMMULT}. Symbols can also be drawn independent of {\tt drawdata( 
 );}\index{drawdata} at an arbitrary location by using {\tt symbol( x , y , 
 sym\_number);}. For an example of the symbol capabilities consult the last 
 example of the previous chapter. Symbols may also be included in text  
 strings drawn with {\tt text();} by enclosing the symbol number with '\$'
 in the text string. 

\subsection{Gsave/Grestore}\index{gsave/grestore}
 The pair of functions {\tt gsave();} and {\tt grestore();} are useful for 
 a variety of purposes. {\tt gsave();} stores the complete graphics state 
 including the currently defined path while {\tt grestore();} restores the 
 state to the last saved state. Each {\tt grestore();} must have a matching 
 {\tt gsave();} preceding it. 
	
 The simplest use for this pair is to restore the initial state after 
 translations and scaling. This often comes up in composite figures that 
 are constructed from other existing picture. The composite is built by 
 setting translations and scale factors for each component and then drawing 
 the component. If a {\tt gsave();} was done at the beginning then a {\tt 
 grestore();} can be done after drawing the components to restore the 
 initial scale and translation. This can be useful for adding annotations 
 to the final composite figure. 

 It is also possible to use gsave/grestore to repeatedly draw a given path 
 since the currently defined path is also saved. In the following example a 
 path is defined, saved (using {\tt gsave();}), filled, restored (using {\tt 
 grestore();}) and then finally stroked.\index{stroke}\index{fill} Filling 
 and stroking the same path causes the filled region to have a border drawn 
 in the current line colour and style. 


\vspace*{0.2cm}
\special{psfile=art.eps hscale=30 vscale=30 hoffset=200 voffset=-300}

{\tt
\begin{verbatim}

#include <splot.h>
/* This is a region filling example */
int i;
main() 
   {     
   set(LINEWIDTH,0.1);
   set(FILLRULE,EVENODD);
   translate(10,15);
   for (i=0;i < 8;i++)
      {
      set(LINECOLOUR,i);
      leaf();
      rotate(45);
      }
   }

int leaf()
   {
   arc(3.1,3.38896,0.4,0,360);
   moveto(0,0);
   curveto(3.38924,0.598051,3.18987,3.85411,5.91456,6.11341);
   curveto(2.06013,5.44891,2.52532,1.5948,0,0);
   closepath();
   gsave();
   fill();
   grestore();
   set(LINECOLOUR,BLACK);
   stroke();
   }

\end{verbatim}
}


 The following example again illustrates the use of gsave/grestore to 
 repeatedly draw the same path each time with a small translation to draw a 
 stack of pages. It also illustrates the use of electronic white 
 out\index{white out, example} (filling with colour white) to remove 
 unwanted lines. 

\vspace*{0.2cm}
\special{psfile=gsave.eps hscale=50 vscale=50 hoffset=280 voffset=-420}

{\tt
\begin{verbatim}
 
#include <splot.h>

int i;
double x,y,d,l;

main()
   {
   /* draw 3d stack of pages */
   x = 5;
   y = 15;
   l = 4;
   for (i = 0;i <= 10;i++;)
      {
      d = i * 0.2;
      box(x - d ,y - d, x - d + l, y - d + l);
      gsave();
      set(LINECOLOUR,WHITE);
      fill();
      grestore();
      stroke();
      }
   /* draw sample */
   arc(5.02,14.96,1.2,0,360);
   fill();
   white_box(3.95,13.51,6.134,13.904);
   white_box(3.862,13.689,3.752,15.443);
   /* draw axes */
   moveto(3.00,10.19);
   rarrowto(0.0,2);
   moveto(3.00,10.19);
   rarrowto(2,0);
   moveto(3.00,10.19);
   rarrowto(1.6,1.6);
   stroke();
   /* add labels */
   text(5.20,9.71,"X");
   text(2.31,11.82,"Y");
   text(5.01,11.64,"!l");
   }

int white_box(double x1,double y1,double x2,double y2)
   { 
   gsave();
   newpath();
   box(x1,y1,x2,y2);
   set(LINECOLOUR,WHITE);
   fill();
   grestore();
   }

\end{verbatim}
}

 Using the above technique to repeatedly draw the same element will not 
 work with functions such as {\tt text();}\index{text} which are implicitly 
 stroked since there is no chance to do a {\tt gsave();} before the stroke. 
 However, implicit stroking can be temporarily turned off with the {\tt 
 newpath();}\index{newpath} command. Without the {\tt newpath();} in the 
 following example only the first "SPLOT" would have been printed. The 
 first {\tt stroke();}\index{stroke} after a {\tt newpath();} turns on 
 implicit stroking again with these functions. 

{\tt
\begin{verbatim}
 
#include <splot.h>
main()
   {
   int i;
   newpath();
   translate(10,10);
   text(0,0,"      SPLOT");
   for (i=0;i < 360;i += 30)
      {
      gsave();
      rotate(i);
      stroke();
      grestore();
      }
   }

\end{verbatim}
}

\vspace*{0.2cm}
\special{psfile=logo.eps hscale=50 vscale=50  hoffset=180 voffset=-40}
 
\subsection{Insets}\index{inset}
 Inset figures can easily be made from existing figures by moving the 
 origin to the desired insertion point using {\tt translate(xpos,ypos 
 );}\index{translate}, changing the scale with {\tt 
 scale(xfact,yfact);}\index{scale}, and copying the existing code defining 
 the inset figure into the current file using the editor block move 
 functions. It is also useful to bracket the inset figure with a {\tt 
 gsave();} / {\tt grestore();} pair in order to restore the original 
 coordinates after the inset. 

\index{axes, log example}
{\tt
\begin{verbatim}
/* This figure demonstrates how to use axes other */
/* than the standard linear axes. Also it illustrates */
/* how insets can be made. Insets alternatively can */
/* be made by encapsulating an entire drawing in a */
/* subroutine. */

#include <splot.h>
			   
double *lifetime, *rawtime;          

main()           
   {             
   int i;
   double majortic,minortic;

   /* define a tic length  */
   /* major and minor tics */

   majortic=0.3;
   minortic=0.25;

   /* set up some default values */

   set(FONTASPECT,1.2);
   set(FONTWIDTH,0.8);
   set(PLOTTYPE,SYM_LINES);
   set(CURSYMBOL,CIRCLE);
   set(AXESCLIP,ON);
   set(LINEWIDTH,0.1);
   set(AXESTYPE,LOGY);

   /* get the data and set the box  */                
  
   readdata("demo\lifetime.dat",lifetime);
   /* draw axes box but not centered on the page */
   axes_box(13,17,-30,0.9,330,60,5.51,7.5);
  
   /* x-axis   */  
  
   /* major tics*/
  
   set(TICKLENGTH,majortic);
   tickmarks(XAXES,0,100,200,300);
  
   /* minor ticks */
  
   set(TICKLENGTH,minortic);
   set(LINEWIDTH,0.05);
   tickmarks(XAXES,25,50,75,125,150,175,225,250,275);
   ticklabel(BOTTOM,0,"0",100,"100",200,"200",300,"300");
  
   /* y-axis */
  
   /* major tics*/
  
   set(TICKLENGTH,majortic);
   set(LINEWIDTH,0.1);
   tickmarks(YAXES,1,10,50);
  
   /* minor ticks */
  
   set(TICKLENGTH,minortic);
   set(LINEWIDTH,0.05);
   tickmarks(YAXES,2,3,4,5,6,7,8,9,20,30,40);
   ticklabel(LEFT,1,10,50);
  
   /* axis labels */
  
   label(LOWER,"Temperature (K)");
   label(LEFT,"Lifetime (ms)");
  
   drawdata(lifetime,0,1);        

   /* now build the inset figure */
   /* insert  setup stuff */ 
   set(PLOTTYPE,LINES);
   set(LINEWIDTH,0.065);
   set(AXESTYPE,LOGY);
   readdata("demo\rawtime.dat",rawtime);
   axes_box(6,7.85,0.00,20,0.400,250000,8.02,10.19);
   set(LINEWIDTH,0.05);
   tickmarks(XAXES,0.1);
   tickmarks(YAXES,1);
   set(FONTASPECT,1.0);
   set(FONTWIDTH,0.67);
   ticklabel(BOTTOM,0,0.4);
   drawdata(rawtime,0,1);        
   text(11.30,16.64,"T=20K");
   label(LEFT,"Log Counts (Decades)");
   set(LABELMARG,-0.8);
   label(BOTTOM,"time (ms)");
   }                          
\end{verbatim}
}

\vspace*{25cm}
\special{psfile=logaxes.eps hscale=80 vscale=80  hoffset=-50 voffset=0}

\subsection{Tick Marks and Tick Labels}\index{tick marks}\index{tick 
labels}

 Tick marks are added to an existing axes box using the {\tt tickmarks();} 
 command. At its simplest no parameters are required and Splot tries to 
 select a set of reasonable tick marks for both the x and y axes. 
 Alternatively, a list of tick positions can be provided for each axis. 
 Tick marks are lines and so the width of a tick mark is set using {\tt set 
 (LINEWIDTH, width);}\index{tick marks, width}. The length of a tick mark 
 is set using {\tt set(TICKLENGTH, length);}\index{tick marks, length}. Grid 
 lines may be produced by choosing the length the same as the length of the 
 axes box. If tickmarks on the outside of the axes box are desired they may 
 be generated by setting a negative tick length. 

 Tick labels are produced with the {\tt ticklabel();} command. At its 
 simplest no parameters are required and Splot labels a subset of the 
 existing tick marks on the bottom and left side. Alternatively, an axis 
 may be specified along with a list of tick label positions. At its most 
 powerful each tick position may be paired with a text string allowing any 
 arbitrary string to appear at the desired location. In this way tick 
 labels need not be in the same units as those used to draw the graph. Tick 
 labels are just text and tick label appearance is affected by 
 the text attributes discussed in \ref{sec:text}. 

\index{tick marks, example}
{\tt
\begin{verbatim}

#include <splot.h>
main() 
   {
   /* tick marks and tick label example */
   abox(12,12,5,6);
   ascale(XAXES,0,100);
   ascale(YAXES,0,30);

   /* default tick marks and labels */
   tickmarks(BOTTOM);
   ticklabel(BOTTOM);

   gsave();

   /* grid lines */
   set(TICKLENGTH,12);
   tickmarks(LEFT);
   ticklabel(LEFT);

   /* thick -ve ticks at specified positions  */
   set(LINEWIDTH,0.2);    
   set(TICKLENGTH,-0.3);
   tickmarks(RIGHT,0,5,10,15,20,25,30);
   set(LINEWIDTH,0.05);    
   set(TICKLMARG,0.5);
   ticklabel(RIGHT,0,30);

   grestore();

   /* ticks by spacing and custom labels */
   tickmarks(TOP,5);
   ticklabel(TOP,0,"0",50,"5x10^1^",100,"10^2^");

   }
\end{verbatim}
}

\vspace*{0.2cm}
\special{psfile=tickdemo.eps hscale=50 vscale=50 hoffset=200 voffset=70}

\subsection{clipping}\index{clip} 

 A drawing can be clipped to an arbitrary path by first building a path 
 with the path building functions such as {\tt moveto();} and {\tt 
 lineto();} and then setting it up as the clip path with the {\tt clip();} 
 function. The clip path must be set before the drawing to be clipped is 
 made. In the following example a triangular path is made and then saved using 
 {\tt gsave();}. This path is then set up as the current clip path using 
 the {\tt clip();} function. The path is then restored and stroked in 
 order to show the clip path. The clip path is not ordinarily visible on 
 the page. Finally the path is restored once more the y axis mirrored and 
 the triangle filled. The result is the inverted triangle clipped against 
 the original triangle.

\index{clip, example}
\vspace*{0.2cm}
\special{psfile=clip.eps hscale=30 vscale=30 hoffset=200 voffset=-245}

{\tt
\begin{verbatim}
 
#include <splot.h>
main()
   {
   translate(10,13);
   moveto(-4,-4);
   rlineto(10,0);
   alineto(10,120);
   closepath();
   gsave();
   clip();
   grestore();
   gsave();
   stroke();
   grestore();
   /* mirror about y axis */
   scale(1,-1);
   fill();
   }
\end{verbatim}
}

 Data drawn using {\tt drawdata();} or {\tt plotdata();}\index{drawdata, 
 clipping}\index{plotdata, clipping} may be clipped to the most recently 
 drawn axes box by setting {\tt set(AXESCLIP,ON );}\index{set, AXESCLIP} before 
 calling {\tt plotdata();} or {\tt drawdata();}. This makes use of the 
 clipping mechanism internally by temporarily adding the axes box to the 
 clip path and then restoring the previous clip path after the data is 
 drawn. 

\subsection{units}\index{coordinate, matching}\index{units}

 The default units for the drawing page are centimeters. The physical page 
 available for drawing in is 20 cm wide by 26 cm high (approximately 8 x 11 
 inches). It is not possible to change the physical size of the drawing 
 area but the units can easily be changed using the {\tt scale(xfact, 
 yfact);}\index {scale} command. Thus in order to change the units to 
 inches for example put {\tt scale(0.3937,0.3937);} right after {\tt 
 main()} in the file. The default orientation of the page is 
 portrait\index{portrait} with the x axes along the short side. The origin 
 may be shifted using {\tt translate();}\index{translate} and x and y 
 interchanged using {\tt rotate(90);}\index{rotate}. It is thus possible to 
 change to landscape mode using a combination of {\tt translate();} and 
 {\tt rotate();} but it is much easier to just specify {\tt set(PAGE\_ROT, 
 ON);}\index{set, PAGE\_ROT}\index{landscape} at the top of the file after 
 {\tt main()}. 

 It is sometimes convenient to change the coordinates of the page to 
 match\index{cmatch} those used to draw data within the axes box. This can 
 be useful for adding labels to features in the 
 data. This could be done using {\tt translate();} and {\tt scale();} but 
 is much more easily achieved with the function {\tt cmatch(ON);} in the 
 code or the coordinate match menu choice in the misc menu. The menu button 
 is a toggle and alternately turns on and off the coordinate matching. If 
 there are multiple axes boxes in a figure the last drawn one is used to 
 match to. This may be changed by high lighting a different axes box using 
 the right mouse button. 
