Logo Search packages:      
Sourcecode: latexdraw version File versions  Download package

static void latexDraw::parsers::pstricks::PSTricksParserActionsManager::parseOptionsFigure ( String  params,
PSTricksParameters  pstp,
boolean  applyParams 
) [inline, static]

Allows to parse the options of any PSTricks figure (excepts psplot).
All the parameters will be in cm.

Parameters:
params The code to parse.
pstp The pstricks parameters.
applyParams If true the parsed parameters will be applied to the pstp, else the parameters will be parsed but ignored.

Definition at line 946 of file PSTricksParserActionsManager.java.

References latexDraw::parsers::pstricks::PSTricksParameters::arcSep, latexDraw::parsers::pstricks::PSTricksParameters::arcSepA, latexDraw::parsers::pstricks::PSTricksParameters::arcSepB, latexDraw::parsers::pstricks::PSTricksParameters::arrowBrLgth, latexDraw::parsers::pstricks::PSTricksParameters::arrowDotSD, latexDraw::parsers::pstricks::PSTricksParameters::arrowDotSN, latexDraw::parsers::pstricks::PSTricksParameters::arrowInset, latexDraw::parsers::pstricks::PSTricksParameters::arrowLgth, latexDraw::parsers::pstricks::PSTricksParameters::arrowrBrLgth, latexDraw::parsers::pstricks::PSTricksParameters::arrowSizeD, latexDraw::parsers::pstricks::PSTricksParameters::arrowSizeN, latexDraw::parsers::pstricks::PSTricksParameters::arrowStyle, latexDraw::parsers::pstricks::PSTricksParameters::arrowTBarSD, latexDraw::parsers::pstricks::PSTricksParameters::arrowTBarSN, latexDraw::parsers::pstricks::PSTricksParameters::axesStyle, latexDraw::parsers::pstricks::PSTricksParameters::border, latexDraw::parsers::pstricks::PSTricksParameters::borderColor, latexDraw::parsers::pstricks::PSTricksParameters::borderPos, latexDraw::parsers::pstricks::PSTricksParameters::boxSep, latexDraw::parsers::pstricks::PSTricksParameters::curvature1, latexDraw::parsers::pstricks::PSTricksParameters::curvature2, latexDraw::parsers::pstricks::PSTricksParameters::curvature3, latexDraw::parsers::pstricks::PSTricksParameters::dashBlack, latexDraw::parsers::pstricks::PSTricksParameters::dashWhite, latexDraw::parsers::pstricks::PSTricksParameters::dbleColor, latexDraw::parsers::pstricks::PSTricksParameters::dbleLine, latexDraw::parsers::pstricks::PSTricksParameters::dbleSep, latexDraw::parsers::pstricks::PSTricksParameters::dotAngle, latexDraw::parsers::pstricks::PSTricksParameters::dotScale1, latexDraw::parsers::pstricks::PSTricksParameters::dotScale2, latexDraw::parsers::pstricks::PSTricksParameters::dotStep, latexDraw::parsers::pstricks::PSTricksParameters::dotStyle, latexDraw::parsers::pstricks::PSTricksParameters::dxIncrement, latexDraw::parsers::pstricks::PSTricksParameters::dxLabelDist, latexDraw::parsers::pstricks::PSTricksParameters::dyIncrement, latexDraw::parsers::pstricks::PSTricksParameters::dyLabelDist, latexDraw::parsers::pstricks::PSTricksParameters::fillColor, latexDraw::parsers::pstricks::PSTricksParameters::fillStyle, latexDraw::parsers::pstricks::PSTricksParameters::frameArc, latexDraw::parsers::pstricks::PSTricksParameters::frameSep, latexDraw::parsers::pstricks::PSTricksParameters::gangle, latexDraw::parsers::pstricks::PSTricksParameters::gradAngle, latexDraw::parsers::pstricks::PSTricksParameters::gradBegin, latexDraw::parsers::pstricks::PSTricksParameters::gradEnd, latexDraw::parsers::pstricks::PSTricksParameters::gradLines, latexDraw::parsers::pstricks::PSTricksParameters::gradMidPoint, latexDraw::parsers::pstricks::PSTricksParameters::gridColor, latexDraw::parsers::pstricks::PSTricksParameters::gridDots, latexDraw::parsers::pstricks::PSTricksParameters::gridLabel, latexDraw::parsers::pstricks::PSTricksParameters::gridWidth, latexDraw::parsers::pstricks::PSTricksParameters::hatchAngle, latexDraw::parsers::pstricks::PSTricksParameters::hatchCol, latexDraw::parsers::pstricks::PSTricksParameters::hatchSep, latexDraw::parsers::pstricks::PSTricksParameters::hatchWidth, latexDraw::parsers::pstricks::PSTricksParameters::isCornerRel, latexDraw::parsers::pstricks::PSTricksParameters::isShadow, latexDraw::parsers::pstricks::PSTricksParameters::labels, latexDraw::parsers::pstricks::PSTricksParameters::labelsGridCol, latexDraw::parsers::pstricks::PSTricksParameters::lineArc, latexDraw::parsers::pstricks::PSTricksParameters::lineColor, latexDraw::parsers::pstricks::PSTricksParameters::lineStyle, latexDraw::parsers::pstricks::PSTricksParameters::lineWidth, latexDraw::parsers::pstricks::PSTricksParameters::origin, latexDraw::parsers::pstricks::PSTricksParameters::ox, latexDraw::parsers::pstricks::PSTricksParameters::oy, latexDraw::parsers::pstricks::PSTricksParameters::shadowAngle, latexDraw::parsers::pstricks::PSTricksParameters::shadowCol, latexDraw::parsers::pstricks::PSTricksParameters::shadowSize, latexDraw::parsers::pstricks::PSTricksParameters::showOrigin, latexDraw::parsers::pstricks::PSTricksParameters::showPoints, latexDraw::parsers::pstricks::PSTricksParameters::subGridCol, latexDraw::parsers::pstricks::PSTricksParameters::subGridDiv, latexDraw::parsers::pstricks::PSTricksParameters::subGridDots, latexDraw::parsers::pstricks::PSTricksParameters::subGridWidth, latexDraw::parsers::pstricks::PSTricksParameters::swapAxes, latexDraw::parsers::pstricks::PSTricksParameters::ticks, latexDraw::parsers::pstricks::PSTricksParameters::ticksSize, latexDraw::parsers::pstricks::PSTricksParameters::ticksStyle, latexDraw::parsers::pstricks::PSTricksParameters::unit, latexDraw::parsers::pstricks::PSTricksParameters::xUnit, and latexDraw::parsers::pstricks::PSTricksParameters::yUnit.

Referenced by parseParametersCircle(), parseParametersDot(), and parseParametersFrameEllipse().

      {
            int size = params.length(); 
            int id[] = {0};
            PSTricksParameters p = applyParams ? pstp : new PSTricksParameters(pstp);
      
            while(id[0]<params.length())
            {
                  try
                  {
                        switch(params.charAt(id[0]))
                        {
                              case 's' : 
                                    if(++id[0]>size) throw new IgnoreCommandException(-1);
                                    switch(params.charAt(id[0]))
                                    {
                                          case 'h' : //sh
                                                if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                switch(params.charAt(id[0]))
                                                {
                                                      case 'a' : // sha
                                                            if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                            
                                                            if(params.charAt(++id[0])=='d' && params.charAt(++id[0])=='o' && 
                                                                  params.charAt(++id[0])=='w') // shadow
                                                            {
                                                                  if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                  switch(params.charAt(id[0]))
                                                                  {
                                                                        case 's' : // shadowsize = Real unit
                                                                              if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='i' && params.charAt(++id[0])=='z' && 
                                                                                    params.charAt(++id[0])=='e' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.shadowSize = readEqualRealUnit(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'a' : // shadowangle = Real
                                                                              if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='n' && params.charAt(++id[0])=='g' && 
                                                                                    params.charAt(++id[0])=='l' && params.charAt(++id[0])=='e' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.shadowAngle = readEqualReal(id, params);
                                                                                    goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'c' : // shadowcolor = String
                                                                              if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='l' && 
                                                                                    params.charAt(++id[0])=='o' && params.charAt(++id[0])=='r' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    String s2 = readEqualString(id, params, true);
                                                                                    Color c = DviPsColors.getColour(s2); // We search the colour
                                                                                    if(c!=null) p.shadowCol = c;
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                        
                                                                        default : 
                                                                              if((params.charAt(id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {// shadow
                                                                                    String s = readEqualString(id, params, false);
                                                                                    if(s.equals("true"))           p.isShadow = true;//$NON-NLS-1$
                                                                                    else if(s.equals("false")) p.isShadow = false;//$NON-NLS-1$
                                                                                          
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                              }
                                                                              else
                                                                                    throw new IgnoreCommandException(-1);
                                                                  }
                                                            }else throw new IgnoreCommandException(-1);
                                                            break;
                                                            
                                                      case 'o' : // sho
                                                            if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                                            
                                                            if(params.charAt(++id[0])=='w')//show
                                                            {
                                                                  if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                                                  
                                                                  switch(params.charAt(++id[0]))
                                                                  {
                                                                        case 'p'://showp
                                                                              if(id[0]+6>size) throw new IgnoreCommandException(-1);
                                                                              if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='i' && 
                                                                                    params.charAt(++id[0])=='n' && params.charAt(++id[0])=='t' && 
                                                                                    params.charAt(++id[0])=='s' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {//showpoints = true|false
                                                                                    String s = readEqualString(id, params, false);
                                                                                    if(s.equals("true"))           p.showPoints = true;//$NON-NLS-1$
                                                                                    else if(s.equals("false")) p.showPoints = false;//$NON-NLS-1$
                                                                                          
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                              }
                                                                              else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'o'://showo
                                                                              if(id[0]+6>size) throw new IgnoreCommandException(-1);
                                                                              if(params.charAt(++id[0])=='r' && params.charAt(++id[0])=='i' && 
                                                                                    params.charAt(++id[0])=='g' && params.charAt(++id[0])=='i' && 
                                                                                    params.charAt(++id[0])=='n' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {//showorigin = true|false
                                                                                    String s = readEqualString(id, params, false);
                                                                                    if(s.equals("true"))           p.showOrigin = true;//$NON-NLS-1$
                                                                                    else if(s.equals("false")) p.showOrigin = false;//$NON-NLS-1$
                                                                                          
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                              }
                                                                              else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        default: throw new IgnoreCommandException(-1);
                                                                  }
                                                                  
                                                            }else throw new IgnoreCommandException(-1);
                                                            break;
                                                            
                                                      default : throw new IgnoreCommandException(-1);
                                                }
                                                break;
                                                
                                          case 'u' : // su
                                                if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='b' && params.charAt(++id[0])=='g' && 
                                                      params.charAt(++id[0])=='r' && params.charAt(++id[0])=='i' && 
                                                      params.charAt(++id[0])=='d') // subgrid
                                                {
                                                      if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                      switch(params.charAt(id[0]))
                                                      {
                                                            case 'd' : // subgridd
                                                                  if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                  switch(params.charAt(id[0]))
                                                                  {
                                                                        case 'o' : // subgriddots = Integer
                                                                              if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='t' && params.charAt(++id[0])=='s' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.subGridDots = readEqualInteger(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id);
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'i' : // subgriddiv = Integer
                                                                              if(id[0]+2>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='v' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.subGridDiv = readEqualInteger(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id);
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                        
                                                                        default : throw new IgnoreCommandException(-1);
                                                                  }
                                                                  break;
                                                                  
                                                            case 'w' : // subgridwidth = Real unit
                                                                  if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                  
                                                                  if(params.charAt(++id[0])=='i' && params.charAt(++id[0])=='d' && 
                                                                        params.charAt(++id[0])=='t' && params.charAt(++id[0])=='h' && 
                                                                        (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                  {
                                                                        p.subGridWidth = readEqualRealUnit(id, params);
                                                                        if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                        
                                                                  }else throw new IgnoreCommandException(-1);
                                                                  break;
                                                                  
                                                            case 'c': // subgridcolor = String
                                                                  if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                  
                                                                  if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='l' && 
                                                                        params.charAt(++id[0])=='o' && params.charAt(++id[0])=='r' && 
                                                                        (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                  {
                                                                        String s2 = readEqualString(id, params, true);
                                                                        Color c = DviPsColors.getColour(s2); // We search the colour
                                                                        if(c!=null) p.subGridCol = c;
                                                                        if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                        
                                                                  }else throw new IgnoreCommandException(-1);
                                                                  break;
                                                                  
                                                            default : throw new IgnoreCommandException(-1);
                                                      }
                                                }else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          case 'w' : // swapaxes = true|false
                                                if(id[0]+7>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='a' && params.charAt(++id[0])=='p' && 
                                                      params.charAt(++id[0])=='a' && params.charAt(++id[0])=='x' && 
                                                      params.charAt(++id[0])=='e' && params.charAt(++id[0])=='s' && 
                                                      (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                {
                                                      String s = readEqualString(id, params, false);
                                                      if(s.equals("true"))           p.swapAxes = true;//$NON-NLS-1$
                                                      else if(s.equals("false")) p.swapAxes = false;//$NON-NLS-1$
                                                            
                                                      if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                      
                                                }else throw new IgnoreCommandException(-1);
                                                break;
                                    
                                          default : throw new IgnoreCommandException(-1);
                                    }
                                    break;
                                    
                              case 'd' : 
                                    if(++id[0]>size) throw new IgnoreCommandException(-1);
                                    switch(params.charAt(id[0]))
                                    {
                                          case 'o' : // do
                                                if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                switch(params.charAt(id[0]))
                                                {
                                                      case 't' : // dot
                                                            if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                            switch(params.charAt(id[0]))
                                                            {
                                                                  case 's' : // dots
                                                                        if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                        switch(params.charAt(id[0]))
                                                                        {
                                                                              case 'i' : //dotsize = Real unit Real
                                                                                    if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                                                    
                                                                                    if(params.charAt(++id[0])=='z' && params.charAt(++id[0])=='e' && 
                                                                                          (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                                    {
                                                                                          p.arrowDotSD = readEqualRealUnit(id, params);
                                                                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token

                                                                                          if(id[0]<size && (Character.isDigit(
                                                                                                                  params.charAt(id[0])) || params.charAt(id[0])=='.')) 
                                                                                                p.arrowDotSN = readReal(params, id, true);// If there is the x, we read it
                                                                                          else p.arrowDotSN = 0;

                                                                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                          
                                                                                    }else throw new IgnoreCommandException(-1);
                                                                                    break;
                                                                                    
                                                                              case 't' : // dotstyle = String
                                                                                    if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                                                                    
                                                                                    if(params.charAt(++id[0])=='y' && params.charAt(++id[0])=='l' && 
                                                                                          params.charAt(++id[0])=='e' && 
                                                                                          (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                                    {
                                                                                          while(id[0]<size && params.charAt(id[0])!='=') id[0]++; // We search the '='
                                                                                          if(id[0]>=size) throw new IgnoreCommandException(-1);
                                                                                          id[0]++;
                                                                                          
                                                                                          goToNextChar(params, id); // We go to the next token
                                                                                          
                                                                                          String s;
                                                                                          
                                                                                          if(params.charAt(id[0])=='|' || params.charAt(id[0])=='+')
                                                                                                 s = String.valueOf(params.charAt(id[0]++));
                                                                                          else
                                                                                          {
                                                                                                s = readString(params, id, false);
                                                                                                if(id[0]<size && params.charAt(id[0])=='*')
                                                                                                      s+=String.valueOf(params.charAt(id[0]++));
                                                                                          }
                                                                                          
                                                                                          if(!PSTricksConstants.isValidDotStyle(s))
                                                                                                throw new IgnoreCommandException(-1);
                                                                                                
                                                                                          p.dotStyle = s;
                                                                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','

                                                                                    }else throw new IgnoreCommandException(-1);
                                                                                    break;
                                                                                    
                                                                              case 'c' : // dotscale = Real Real
                                                                                    if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                                                                    
                                                                                    if(params.charAt(++id[0])=='a' && params.charAt(++id[0])=='l' && 
                                                                                          params.charAt(++id[0])=='e' && 
                                                                                          (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                                    {
                                                                                          p.dotScale1 = readEqualReal(id, params); // We read the first parameter
                                                                                          
                                                                                          goToNextChar(params, id); // We go to the next token
                                                                                          if(id[0]<size && (Character.isDigit(
                                                                                                                  params.charAt(id[0])) || params.charAt(id[0])=='.')) 
                                                                                                p.dotScale2 = readReal(params, id, true);// If there is the x, we read it
                                                                                          else p.dotScale2 = 1;
                                                                                          
                                                                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                                          
                                                                                    }else throw new IgnoreCommandException(-1);
                                                                                    break;
                                                                                    
                                                                              case 'e' : // dotsep = Real unit
                                                                                    if(id[0]+2>size) throw new IgnoreCommandException(-1);

                                                                                    if(params.charAt(++id[0])=='p' && 
                                                                                          (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                                    {
                                                                                          p.dotStep = readEqualRealUnit(id, params);
                                                                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    } else throw new IgnoreCommandException(-1);
                                                                                    break;
                                                                        
                                                                              default : throw new IgnoreCommandException(-1);
                                                                        }
                                                                        break;
                                                                        
                                                                  case 'a' : // dotangle = Real
                                                                        
                                                                        if(id[0]+5>size) throw new IgnoreCommandException(-1);

                                                                        if(params.charAt(++id[0])=='n' && params.charAt(++id[0])=='g' &&
                                                                              params.charAt(++id[0])=='l' && params.charAt(++id[0])=='e' &&
                                                                              (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                        {
                                                                              p.dotAngle = readEqualReal(id, params);
                                                                  
                                                                              if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                        }else throw new IgnoreCommandException(-1);
                                                                        break;
                                                            
                                                                  default : throw new IgnoreCommandException(-1);
                                                            }
                                                            break;
                                                            
                                                      case 'u' : // dou
                                                            if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                            
                                                            if(params.charAt(++id[0])=='b' && params.charAt(++id[0])=='l' && 
                                                                  params.charAt(++id[0])=='e') // double
                                                            {
                                                                  if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                  switch(params.charAt(id[0]))
                                                                  {
                                                                        case 'l' : // doubleline = true/false
                                                                              if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='i' && params.charAt(++id[0])=='n' &&
                                                                                    params.charAt(++id[0])=='e' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    String s = readEqualString(id, params, false);
                                                                                    if(s.equals("true"))           p.dbleLine = true;//$NON-NLS-1$
                                                                                    else if(s.equals("false")) p.dbleLine = false;//$NON-NLS-1$
                                                                                    
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 's' : // doublesep = Real unit
                                                                              if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='e' && params.charAt(++id[0])=='p' &&
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.dbleSep = readEqualRealUnit(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'c' : // doubleColor = String
                                                                              if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='l' &&
                                                                                    params.charAt(++id[0])=='o' && params.charAt(++id[0])=='r' &&
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    String s2 = readEqualString(id, params, true);
                                                                                    Color c = DviPsColors.getColour(s2); // We search the colour
                                                                                    if(c!=null) p.dbleColor = c;
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                        
                                                                        default : throw new IgnoreCommandException(-1);
                                                                  }
                                                            }else throw new IgnoreCommandException(-1);
                                                            break;
                                                      
                                                      default : throw new IgnoreCommandException(-1);
                                                }
                                                break;
                                                
                                          case 'i' : // dimen = outer|inner|middle
                                                if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='m' && params.charAt(++id[0])=='e' && 
                                                      params.charAt(++id[0])=='n' && 
                                                      (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                {
                                                      String s = readEqualString(id, params, false);
                                                      
                                                      if(s.equals(PSTricksConstants.BORDERS_INSIDE) ||
                                                            s.equals(PSTricksConstants.BORDERS_MIDDLE) ||
                                                            s.equals(PSTricksConstants.BORDERS_OUTSIDE))
                                                      {
                                                            p.borderPos = s;
                                                            if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                            
                                                      }else throw new IgnoreCommandException(-1);
                                                }else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          case 'a' : // dash = Real unit Real unit
                                                if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='s' && params.charAt(++id[0])=='h' && 
                                                      (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                {
                                                      
                                                      double r1 = readEqualRealUnit(id, params);
                                                      double r2 = readRealUnit(id, params, true); // We read the second parameter
                                                      
                                                      p.dashBlack = r1;
                                                      p.dashWhite = r2;
                                                      
                                                      if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                      
                                                }else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          case 'x'://dx = real unit
                                                if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                                
                                                if((params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                {
                                                      p.dxLabelDist = readEqualRealUnit(id, params);
                                                      if(id[0]<size) goToNextChar(params, id);
                                                }
                                                else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          case 'y'://dy = real unit
                                                if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                                
                                                if((params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                {
                                                      p.dyLabelDist = readEqualRealUnit(id, params);
                                                      if(id[0]<size) goToNextChar(params, id);
                                                }
                                                else throw new IgnoreCommandException(-1);
                                                break;
                                    
                                          default : throw new IgnoreCommandException(-1);
                                    }
                                    break;
                                    
                              case 'a' : 
                                    if(++id[0]>size) throw new IgnoreCommandException(-1);
                                    
                                    switch(params.charAt(id[0]))
                                    {
                                          case 'r':
                                                if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                switch(params.charAt(id[0]))
                                                {
                                                      case 'c' : //arc
                                                            if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                            
                                                            if(params.charAt(++id[0])=='s' && params.charAt(++id[0])=='e' && 
                                                                  params.charAt(++id[0])=='p') // arcsep
                                                            {
                                                                  if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                  
                                                                  switch(params.charAt(id[0]))
                                                                  {
                                                                        case 'A' : // arcsepA = Real unit
                                                                              p.arcSepA = readEqualRealUnit(id, params);
                                                                              if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                              break;
                                                                                    
                                                                        case 'B' : // arcSepB = Real unit
                                                                              p.arcSepB = readEqualRealUnit(id, params);
                                                                              if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                              break;
                                                                  
                                                                        default : 
                                                                              if(params.charAt(id[0])=='=' || isCharToIgnore(params.charAt(id[0])))
                                                                              { // arcsep = Real
                                                                                    p.arcSep = readEqualReal(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                  }
                                                            }else throw new IgnoreCommandException(-1);
                                                            
                                                            break;
                                                            
                                                      case 'r' : //arr
                                                            if(id[0]+2>size) throw new IgnoreCommandException(-1);
                                                      
                                                            if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='w')
                                                            { // arrow
                                                                  if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                  
                                                                  switch(params.charAt(id[0]))
                                                                  {
                                                                        case 's' : // arrows
                                                                              
                                                                              if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              switch(params.charAt(id[0]))
                                                                              {
                                                                                    case 'i' : // arrowsize= Real unit Real
                                                                        
                                                                                                if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                                                                
                                                                                                if(params.charAt(++id[0])=='z' && params.charAt(++id[0])=='e' && 
                                                                                                      (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                                                {
                                                                                                      p.arrowSizeD = readEqualRealUnit(id, params);
                                                                                                      goToNextChar(params, id); // We go to the next token
                                                                                                      if(id[0]<size && (Character.isDigit(params.charAt(id[0])) || params.charAt(id[0])=='.')) 
                                                                                                            p.arrowSizeN = readReal(params, id, true);// If there is the x, we read it
                                                                                                      
                                                                                                      if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                                                      
                                                                                                }else throw new IgnoreCommandException(-1);
                                                                                                break;
                                                                                          
                                                                                    case '=':
                                                                                                id[0]++;
                                                                                                goToNextChar(params, id);
                                                                                                char str = params.charAt(id[0]);
                                                                                                
                                                                                                if(str!='-')
                                                                                                {
                                                                                                      p.arrowStyle[0] = String.valueOf(str);
                                                                                                      id[0]++;
                                                                                                      goToNextChar(params, id);
                                                                                                      
                                                                                                      if(params.charAt(id[0])!='-')
                                                                                                            throw new IgnoreCommandException(-1);
                                                                                                }
                                                                                                
                                                                                                id[0]++;
                                                                                                goToNextChar(params, id);
                                                                                                
                                                                                                if(id[0]<params.length())
                                                                                                {
                                                                                                      str = params.charAt(id[0]);
                                                                                                      
                                                                                                      if(str!=',' || str!=']')
                                                                                                            p.arrowStyle[1] = String.valueOf(str);
                                                                                                      
                                                                                                      id[0]++;
                                                                                                }
                                                                                                break;
                                                                                                
                                                                                    default: throw new IgnoreCommandException(-1);
                                                                              }
                                                                              break;
                                                                              
                                                                        case 'l' : // arrowlength = Real
                                                                              if(id[0]+6>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='e' && params.charAt(++id[0])=='n' && 
                                                                                    params.charAt(++id[0])=='g' && params.charAt(++id[0])=='t' && 
                                                                                    params.charAt(++id[0])=='h' &&
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.arrowLgth = readEqualReal(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'i' : // arrowinset = Real
                                                                              if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='n' && params.charAt(++id[0])=='s' && 
                                                                                    params.charAt(++id[0])=='e' && params.charAt(++id[0])=='t' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.arrowInset = readEqualReal(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                        
                                                                        default : throw new IgnoreCommandException(-1);
                                                                  } // switch(params.charAt(id[0]))
                                                            }else throw new IgnoreCommandException(-1);
                                                            break;
                                                            
                                                      default : throw new IgnoreCommandException(-1);
                                                } // switch(params.charAt(id[0]))
                                                break;
                                                
                                          case 'x': // ax
                                                
                                                if(id[0]+6>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='e' && params.charAt(++id[0])=='s' && 
                                                      params.charAt(++id[0])=='s' &&
                                                      params.charAt(++id[0])=='t' && params.charAt(++id[0])=='y' && 
                                                      params.charAt(++id[0])=='l' && params.charAt(++id[0])=='e' && 
                                                      (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                {// axestyle
                                                      p.axesStyle = readEqualString(id, params, true);
                                                      if(id[0]<size) goToNextChar(params, id);
                                                }
                                                else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          default : throw new IgnoreCommandException(-1);
                                    }
                                    break;
                                                
                                    
                              case 'g' :
                                    
                                    if(++id[0]>size) throw new IgnoreCommandException(-1);
                                    
                                    switch(params.charAt(id[0]))
                                    {
                                          case 'r' : //gr
                                                if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                
                                                switch(params.charAt(id[0]))
                                                {
                                                      case 'i':
                                                            if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                                            if(params.charAt(++id[0])=='d')// grid
                                                            { 
                                                                  if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                  
                                                                  switch(params.charAt(id[0]))
                                                                  {
                                                                        case 'l' ://gridl
                                                                              if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='a' && params.charAt(++id[0])=='b' && 
                                                                                    params.charAt(++id[0])=='e' && params.charAt(++id[0])=='l')// gridlabel
                                                                              { 
                                                                                    if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                                    
                                                                                    switch(params.charAt(id[0]))
                                                                                    {
                                                                                          case 's' : // gridlabels = Real unit
                                                                                                p.gridLabel = readEqualRealUnit(id, params);
                                                                                                if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                                break;
                                                                                                
                                                                                          case 'c' : // gridlabelcolor = string
                                                                                                String s = readEqualString(id, params, true);
                                                                                                Color c = DviPsColors.getColour(s); // We search the colour
                                                                                                if(c!=null) p.labelsGridCol = c;
                                                                                                if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                                break;
                                                                                          
                                                                                          default : throw new IgnoreCommandException(-1);
                                                                                    }
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'w' : //gridwidth = Real unit
                                                                              if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='i' && params.charAt(++id[0])=='d' && 
                                                                                    params.charAt(++id[0])=='t' && params.charAt(++id[0])=='h' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.gridWidth = readEqualRealUnit(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'c' : // gridcolor = string
                                                                              if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='l' && 
                                                                                    params.charAt(++id[0])=='o' && params.charAt(++id[0])=='r' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    String s = readEqualString(id, params, true);
                                                                                    Color c = DviPsColors.getColour(s); // We search the colour
                                                                                    if(c!=null) p.gridColor = c;
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'd' : // griddots = Integer
                                                                              if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                                                              
                                                                              if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='t' && 
                                                                                    params.charAt(++id[0])=='s' &&
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.gridDots = readEqualInteger(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        default : throw new IgnoreCommandException(-1);
                                                                  }
                                                            }else throw new IgnoreCommandException(-1);
                                                            break;
                                                      
                                                      case 'a'://gra
                                                            if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                            if(params.charAt(id[0])=='d')// grad
                                                            { 
                                                                  if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                  switch(params.charAt(id[0]))
                                                                  {
                                                                        case 'b' : //gradbegin
                                                                              if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                              if(params.charAt(++id[0])=='e' && params.charAt(++id[0])=='g' && 
                                                                              params.charAt(++id[0])=='i' && params.charAt(++id[0])=='n' && 
                                                                              (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    String r = readEqualString(id, params, true);
                                                                                    Color c = DviPsColors.getColour(r); // We search the colour
                                                                                    if(c!=null) p.gradBegin = c;
                                                                                    
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                        
                                                                        case 'e' : //gradend
                                                                              if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                                              if(params.charAt(++id[0])=='n' && params.charAt(++id[0])=='d' && 
                                                                              (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    String r = readEqualString(id, params, true);
                                                                                    Color c = DviPsColors.getColour(r); // We search the colour
                                                                                    if(c!=null) p.gradEnd = c;
                                                                                    
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                                    
                                                                              }else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'l' : //gradlines
                                                                              if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                              if(params.charAt(++id[0])=='i' && params.charAt(++id[0])=='n' && 
                                                                                    params.charAt(++id[0])=='e' && params.charAt(++id[0])=='s' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                                    {
                                                                                          p.gradLines = readEqualInteger(id, params);
                                                                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                                          
                                                                                    } else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'm' : //gradmidpoint
                                                                              if(id[0]+9>size) throw new IgnoreCommandException(-1);
                                                                              if(params.charAt(++id[0])=='i' && params.charAt(++id[0])=='d' && 
                                                                                    params.charAt(++id[0])=='p' && params.charAt(++id[0])=='o' && 
                                                                                    params.charAt(++id[0])=='i' && params.charAt(++id[0])=='n' && 
                                                                                    params.charAt(++id[0])=='t' &&
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                                    {
                                                                                          double midPt = readEqualReal(id, params);
                                                                                          if(midPt>=0 && midPt<=1)
                                                                                                p.gradMidPoint = midPt;
                                                                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                                          
                                                                                    } else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                              
                                                                        case 'a' : //gradangle
                                                                              if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                              if(params.charAt(++id[0])=='n' && params.charAt(++id[0])=='g' && 
                                                                                    params.charAt(++id[0])=='l' && params.charAt(++id[0])=='e' && 
                                                                                    (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                                    {
                                                                                          p.gradAngle = readEqualReal(id, params);
                                                                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                                          
                                                                                    } else throw new IgnoreCommandException(-1);
                                                                              break;
                                                                  
                                                                        default : throw new IgnoreCommandException(-1);
                                                                  }
                                                            }else throw new IgnoreCommandException(-1);
                                                            
                                                            break;
                                                            
                                                      default : throw new IgnoreCommandException(-1);
                                                }
                                                break;      
                                                
                                          case 'a' : //gangle
                                                if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='n' && params.charAt(++id[0])=='g' && 
                                                      params.charAt(++id[0])=='l' && params.charAt(++id[0])=='e' && 
                                                      (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                      {
                                                            p.gangle = readEqualReal(id, params);
                                                            if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                            
                                                      } else throw new IgnoreCommandException(-1);
                                                break;
                                                      
                                          default : throw new IgnoreCommandException(-1);
                                    }
                                    
                                    
                                    
                                    break;
                                    
                              case 'l' : 
                                    if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                    
                                    switch(params.charAt(++id[0]))
                                    {
                                          case 'i':// li
                                                if(id[0]+2>size) throw new IgnoreCommandException(-1);
                                                if(params.charAt(++id[0])=='n' && params.charAt(++id[0])=='e')// line
                                                { 
                                                      if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                      
                                                      switch(params.charAt(id[0]))
                                                      {
                                                            case 'w' : // linewidth = Real unit
                                                                  if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                  
                                                                  if(params.charAt(++id[0])=='i' && params.charAt(++id[0])=='d' && 
                                                                        params.charAt(++id[0])=='t' && params.charAt(++id[0])=='h' &&
                                                                        (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                  {
                                                                        p.lineWidth = readEqualRealUnit(id, params);
                                                                        if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                        
                                                                  }else throw new IgnoreCommandException(-1);
                                                                  break;
                                                                  
                                                            case 'c' : // lineColor = string
                                                                  if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                  
                                                                  if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='l' && 
                                                                        params.charAt(++id[0])=='o' && params.charAt(++id[0])=='r' &&
                                                                        (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                  {
                                                                        String r = readEqualString(id, params, true);
                                                                        Color c = DviPsColors.getColour(r); // We search the colour
                                                                        if(c!=null) p.lineColor = c;
                                                                        
                                                                        if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                        
                                                                  }else throw new IgnoreCommandException(-1);
                                                                  break;
                                                                  
                                                            case 'a' : // linearc = Real unit
                                                                  if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                                  
                                                                  if(params.charAt(++id[0])=='r' && params.charAt(++id[0])=='c' && 
                                                                        (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                  {
                                                                        p.lineArc = readEqualRealUnit(id, params);
                                                                        if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                        
                                                                  }else throw new IgnoreCommandException(-1);
                                                                  break;
                                                                  
                                                            case 's' : // linestyle = string
                                                                  if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                  
                                                                  if(params.charAt(++id[0])=='t' && params.charAt(++id[0])=='y' && 
                                                                        params.charAt(++id[0])=='l' && params.charAt(++id[0])=='e' && 
                                                                        (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                  {
                                                                        p.lineStyle = readEqualString(id, params, false);
                                                                        if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                  }
                                                                  else throw new IgnoreCommandException(-1);
                                                                  break;
                                                      
                                                            default : throw new IgnoreCommandException(-1);
                                                      }
                                                }else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          case 'a':// la
                                                if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                if(params.charAt(++id[0])=='b' && params.charAt(++id[0])=='e' &&
                                                      params.charAt(++id[0])=='l' && params.charAt(++id[0])=='s'&& 
                                                      (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                { 
                                                      p.labels = readEqualString(id, params, false);
                                                      if(id[0]<size) goToNextChar(params, id);
                                                }
                                                else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          default : throw new IgnoreCommandException(-1);
                                    }
                                    
                                    break;
                                    
                              case 'f' :
                                    if(++id[0]>size) throw new IgnoreCommandException(-1);
                                    
                                    switch(params.charAt(id[0]))
                                    {
                                          case 'i': //fi
                                                if(id[0]+2>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='l' && params.charAt(++id[0])=='l')//fill
                                                {
                                                      if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                      if(params.charAt(id[0])=='c')//fillc
                                                      {
                                                            if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                            
                                                            if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='l' && 
                                                                  params.charAt(++id[0])=='o' && params.charAt(++id[0])=='r' && 
                                                                  (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                            { // fillColor = string
                                                                  String r = readEqualString(id, params, true);
                                                                  Color c = DviPsColors.getColour(r); // We search the colour
                                                                  if(c!=null) p.fillColor = c;

                                                                  if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                  
                                                            }else throw new IgnoreCommandException(-1);
                                                      }else
                                                      if(params.charAt(id[0])=='s')//fills
                                                      {
                                                            if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                            
                                                            if(params.charAt(++id[0])=='t' && params.charAt(++id[0])=='y' && 
                                                                  params.charAt(++id[0])=='l' && params.charAt(++id[0])=='e' && 
                                                                  (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                            { // fillstyle = string
                                                                  String r = readEqualString(id, params, false);
                                                                  
                                                                  if(id[0]<size && params.charAt(id[0])=='*') // We add the '*' the fillstyle
                                                                  {
                                                                        r+=String.valueOf(params.charAt(id[0]));
                                                                        id[0]++;
                                                                  }
                                                                  
                                                                  p.fillStyle = r;
                                                                  if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                  
                                                            }else throw new IgnoreCommandException(-1);
                                                      }else throw new IgnoreCommandException(-1);
                                                }else throw new IgnoreCommandException(-1);
                                                
                                                break;
                                                
                                          case 'r': //fr 
                                                
                                                if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='a' && params.charAt(++id[0])=='m' && params.charAt(++id[0])=='e')
                                                {//frame
                                                      if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                                      
                                                      switch(params.charAt(++id[0]))
                                                      {
                                                            case 'a' : // framearc
                                                                  if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                                  if(params.charAt(++id[0])=='r' && params.charAt(++id[0])=='c' && 
                                                                        (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.frameArc = readEqualReal(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                                    
                                                                              } else throw new IgnoreCommandException(-1);
                                                                  break;
                                                                  
                                                            case 's' : // framesep
                                                                  if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                                  if(params.charAt(++id[0])=='e' && params.charAt(++id[0])=='p' && 
                                                                        (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                              {
                                                                                    p.frameSep = readEqualRealUnit(id, params);
                                                                                    if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                                    
                                                                              } else throw new IgnoreCommandException(-1);
                                                                  break;
                                                                  
                                                            default :
                                                                  throw new IgnoreCommandException(-1);
                                                      }
                                                }else throw new IgnoreCommandException(-1);
                                                      
                                                break;
                                                
                                          default : throw new IgnoreCommandException(-1);
                                    }
                                    break;
                                    
                              case 'b' :
                                    if(++id[0]>size) throw new IgnoreCommandException(-1);
                                    
                                    switch(params.charAt(id[0]))
                                    {
                                          case 'o' ://bo
                                                if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                                
                                                switch(params.charAt(++id[0]))
                                                {
                                                      case 'r'://bor
                                                            if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                            
                                                            if(params.charAt(++id[0])=='d' && params.charAt(++id[0])=='e' &&
                                                                  params.charAt(++id[0])=='r')//border
                                                            {
                                                                  if(++id[0]>size) throw new IgnoreCommandException(-1);
                                                                  if(params.charAt(id[0])=='c')//borderc
                                                                  {
                                                                        if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                                        if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='l' && params.charAt(++id[0])=='o' &&
                                                                              params.charAt(++id[0])=='r' && (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                        { // bordercolor = string
                                                                              String r = readEqualString(id, params, true);
                                                                              Color c = DviPsColors.getColour(r); // We search the colour
                                                                              if(c!=null) p.borderColor = c;
                                                                              if(id[0]<size) goToNextChar(params, id);
                                                                              
                                                                        }else throw new IgnoreCommandException(-1);
                                                                  }else
                                                                        if(params.charAt(id[0])=='=' || isCharToIgnore(params.charAt(id[0])))
                                                                        {// border = Real unit
                                                                              p.border = readEqualRealUnit(id, params);
                                                                              if(id[0]<size) goToNextChar(params, id); 
                                                                              
                                                                        }else throw new IgnoreCommandException(-1);
                                                            }else throw new IgnoreCommandException(-1);
                                                            break;
                                                            
                                                      case 'x' ://boxsep
                                                            if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                                            if(params.charAt(++id[0])=='s' && params.charAt(++id[0])=='e' &&
                                                                  params.charAt(++id[0])=='p' && (params.charAt(++id[0])=='=' || 
                                                                  isCharToIgnore(params.charAt(id[0]))))//boxsep
                                                            {
                                                                  String s = readEqualString(id, params, false);
                                                                  if(s.equals("true"))           p.boxSep = true;//$NON-NLS-1$
                                                                  else if(s.equals("false")) p.boxSep = false;//$NON-NLS-1$
                                                                        
                                                                  if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                  
                                                            }else throw new IgnoreCommandException(-1);
                                                            
                                                            break;
                                                            
                                                      default :
                                                            throw new IgnoreCommandException(-1);
                                                }
                                                break;
                                                
                                                
                                          case 'r' :
                                                if(id[0]+12>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='a' && params.charAt(++id[0])=='c' && params.charAt(++id[0])=='k' &&
                                                      params.charAt(++id[0])=='e' && params.charAt(++id[0])=='t' && params.charAt(++id[0])=='l' && 
                                                      params.charAt(++id[0])=='e' && params.charAt(++id[0])=='n' && params.charAt(++id[0])=='g' && 
                                                      params.charAt(++id[0])=='t' && params.charAt(++id[0])=='h' && (params.charAt(++id[0])=='=' || 
                                                      isCharToIgnore(params.charAt(id[0]))))
                                                      {
                                                            p.arrowBrLgth = readEqualReal(id, params);
                                                            if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                            
                                                      } else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          default : throw new IgnoreCommandException(-1);
                                    }
                                    break;
                                    
                              case 'c' :
                                    if(++id[0]>size) throw new IgnoreCommandException(-1);
                                    
                                    switch(params.charAt(id[0]))
                                    {
                                          case 'o' : // cornersize = absolute/relative
                                                if(id[0]+9>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='r' && params.charAt(++id[0])=='n' && params.charAt(++id[0])=='e' &&
                                                      params.charAt(++id[0])=='r' && params.charAt(++id[0])=='s' && params.charAt(++id[0])=='i' &&
                                                      params.charAt(++id[0])=='z' && params.charAt(++id[0])=='e' &&(params.charAt(++id[0])=='=' || 
                                                      isCharToIgnore(params.charAt(id[0]))))
                                                      {
                                                            String r = readString(params, id, false); // We read the parameter
                                                            r = r.toLowerCase();
                                                            if(r.equals(PSTricksConstants.TOKEN_ABSOLUTE))
                                                                  p.isCornerRel = false;
                                                            else if(r.equals(PSTricksConstants.TOKEN_RELATIVE))
                                                                  p.isCornerRel = true;
                                                            
                                                            if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                            
                                                      } else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          case 'u' : // curvate = Real Real Real
                                                if(id[0]+6>size) throw new IgnoreCommandException(-1);
                                                
                                                if(params.charAt(++id[0])=='r' && params.charAt(++id[0])=='v' && params.charAt(++id[0])=='a' &&
                                                      params.charAt(++id[0])=='t' && params.charAt(++id[0])=='e' && (params.charAt(++id[0])=='=' || 
                                                      isCharToIgnore(params.charAt(id[0]))))
                                                      {
                                                            p.curvature1 = readEqualReal(id, params); // We read the first parameter
                                                            p.curvature2 = readReal(params, id, true); // We read the second parameter
                                                            p.curvature3 = readReal(params, id, true); // We read the third parameter
                                                            if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                            
                                                      } else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          default : throw new IgnoreCommandException(-1);
                                    }
                                    break;
                                    
                              case 'o' : // origin = {Real unit, Real unit}
                              
                                    if(id[0]+6>size) throw new IgnoreCommandException(-1);
                                    
                                    if(params.charAt(++id[0])=='r' && params.charAt(++id[0])=='i' && params.charAt(++id[0])=='g' &&
                                          params.charAt(++id[0])=='i' && params.charAt(++id[0])=='n' && (params.charAt(++id[0])=='=' || 
                                          isCharToIgnore(params.charAt(id[0]))))
                                    {
                                          readChar(params, '=', id);
                                          readChar(params, '{', id);

                                          double x=Double.NaN, y=Double.NaN;
                                          
                                          goToNextChar(params, id); // We go to the next token
                                          if(id[0]<size && (Character.isDigit(params.charAt(id[0])) || params.charAt(id[0])=='.' || 
                                                params.charAt(id[0])=='-'))
                                                x = readRealUnit(id, params, true);// If there is the x, we read it
                                          
                                          readChar(params, ',', id);
                                          
                                          goToNextChar(params, id); // We go to the next token
                                          if(id[0]<size && (Character.isDigit(params.charAt(id[0])) || params.charAt(id[0])=='.' || 
                                                params.charAt(id[0])=='-')) 
                                                y = readRealUnit(id, params, true);// If there is the y, we read it
                                          
                                          readChar(params, '}', id);
                                          
                                          if(!Double.isNaN(x)) p.origin.x = x;
                                          if(!Double.isNaN(y)) p.origin.y = y;
                                          
                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma

                                    }else throw new IgnoreCommandException(-1);
                                    break;
                                    
                              case 'h' : 
                                    
                                    if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                    
                                    if(params.charAt(++id[0])=='a' && params.charAt(++id[0])=='t' && 
                                          params.charAt(++id[0])=='c' && params.charAt(++id[0])=='h')
                                    {
                                          if(++id[0]>size) throw new IgnoreCommandException(-1);
                                          
                                          switch(params.charAt(id[0]))
                                          {
                                                case 'a' : // hatchangle = Real
                                                      if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                      
                                                      if(params.charAt(++id[0])=='n' && params.charAt(++id[0])=='g' && 
                                                            params.charAt(++id[0])=='l' && params.charAt(++id[0])=='e' &&
                                                            (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                            {
                                                                  p.hatchAngle = readEqualReal(id, params);
                                                                  if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                  
                                                            }else throw new IgnoreCommandException(-1);
                                                      break;
                                                
                                                case 'w' : // hatchwidth = Real unit
                                                      if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                      
                                                      if(params.charAt(++id[0])=='i' && params.charAt(++id[0])=='d' && 
                                                            params.charAt(++id[0])=='t' && params.charAt(++id[0])=='h' &&
                                                            (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                            {
                                                                  p.hatchWidth = readEqualRealUnit(id, params);
                                                                  if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                  
                                                            }else throw new IgnoreCommandException(-1);
                                                      break;      
                                                      
                                                case 's' : // hatchsep = Real unit
                                                      if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                      
                                                      if(params.charAt(++id[0])=='e' && params.charAt(++id[0])=='p' && 
                                                            (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                            {
                                                                  p.hatchSep = readEqualRealUnit(id, params);
                                                                  if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                                  
                                                            }else throw new IgnoreCommandException(-1);
                                                      break;
                                                      
                                                case 'c' : // hatchcolor = colour
                                                      if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                                      
                                                      if(params.charAt(++id[0])=='o' && params.charAt(++id[0])=='l' && 
                                                            params.charAt(++id[0])=='o' && params.charAt(++id[0])=='r' &&
                                                            (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                            {
                                                                  String r = readEqualString(id, params, true);
                                                                  Color c = DviPsColors.getColour(r); // We search the colour
                                                                  if(c!=null) p.hatchCol = c;
      
                                                                  if(id[0]<size) goToNextChar(params, id); // We go to the next token : ','
                                                                  
                                                            }else throw new IgnoreCommandException(-1);
                                                      break;      
                                                      
                                                default : throw new IgnoreCommandException(-1);
                                          }
                                    }else throw new IgnoreCommandException(-1);
                                    break;
                        
                              case 'r' :// rbracketlength = Real
                                    
                                    if(id[0]+14>size) throw new IgnoreCommandException(-1);
                                    
                                    if(params.charAt(++id[0])=='b' && params.charAt(++id[0])=='r' && params.charAt(++id[0])=='a' &&
                                          params.charAt(++id[0])=='c' && params.charAt(++id[0])=='k' && params.charAt(++id[0])=='e' &&
                                          params.charAt(++id[0])=='t' && params.charAt(++id[0])=='l' && params.charAt(++id[0])=='e' &&
                                          params.charAt(++id[0])=='n' && params.charAt(++id[0])=='g' && params.charAt(++id[0])=='t' &&
                                          params.charAt(++id[0])=='h' && (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                          {
                                                p.arrowrBrLgth = readEqualReal(id, params);
                                                if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                
                                          } else throw new IgnoreCommandException(-1);
                                    break;
                                    
                              case 't' :
                                    if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                    
                                    switch(params.charAt(++id[0]))
                                    {
                                          case 'b': //tb
                                                if(params.charAt(++id[0])=='a' && params.charAt(++id[0])=='r' &&
                                                      params.charAt(++id[0])=='s' && params.charAt(++id[0])=='i' && params.charAt(++id[0])=='z' &&
                                                      params.charAt(++id[0])=='e' && (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                { // tbarsize = Real unit Real
                                                      p.arrowTBarSD = readEqualRealUnit(id, params);
                                                      if(id[0]<size) goToNextChar(params, id); // We go to the next token
                                                      if(id[0]<size && (Character.isDigit(params.charAt(id[0])) || params.charAt(id[0])=='.')) 
                                                            p.arrowTBarSN = readReal(params, id, true);// If there is the x, we read it
                                                      
                                                      if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                                }
                                                else throw new IgnoreCommandException(-1);
                                                break;
                                                
                                          case 'i': //ti
                                                if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                if(params.charAt(++id[0])=='c' && params.charAt(++id[0])=='k' && 
                                                      params.charAt(++id[0])=='s')
                                                { // ticks
                                                      if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                                      switch(params.charAt(++id[0]))
                                                      {
                                                            case 't'://tickst
                                                                  if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                                                  if(params.charAt(++id[0])=='y' && params.charAt(++id[0])=='l' &&
                                                                        params.charAt(++id[0])=='e' && (params.charAt(++id[0])=='=' || 
                                                                        isCharToIgnore(params.charAt(id[0]))))
                                                                  {//tickstyle = string
                                                                        p.ticksStyle = readString(params, id, false);
                                                                        if(id[0]<size) goToNextChar(params, id);
                                                                  }
                                                                  else throw new IgnoreCommandException(-1);
                                                                  break;
                                                                  
                                                            case 'i'://ticksi
                                                                  if(id[0]+3>size) throw new IgnoreCommandException(-1);
                                                                  if(params.charAt(++id[0])=='z' && params.charAt(++id[0])=='e' &&
                                                                        (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                                                  {//ticksize = real unit
                                                                        p.ticksSize = readEqualRealUnit(id, params);
                                                                        if(id[0]<size) goToNextChar(params, id);
                                                                  }
                                                                  else throw new IgnoreCommandException(-1);
                                                                  break;
                                                                  
                                                            default :
                                                                  if(params.charAt(id[0])=='=' || isCharToIgnore(params.charAt(id[0])))//ticks = string
                                                                  {
                                                                        p.ticks = readString(params, id, false);
                                                                        if(id[0]<size) goToNextChar(params, id);
                                                                  }
                                                                  else throw new IgnoreCommandException(-1);
                                                      }
                                                }
                                                break;
                                    }
                                    break;
                        
                              case 'u' : // unit = Real unit
                                    
                                    if(id[0]+4>size) throw new IgnoreCommandException(-1);
                                    
                                    if(params.charAt(++id[0])=='n' && params.charAt(++id[0])=='i' && 
                                          params.charAt(++id[0])=='t' && (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                    {
                                          double r = readEqualReal(id, params); // We read the parameter
                                          
                                          goToNextChar(params, id); // We go to the next token
                                          
                                          if(id[0]<size && Character.isLetter(params.charAt(id[0])) && params.charAt(id[0])!=',') 
                                          {
                                                String lgth = readString(params, id, false);// If there is a unit of length, we read it
                                                r = convertInCm(r, lgth);
                                                p.unit = r;
                                          }
                                          else
                                                p.unit *= r;
                                          
                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                          
                                    }else throw new IgnoreCommandException(-1);
                                    break;
                                    
                              case 'x' : // xunit = Real unit
                                    
                                    if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                    
                                    if(params.charAt(++id[0])=='u' && params.charAt(++id[0])=='n' && params.charAt(++id[0])=='i' && 
                                          params.charAt(++id[0])=='t' && (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                    {
                                          double r = readEqualReal(id, params); // We read the parameter
                                          goToNextChar(params, id); // We go to the next token
                                          
                                          if(id[0]<size && Character.isLetter(params.charAt(id[0])) && params.charAt(id[0])!=',') 
                                                p.xUnit = convertInCm(r, readString(params, id, false));
                                          else p.xUnit *= r;
                                          
                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                          
                                    }else throw new IgnoreCommandException(-1);
                                    break;
                                    
                              case 'y' : // yunit = Real unit
                                    if(id[0]+5>size) throw new IgnoreCommandException(-1);
                                    
                                    if(params.charAt(++id[0])=='u' && params.charAt(++id[0])=='n' && params.charAt(++id[0])=='i' && 
                                          params.charAt(++id[0])=='t' && (params.charAt(++id[0])=='=' || isCharToIgnore(params.charAt(id[0]))))
                                    {
                                          double r = readEqualReal(id, params); // We read the parameter
                                          goToNextChar(params, id); // We go to the next token
                                          
                                          if(id[0]<size && Character.isLetter(params.charAt(id[0])) && params.charAt(id[0])!=',') 
                                               p.yUnit = convertInCm(r, readString(params, id, false));
                                          else p.yUnit *= r;
                                          
                                          if(id[0]<size) goToNextChar(params, id); // We go to the next token : the comma
                                          
                                    }else throw new IgnoreCommandException(-1);
                                    break;
                                    
                              case 'O': 
                                    if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                    
                                    switch(params.charAt(++id[0]))
                                    {
                                          case 'x': // Ox
                                                p.ox = readEqualReal(id, params);
                                                if(id[0]<size) goToNextChar(params, id);
                                                break;
                                                
                                          case 'y': // Oy
                                                p.oy = readEqualReal(id, params);
                                                if(id[0]<size) goToNextChar(params, id); 
                                                break;
                                                
                                          default: throw new IgnoreCommandException(-1);
                                    }
                                    break;
                                    
                              case 'D':
                                    if(id[0]+1>size) throw new IgnoreCommandException(-1);
                                    
                                    switch(params.charAt(++id[0]))
                                    {
                                          case 'x': // Dx
                                                p.dxIncrement = readEqualReal(id, params);
                                                if(id[0]<size) goToNextChar(params, id);
                                                break;
                                                
                                          case 'y': // Dy
                                                p.dyIncrement = readEqualReal(id, params);
                                                if(id[0]<size) goToNextChar(params, id); 
                                                break;
                                                
                                          default: throw new IgnoreCommandException(-1);
                                    }
                                    break;
                                    
                              case 9 : // '\t'
                              case ',' :
                              case ' ' :
                                    id[0]++;
                                    break;
                                    
                              default : 
                                    if(isCharToIgnore(params.charAt(id[0]))) id[0]++;
                                    else throw new IgnoreCommandException(-1);
                        }//switch
                  }
                  catch(IgnoreCommandException e) // We jump to the next parameter
                  {
                        int cptPar = 0;
                        int cptBrack = 0;
                        while(id[0]<size && (params.charAt(id[0])!=',' || cptPar!=0 || cptBrack!=0))
                        {
                              if(params.charAt(id[0])=='{') cptBrack++;
                              else if(params.charAt(id[0])=='(') cptPar++;
                              else if(params.charAt(id[0])=='}') cptBrack--;
                              else if(params.charAt(id[0])==')') cptPar--;
                              id[0]++;
                        }
                        id[0]++;
                  }
            }//while
      }//public void parseOptionsFigure


Generated by  Doxygen 1.6.0   Back to index