Subversion Repositories wimsdev

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
4897 bpr 1 
        JXG.GeogebraReader = new function() {
2 
/**
3 
 * @param {String} type the type of expression
4 
 * @param {String} m first input value
5 
 * @param {String} n second input value
6 
 * @return {String} return the object, string or calculated value
7 
 */
8 
this.ggbAct = function(type, m, n) {
9 
  var v1 = m, v2 = n, s1, s2, a;
10 
  switch(type.toLowerCase()) {
11 
    case 'end':
12 
      // JXG.debug("<b>end: </b>"+ v1);
13 
      return v1;
14 
    break;
15 
    case 'coord':
16 
      s1 = (JXG.GeogebraReader.board.ggbElements[v1]) ? 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'")' : v1;
17 
      s2 = (JXG.GeogebraReader.board.ggbElements[v2]) ? 'JXG.getReference(JXG.GeogebraReader.board, "'+ v2 +'")' : v2;
18 
      return [s1, s2];
19 
    break;
20 
    case 'le': // smaller then
21 
      return '( ('+ v1 +') <= ('+ v2 +') )';
22 
    break;
23 
    case 'ge': // greater then
24 
      return '( ('+ v1 +') >= ('+ v2 +') )';
25 
    break;
26 
    case 'eq': // equal
27 
      return '( ('+ v1 +') == ('+ v2 +') )';
28 
    break;
29 
    case 'neq': // not equal
30 
      return '( ('+ v1 +') != ('+ v2 +') )';
31 
    break;
32 
    case 'lt': // smaller
33 
      return '( ('+ v1 +') < ('+ v2 +') )';
34 
    break;
35 
    case 'gt': // greater
36 
      return '( ('+ v1 +') > ('+ v2 +') )';
37 
    break;
38 
    case 'add':
39 
        if (JXG.GeogebraReader.isGGBVector(v1) && JXG.GeogebraReader.isGGBVector(v2)){ //Add: Vector + Vector
40 
                return [1, v1[1] + '+' + v2[1], v1[2] + '+' + v2[2]];
41 
        }
42 
      if( JXG.isString(v1) && !v1.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v1.match(/JXG\.getReference/) ) {
43 
        s1 = [v1+'.X()', v1+'.Y()'];
44 
      } else {
45 
        s1 = v1;
46 
      }
47 
 
48 
      if( JXG.isString(v2) && !v2.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v2.match(/JXG\.getReference/) ) {
49 
        s2 = [v2+'.X()', v2+'.Y()'];
50 
      } else {
51 
        s2 = v2;
52 
      }
53 
 
54 
      if (JXG.GeogebraReader.isGGBVector(s1) && JXG.isArray(s2)){ //Add: Vector + Point
55 
          return [s1[1] + '+' + s2[0], s1[2] + '+' + s2[1]];
56 
                }
57 
 
58 
      if (JXG.GeogebraReader.isGGBVector(s2) && JXG.isArray(s1)){ //Add: Vector + Point
59 
          return [s2[1] + '+' + s1[0], s2[2] + '+' + s1[1]];
60 
                }
61 
 
62 
      if( JXG.isArray(s1) && JXG.isArray(s2) ) {
63 
        return [ s1[0] +' + '+ s2[0], s1[1] +' + '+ s2[1] ];
64 
      }
65 
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
66 
        return s1 +' + '+ s2;
67 
      }
68 
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2) ) {
69 
        return [ s1 +' + '+ s2[0], s1 +' + '+ s2[1] ];
70 
      }
71 
      else if( JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
72 
        return [ s1[0] +' + '+ s2, s1[1] +' + '+ s2 ];
73 
      }
74 
      else {
75 
        return s1 +' + '+ s2;
76 
      }
77 
    break;
78 
    case 'sub':
79 
        if (JXG.GeogebraReader.isGGBVector(v1) && JXG.GeogebraReader.isGGBVector(v2)){ //Sub: Vector - Vector
80 
                return [1, v1[1] + '-' + v2[1], v1[2] + '-' + v2[2]];
81 
        }
82 
 
83 
      if( JXG.isString(v1) && !v1.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v1.match(/JXG\.getReference/) ) {
84 
        s1 = [v1+'.X()', v1+'.Y()'];
85 
      } else {
86 
        s1 = v1;
87 
      }
88 
 
89 
      if( JXG.isString(v2) && !v2.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v2.match(/JXG\.getReference/) ) {
90 
        s2 = [v2+'.X()', v2+'.Y()'];
91 
      } else {
92 
        s2 = v2;
93 
      }
94 
 
95 
      if (JXG.GeogebraReader.isGGBVector(s1) && JXG.isArray(s2)){ //Add: Vector - Point
96 
          return [s1[1] + '-' + s2[0], s1[2] + '-' + s2[1]];
97 
                }
98 
 
99 
      if (JXG.isArray(s1) && JXG.GeogebraReader.isGGBVector(s2)){ //Add: Punkt - Vector
100 
          return [s1[0] + '-(' + s2[1] + ')', s1[1] + '-(' + s2[2] +')'];
101 
                }
102 
 
103 
      if( JXG.isArray(s1) && JXG.isArray(s2) ) {
104 
        return [ s1[0] +' - '+ s2[0], s1[1] +' - '+ s2[1] ];
105 
      }
106 
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
107 
        return s1 +' - '+ s2;
108 
      }
109 
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2) ) {
110 
        return [ s1 +' - '+ s2[0], s1 +' - '+ s2[1] ];
111 
      }
112 
      else if( JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
113 
        return [ s1[0] +' - '+ s2, s1[1] +' - '+ s2 ];
114 
      }
115 
      else {
116 
        return s1 +' - '+ s2;
117 
      }
118 
    break;
119 
    case 'neg':
120 
      return '!('+ v1 +')';
121 
    break;
122 
    case 'pow':
123 
      return 'Math.pow('+ v1 +', '+ v2 +')';
124 
    break;
125 
    case 'or':
126 
      return '('+ v1 +'||'+ v2 +')';
127 
    break;
128 
    case 'and':
129 
      return '('+ v1 +'&&'+ v2 +')';
130 
    break;
131 
    case 'mul':
132 
        if (JXG.GeogebraReader.isGGBVector(v1) && !JXG.isArray(v2)){ // Mult: Vector * Skalar
133 
                return [1,'(' + v1[1] + ')*'+v2,'(' + v1[2] + ')*'+v2];
134 
        } else if (!JXG.isArray(v1) && JXG.GeogebraReader.isGGBVector(v2)){ // Mult: Skalar * Vector
135 
                return new Array(1,'(' + v2[1] + ')*'+v1,'(' + v2[2] + ')*'+v1);
136 
        } else if (JXG.GeogebraReader.isGGBVector(v1) && JXG.GeogebraReader.isGGBVector(v2)){ //Mult: Vector * Vector
137 
                return '((' + v1[1] + ')*('+v2[1]+')+('+ v1[2] + ')*('+v2[2]+'))';
138 
        } else { // Rest
139 
      if( JXG.isString(v1) && !v1.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v1.match(/JXG\.getReference/) ) {
140 
                        s1 = [v1+'.X()', v1+'.Y()'];
141 
                      } else {
142 
                        s1 = v1;
143 
                      }
144 
 
145 
                if( JXG.isString(v2) && !v2.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v2.match(/JXG\.getReference/) ) {
146 
                        s2 = [v2+'.X()', v2+'.Y()'];
147 
                      } else {
148 
                        s2 = v2;
149 
                      }
150 
 
151 
                      if( JXG.isArray(s1) && JXG.isArray(s2) ) {
152 
                        return [ s1[0] +' * '+ s2[0], s1[1] +' * '+ s2[1] ];
153 
                      }
154 
                      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
155 
                        return s1 +' * '+ s2;
156 
                      }
157 
                      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2) ) {
158 
                        return [ s1 +' * '+ s2[0], s1 +' * '+ s2[1] ];
159 
                      }
160 
                      else if( JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
161 
                        return [ s1[0] +' * '+ s2, s1[1] +' * '+ s2 ];
162 
                      }
163 
                      else {
164 
                        return s1 +' * '+ s2;
165 
                      }
166 
        }
167 
    break;
168 
    case 'div':
169 
      if( JXG.isString(v1) && !v1.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v1.match(/JXG\.getReference/) ) {
170 
        s1 = [v1+'.X()', v1+'.Y()'];
171 
      } else {
172 
        s1 = v1;
173 
      }
174 
 
175 
      if( JXG.isString(v2) && !v2.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v2.match(/JXG\.getReference/) ) {
176 
        s2 = [v2+'.X()', v2+'.Y()'];
177 
      } else {
178 
        s2 = v2;
179 
      }
180 
 
181 
      if( JXG.isArray(s1) && JXG.isArray(s2) ) {
182 
        return [ s1[0] +' / '+ s2[0], s1[1] +' / '+ s2[1] ];
183 
      }
184 
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
185 
        return s1 +' / '+ s2;
186 
      }
187 
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2) ) {
188 
        return [ s1 +' / '+ s2[0], s1 +' / '+ s2[1] ];
189 
      }
190 
      else if( JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
191 
        return [ s1[0] +' / '+ s2, s1[1] +' / '+ s2 ];
192 
      }
193 
      else {
194 
        return s1 +' / '+ s2;
195 
      }
196 
    break;
197 
    case 'negmult':
198 
        if (JXG.GeogebraReader.isGGBVector(v1))
199 
                return new Array(1, -1 + '*' + v1[1],-1 + '*' + v1[2]);
200 
      return -1 +'*'+ v1;
201 
    break;
202 
    case 'bra':
203 
        if (JXG.GeogebraReader.isGGBVector(v1))
204 
                return new Array(1,'(' + v1[1] + ')','(' + v1[2] + ')');
205 
      return '('+ v1 +')';
206 
    break;
207 
    case 'int':
208 
      return parseInt(v1);
209 
    break;
210 
    case 'float':
211 
      return parseFloat(v1);
212 
    break;
213 
    case 'param':
214 
      return v1;
215 
    break;
216 
    case 'html':
217 
      return v1;
218 
    break;
219 
    case 'string':
220 
      if(v2) return [v1, v2];
221 
      else   return v1;
222 
    break;
223 
    case 'command':
224 
      v2 = v1.split('[');
225 
      s1 = v2[0];
226 
      s2 = (v2[1].split(']'))[0];
227 
      switch(s1.toLowerCase()) {
228 
        case 'name':
229 
          return 'JXG.getReference(JXG.GeogebraReader.board, "'+ s2 +'").getName()'; //TODO korrigiere getName()
230 
        break;
231 
      }
232 
    break;
233 
    case 'var':
234 
      if(v2) {
235 
        switch(v1.toLowerCase()) {
236 
            case 'x':
237 
                return v2 +'.X()';
238 
            break;
239 
            case 'y':
240 
                return v2 +'.Y()';
241 
            break;
242 
            case 'abs':
243 
                        case 'acos':
244 
                        case 'asin':
245 
                        case 'atan':
246 
                        case 'ceil':
247 
                        case 'cos':
248 
                        case 'exp':
249 
                        case 'floor':
250 
                        case 'log':
251 
                        case 'max':
252 
                        case 'min':
253 
                        case 'pow':
254 
                        case 'random':
255 
                        case 'round':
256 
                        case 'sin':
257 
                        case 'sqrt':
258 
                        case 'tan':
259 
              return 'Math.'+v1.toLowerCase()+'('+ v2 +')';
260 
            break;
261 
            default:
262 
                return v1.toLowerCase()+'*('+ v2 +')';
263 
            break;
264 
        }
265 
      } else {
266 
 
267 
        if(v1 == 'PI') {
268 
          return 'Math.PI';
269 
        } else {
270 
          a = JXG.GeogebraReader.checkElement(v1);
271 
          if(typeof JXG.GeogebraReader.board.ggb[v1] != 'undefined') {
272 
            return 'JXG.GeogebraReader.board.ggb["'+ v1 +'"]()';
273 
          } else if(typeof a.Value != 'undefined') {
274 
            return 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").Value()';
275 
          } else if(typeof a.Area != 'undefined') {
276 
            return 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").Area()';
277 
          } else if(typeof a.plaintextStr != 'undefined') {
278 
            return '1.0*JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").plaintextStr';
279 
          } else if (a.type == JXG.OBJECT_TYPE_VECTOR){
280 
            return new Array(1, 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point2.X()-JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point1.X()','JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point2.Y()-JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point1.Y()');
281 
          }else if(a.elementClass == JXG.OBJECT_CLASS_LINE) {
282 
            return 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point1.Dist(JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point2)';
283 
          } else {
284 
            return 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'")';
285 
          }
286 
        }
287 
      }
288 
    break;
289 
  }
290 
};
291 
 
292 
/**
293 
 * JS/CC parser to convert the input expression to a working javascript function.
294 
 * @param {Object} board object
295 
 * @param {Object} element Element that needs to be updated
296 
 * @param {String} exp String which contains the function, expression or information
297 
 */
298 
this.ggbParse = function(exp, element) {
299 
  var element = (element) ? JXG.getReference(JXG.GeogebraReader.board, JXG.GeogebraReader.board.ggbElements[element].id) : false;
300 
  if(element) JXG.debug("Zu aktualisierendes Element: "+ element.name + "("+ element.id +")");
301 
 
302 
/*
303 
    This parser was generated with: The LALR(1) parser and lexical analyzer generator for JavaScript, written in JavaScript
304 
    In the version 0.30 on http://jscc.jmksf.com/
305 
 
306 
    It is based on the default template driver for JS/CC generated parsers running as
307 
    browser-based JavaScript/ECMAScript applications and was strongly modified.
308 
 
309 
    The parser was written 2007, 2008 by Jan Max Meyer, J.M.K S.F. Software Technologies
310 
    This is in the public domain.
311 
*/
312 
 
313 
/***** begin replace *****/
314 
        var _dbg_withtrace              = false;
315 
        var _dbg_string                 = new String();
316 
 
317 
        function __dbg_print( text ) {
318 
                _dbg_string += text + "\n";
319 
        }
320 
 
321 
        function __lex( info ) {
322 
                var state               = 0;
323 
                var match               = -1;
324 
                var match_pos   = 0;
325 
                var start               = 0;
326 
                var pos                 = info.offset + 1;
327 
 
328 
                do
329 
                {
330 
                        pos--;
331 
                        state = 0;
332 
                        match = -2;
333 
                        start = pos;
334 
 
335 
                        if( info.src.length <= start )
336 
                                return 28;
337 
 
338 
                        do
339 
                        {
340 
 
341 
        switch( state )
342 
        {
343 
                case 0:
344 
                        if( info.src.charCodeAt( pos ) == 9 || info.src.charCodeAt( pos ) == 32 ) state = 1;
345 
                        else if( info.src.charCodeAt( pos ) == 33 ) state = 2;
346 
                        else if( info.src.charCodeAt( pos ) == 40 ) state = 3;
347 
                        else if( info.src.charCodeAt( pos ) == 41 ) state = 4;
348 
                        else if( info.src.charCodeAt( pos ) == 42 ) state = 5;
349 
                        else if( info.src.charCodeAt( pos ) == 43 ) state = 6;
350 
                        else if( info.src.charCodeAt( pos ) == 44 ) state = 7;
351 
                        else if( info.src.charCodeAt( pos ) == 45 ) state = 8;
352 
                        else if( info.src.charCodeAt( pos ) == 47 ) state = 9;
353 
                        else if( ( info.src.charCodeAt( pos ) >= 48 && info.src.charCodeAt( pos ) <= 57 ) ) state = 10;
354 
                        else if( info.src.charCodeAt( pos ) == 60 ) state = 11;
355 
                        else if( info.src.charCodeAt( pos ) == 62 ) state = 12;
356 
                        else if( ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) ) state = 13;
357 
                        else if( info.src.charCodeAt( pos ) == 94 ) state = 14;
358 
                        else if( info.src.charCodeAt( pos ) == 34 ) state = 26;
359 
                        else if( info.src.charCodeAt( pos ) == 38 ) state = 28;
360 
                        else if( info.src.charCodeAt( pos ) == 46 ) state = 29;
361 
                        else if( info.src.charCodeAt( pos ) == 61 ) state = 30;
362 
                        else if( info.src.charCodeAt( pos ) == 95 ) state = 31;
363 
                        else if( info.src.charCodeAt( pos ) == 124 ) state = 32;
364 
                        else state = -1;
365 
                        break;
366 
 
367 
                case 1:
368 
                        state = -1;
369 
                        match = 1;
370 
                        match_pos = pos;
371 
                        break;
372 
 
373 
                case 2:
374 
                        if( info.src.charCodeAt( pos ) == 61 ) state = 15;
375 
                        else state = -1;
376 
                        match = 23;
377 
                        match_pos = pos;
378 
                        break;
379 
 
380 
                case 3:
381 
                        state = -1;
382 
                        match = 2;
383 
                        match_pos = pos;
384 
                        break;
385 
 
386 
                case 4:
387 
                        state = -1;
388 
                        match = 3;
389 
                        match_pos = pos;
390 
                        break;
391 
 
392 
                case 5:
393 
                        state = -1;
394 
                        match = 13;
395 
                        match_pos = pos;
396 
                        break;
397 
 
398 
                case 6:
399 
                        state = -1;
400 
                        match = 11;
401 
                        match_pos = pos;
402 
                        break;
403 
 
404 
                case 7:
405 
                        state = -1;
406 
                        match = 16;
407 
                        match_pos = pos;
408 
                        break;
409 
 
410 
                case 8:
411 
                        state = -1;
412 
                        match = 12;
413 
                        match_pos = pos;
414 
                        break;
415 
 
416 
                case 9:
417 
                        state = -1;
418 
                        match = 14;
419 
                        match_pos = pos;
420 
                        break;
421 
 
422 
                case 10:
423 
                        if( ( info.src.charCodeAt( pos ) >= 48 && info.src.charCodeAt( pos ) <= 57 ) ) state = 10;
424 
                        else if( info.src.charCodeAt( pos ) == 46 ) state = 18;
425 
                        else state = -1;
426 
                        match = 4;
427 
                        match_pos = pos;
428 
                        break;
429 
 
430 
                case 11:
431 
                        if( info.src.charCodeAt( pos ) == 61 ) state = 19;
432 
                        else state = -1;
433 
                        match = 21;
434 
                        match_pos = pos;
435 
                        break;
436 
 
437 
                case 12:
438 
                        if( info.src.charCodeAt( pos ) == 61 ) state = 21;
439 
                        else state = -1;
440 
                        match = 22;
441 
                        match_pos = pos;
442 
                        break;
443 
 
444 
                case 13:
445 
                        if( ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) ) state = 13;
446 
                        else if( ( info.src.charCodeAt( pos ) >= 48 && info.src.charCodeAt( pos ) <= 57 ) ) state = 27;
447 
                        else if( info.src.charCodeAt( pos ) == 91 ) state = 34;
448 
                        else if( info.src.charCodeAt( pos ) == 95 ) state = 35;
449 
                        else state = -1;
450 
                        match = 7;
451 
                        match_pos = pos;
452 
                        break;
453 
 
454 
                case 14:
455 
                        state = -1;
456 
                        match = 15;
457 
                        match_pos = pos;
458 
                        break;
459 
 
460 
                case 15:
461 
                        state = -1;
462 
                        match = 20;
463 
                        match_pos = pos;
464 
                        break;
465 
 
466 
                case 16:
467 
                        state = -1;
468 
                        match = 9;
469 
                        match_pos = pos;
470 
                        break;
471 
 
472 
                case 17:
473 
                        state = -1;
474 
                        match = 25;
475 
                        match_pos = pos;
476 
                        break;
477 
 
478 
                case 18:
479 
                        if( ( info.src.charCodeAt( pos ) >= 48 && info.src.charCodeAt( pos ) <= 57 ) ) state = 18;
480 
                        else state = -1;
481 
                        match = 5;
482 
                        match_pos = pos;
483 
                        break;
484 
 
485 
                case 19:
486 
                        state = -1;
487 
                        match = 17;
488 
                        match_pos = pos;
489 
                        break;
490 
 
491 
                case 20:
492 
                        state = -1;
493 
                        match = 19;
494 
                        match_pos = pos;
495 
                        break;
496 
 
497 
                case 21:
498 
                        state = -1;
499 
                        match = 18;
500 
                        match_pos = pos;
501 
                        break;
502 
 
503 
                case 22:
504 
                        state = -1;
505 
                        match = 24;
506 
                        match_pos = pos;
507 
                        break;
508 
 
509 
                case 23:
510 
                        state = -1;
511 
                        match = 8;
512 
                        match_pos = pos;
513 
                        break;
514 
 
515 
                case 24:
516 
                        if( ( info.src.charCodeAt( pos ) >= 48 && info.src.charCodeAt( pos ) <= 57 ) || ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) ) state = 24;
517 
                        else state = -1;
518 
                        match = 6;
519 
                        match_pos = pos;
520 
                        break;
521 
 
522 
                case 25:
523 
                        state = -1;
524 
                        match = 10;
525 
                        match_pos = pos;
526 
                        break;
527 
 
528 
                case 26:
529 
                        if( info.src.charCodeAt( pos ) == 34 ) state = 16;
530 
                        else if( info.src.charCodeAt( pos ) == 32 || info.src.charCodeAt( pos ) == 46 || ( info.src.charCodeAt( pos ) >= 48 && info.src.charCodeAt( pos ) <= 57 ) || info.src.charCodeAt( pos ) == 61 || ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) || info.src.charCodeAt( pos ) == 223 || info.src.charCodeAt( pos ) == 228 || info.src.charCodeAt( pos ) == 246 || info.src.charCodeAt( pos ) == 252 ) state = 26;
531 
                        else state = -1;
532 
                        break;
533 
 
534 
                case 27:
535 
                        if( ( info.src.charCodeAt( pos ) >= 48 && info.src.charCodeAt( pos ) <= 57 ) || ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) ) state = 27;
536 
                        else if( info.src.charCodeAt( pos ) == 95 ) state = 35;
537 
                        else state = -1;
538 
                        match = 7;
539 
                        match_pos = pos;
540 
                        break;
541 
 
542 
                case 28:
543 
                        if( info.src.charCodeAt( pos ) == 38 ) state = 17;
544 
                        else if( ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) ) state = 33;
545 
                        else state = -1;
546 
                        break;
547 
 
548 
                case 29:
549 
                        if( ( info.src.charCodeAt( pos ) >= 48 && info.src.charCodeAt( pos ) <= 57 ) ) state = 18;
550 
                        else state = -1;
551 
                        break;
552 
 
553 
                case 30:
554 
                        if( info.src.charCodeAt( pos ) == 61 ) state = 20;
555 
                        else state = -1;
556 
                        break;
557 
 
558 
                case 31:
559 
                        if( info.src.charCodeAt( pos ) == 95 ) state = 36;
560 
                        else state = -1;
561 
                        break;
562 
 
563 
                case 32:
564 
                        if( info.src.charCodeAt( pos ) == 124 ) state = 22;
565 
                        else state = -1;
566 
                        break;
567 
 
568 
                case 33:
569 
                        if( info.src.charCodeAt( pos ) == 59 ) state = 23;
570 
                        else if( ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) ) state = 33;
571 
                        else state = -1;
572 
                        break;
573 
 
574 
                case 34:
575 
                        if( ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) ) state = 37;
576 
                        else state = -1;
577 
                        break;
578 
 
579 
                case 35:
580 
                        if( ( info.src.charCodeAt( pos ) >= 48 && info.src.charCodeAt( pos ) <= 57 ) || ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) ) state = 27;
581 
                        else if( info.src.charCodeAt( pos ) == 95 ) state = 35;
582 
                        else state = -1;
583 
                        break;
584 
 
585 
                case 36:
586 
                        if( ( info.src.charCodeAt( pos ) >= 48 && info.src.charCodeAt( pos ) <= 57 ) || ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) ) state = 24;
587 
                        else state = -1;
588 
                        break;
589 
 
590 
                case 37:
591 
                        if( info.src.charCodeAt( pos ) == 93 ) state = 25;
592 
                        else if( ( info.src.charCodeAt( pos ) >= 65 && info.src.charCodeAt( pos ) <= 90 ) || ( info.src.charCodeAt( pos ) >= 97 && info.src.charCodeAt( pos ) <= 122 ) ) state = 37;
593 
                        else state = -1;
594 
                        break;
595 
 
596 
        }
597 
 
598 
 
599 
                                pos++;
600 
 
601 
                        }
602 
                        while( state > -1 );
603 
 
604 
                }
605 
                while( 1 > -1 && match == 1 );
606 
 
607 
                if( match > -1 )
608 
                {
609 
                        info.att = info.src.substr( start, match_pos - start );
610 
                        info.offset = match_pos;
611 
 
612 
 
613 
                }
614 
                else
615 
                {
616 
                        info.att = new String();
617 
                        match = -1;
618 
                }
619 
 
620 
                return match;
621 
        }
622 
 
623 
 
624 
        function __parse( src, err_off, err_la ) {
625 
                var             sstack                  = new Array();
626 
                var             vstack                  = new Array();
627 
                var     err_cnt                 = 0;
628 
                var             act;
629 
                var             go;
630 
                var             la;
631 
                var             rval;
632 
                var     parseinfo               = new Function( "", "var offset; var src; var att;" );
633 
                var             info                    = new parseinfo();
634 
 
635 
        /* Pop-Table */
636 
        var pop_tab = new Array(
637 
                new Array( 0/* p' */, 1 ),
638 
                new Array( 27/* p */, 1 ),
639 
                new Array( 26/* e */, 5 ),
640 
                new Array( 26/* e */, 3 ),
641 
                new Array( 26/* e */, 3 ),
642 
                new Array( 26/* e */, 3 ),
643 
                new Array( 26/* e */, 3 ),
644 
                new Array( 26/* e */, 3 ),
645 
                new Array( 26/* e */, 3 ),
646 
                new Array( 26/* e */, 3 ),
647 
                new Array( 26/* e */, 3 ),
648 
                new Array( 26/* e */, 2 ),
649 
                new Array( 26/* e */, 3 ),
650 
                new Array( 26/* e */, 3 ),
651 
                new Array( 26/* e */, 3 ),
652 
                new Array( 26/* e */, 3 ),
653 
                new Array( 26/* e */, 3 ),
654 
                new Array( 26/* e */, 2 ),
655 
                new Array( 26/* e */, 3 ),
656 
                new Array( 26/* e */, 3 ),
657 
                new Array( 26/* e */, 1 ),
658 
                new Array( 26/* e */, 1 ),
659 
                new Array( 26/* e */, 1 ),
660 
                new Array( 26/* e */, 1 ),
661 
                new Array( 26/* e */, 1 ),
662 
                new Array( 26/* e */, 1 ),
663 
                new Array( 26/* e */, 4 ),
664 
                new Array( 26/* e */, 1 )
665 
        );
666 
 
667 
        /* Action-Table */
668 
        var act_tab = new Array(
669 
                /* State 0 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
670 
                /* State 1 */ new Array( 28/* "$" */,0 ),
671 
                /* State 2 */ new Array( 14/* "/" */,13 , 13/* "*" */,14 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,17 , 12/* "-" */,18 , 11/* "+" */,19 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 28/* "$" */,-1 ),
672 
                /* State 3 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
673 
                /* State 4 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
674 
                /* State 5 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
675 
                /* State 6 */ new Array( 11/* "+" */,29 , 28/* "$" */,-24 , 17/* "<=" */,-24 , 18/* ">=" */,-24 , 19/* "==" */,-24 , 20/* "!=" */,-24 , 21/* "<" */,-24 , 22/* ">" */,-24 , 12/* "-" */,-24 , 15/* "^" */,-24 , 24/* "||" */,-24 , 25/* "&&" */,-24 , 13/* "*" */,-24 , 14/* "/" */,-24 , 16/* "," */,-24 , 3/* ")" */,-24 ),
676 
                /* State 7 */ new Array( 28/* "$" */,-20 , 17/* "<=" */,-20 , 18/* ">=" */,-20 , 19/* "==" */,-20 , 20/* "!=" */,-20 , 21/* "<" */,-20 , 22/* ">" */,-20 , 11/* "+" */,-20 , 12/* "-" */,-20 , 15/* "^" */,-20 , 24/* "||" */,-20 , 25/* "&&" */,-20 , 13/* "*" */,-20 , 14/* "/" */,-20 , 16/* "," */,-20 , 3/* ")" */,-20 ),
677 
                /* State 8 */ new Array( 28/* "$" */,-21 , 17/* "<=" */,-21 , 18/* ">=" */,-21 , 19/* "==" */,-21 , 20/* "!=" */,-21 , 21/* "<" */,-21 , 22/* ">" */,-21 , 11/* "+" */,-21 , 12/* "-" */,-21 , 15/* "^" */,-21 , 24/* "||" */,-21 , 25/* "&&" */,-21 , 13/* "*" */,-21 , 14/* "/" */,-21 , 16/* "," */,-21 , 3/* ")" */,-21 ),
678 
                /* State 9 */ new Array( 28/* "$" */,-22 , 17/* "<=" */,-22 , 18/* ">=" */,-22 , 19/* "==" */,-22 , 20/* "!=" */,-22 , 21/* "<" */,-22 , 22/* ">" */,-22 , 11/* "+" */,-22 , 12/* "-" */,-22 , 15/* "^" */,-22 , 24/* "||" */,-22 , 25/* "&&" */,-22 , 13/* "*" */,-22 , 14/* "/" */,-22 , 16/* "," */,-22 , 3/* ")" */,-22 ),
679 
                /* State 10 */ new Array( 28/* "$" */,-23 , 17/* "<=" */,-23 , 18/* ">=" */,-23 , 19/* "==" */,-23 , 20/* "!=" */,-23 , 21/* "<" */,-23 , 22/* ">" */,-23 , 11/* "+" */,-23 , 12/* "-" */,-23 , 15/* "^" */,-23 , 24/* "||" */,-23 , 25/* "&&" */,-23 , 13/* "*" */,-23 , 14/* "/" */,-23 , 16/* "," */,-23 , 3/* ")" */,-23 ),
680 
                /* State 11 */ new Array( 28/* "$" */,-25 , 17/* "<=" */,-25 , 18/* ">=" */,-25 , 19/* "==" */,-25 , 20/* "!=" */,-25 , 21/* "<" */,-25 , 22/* ">" */,-25 , 11/* "+" */,-25 , 12/* "-" */,-25 , 15/* "^" */,-25 , 24/* "||" */,-25 , 25/* "&&" */,-25 , 13/* "*" */,-25 , 14/* "/" */,-25 , 16/* "," */,-25 , 3/* ")" */,-25 ),
681 
                /* State 12 */ new Array( 2/* "(" */,30 , 28/* "$" */,-27 , 17/* "<=" */,-27 , 18/* ">=" */,-27 , 19/* "==" */,-27 , 20/* "!=" */,-27 , 21/* "<" */,-27 , 22/* ">" */,-27 , 11/* "+" */,-27 , 12/* "-" */,-27 , 15/* "^" */,-27 , 24/* "||" */,-27 , 25/* "&&" */,-27 , 13/* "*" */,-27 , 14/* "/" */,-27 , 16/* "," */,-27 , 3/* ")" */,-27 ),
682 
                /* State 13 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
683 
                /* State 14 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
684 
                /* State 15 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
685 
                /* State 16 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
686 
                /* State 17 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
687 
                /* State 18 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
688 
                /* State 19 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
689 
                /* State 20 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
690 
                /* State 21 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
691 
                /* State 22 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
692 
                /* State 23 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
693 
                /* State 24 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
694 
                /* State 25 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
695 
                /* State 26 */ new Array( 14/* "/" */,13 , 13/* "*" */,14 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,17 , 12/* "-" */,18 , 11/* "+" */,19 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 16/* "," */,44 , 3/* ")" */,45 ),
696 
                /* State 27 */ new Array( 14/* "/" */,-11 , 13/* "*" */,-11 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,-11 , 12/* "-" */,-11 , 11/* "+" */,-11 , 22/* ">" */,-11 , 21/* "<" */,-11 , 20/* "!=" */,-11 , 19/* "==" */,-11 , 18/* ">=" */,-11 , 17/* "<=" */,-11 , 28/* "$" */,-11 , 16/* "," */,-11 , 3/* ")" */,-11 ),
697 
                /* State 28 */ new Array( 14/* "/" */,-17 , 13/* "*" */,-17 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,17 , 12/* "-" */,-17 , 11/* "+" */,-17 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 28/* "$" */,-17 , 16/* "," */,-17 , 3/* ")" */,-17 ),
698 
                /* State 29 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
699 
                /* State 30 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
700 
                /* State 31 */ new Array( 14/* "/" */,-16 , 13/* "*" */,-16 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,17 , 12/* "-" */,-16 , 11/* "+" */,-16 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 28/* "$" */,-16 , 16/* "," */,-16 , 3/* ")" */,-16 ),
701 
                /* State 32 */ new Array( 14/* "/" */,-15 , 13/* "*" */,-15 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,17 , 12/* "-" */,-15 , 11/* "+" */,-15 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 28/* "$" */,-15 , 16/* "," */,-15 , 3/* ")" */,-15 ),
702 
                /* State 33 */ new Array( 14/* "/" */,-14 , 13/* "*" */,-14 , 25/* "&&" */,-14 , 24/* "||" */,-14 , 15/* "^" */,-14 , 12/* "-" */,-14 , 11/* "+" */,-14 , 22/* ">" */,-14 , 21/* "<" */,-14 , 20/* "!=" */,-14 , 19/* "==" */,-14 , 18/* ">=" */,-14 , 17/* "<=" */,-14 , 28/* "$" */,-14 , 16/* "," */,-14 , 3/* ")" */,-14 ),
703 
                /* State 34 */ new Array( 14/* "/" */,-13 , 13/* "*" */,-13 , 25/* "&&" */,-13 , 24/* "||" */,-13 , 15/* "^" */,-13 , 12/* "-" */,-13 , 11/* "+" */,-13 , 22/* ">" */,-13 , 21/* "<" */,-13 , 20/* "!=" */,-13 , 19/* "==" */,-13 , 18/* ">=" */,-13 , 17/* "<=" */,-13 , 28/* "$" */,-13 , 16/* "," */,-13 , 3/* ")" */,-13 ),
704 
                /* State 35 */ new Array( 14/* "/" */,-12 , 13/* "*" */,-12 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,-12 , 12/* "-" */,-12 , 11/* "+" */,-12 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 28/* "$" */,-12 , 16/* "," */,-12 , 3/* ")" */,-12 ),
705 
                /* State 36 */ new Array( 14/* "/" */,13 , 13/* "*" */,14 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,17 , 12/* "-" */,-10 , 11/* "+" */,-10 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 28/* "$" */,-10 , 16/* "," */,-10 , 3/* ")" */,-10 ),
706 
                /* State 37 */ new Array( 14/* "/" */,13 , 13/* "*" */,14 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,17 , 12/* "-" */,-9 , 11/* "+" */,-9 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 28/* "$" */,-9 , 16/* "," */,-9 , 3/* ")" */,-9 ),
707 
                /* State 38 */ new Array( 14/* "/" */,-8 , 13/* "*" */,-8 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,-8 , 12/* "-" */,-8 , 11/* "+" */,-8 , 22/* ">" */,-8 , 21/* "<" */,-8 , 20/* "!=" */,-8 , 19/* "==" */,-8 , 18/* ">=" */,-8 , 17/* "<=" */,-8 , 28/* "$" */,-8 , 16/* "," */,-8 , 3/* ")" */,-8 ),
708 
                /* State 39 */ new Array( 14/* "/" */,-7 , 13/* "*" */,-7 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,-7 , 12/* "-" */,-7 , 11/* "+" */,-7 , 22/* ">" */,-7 , 21/* "<" */,-7 , 20/* "!=" */,-7 , 19/* "==" */,-7 , 18/* ">=" */,-7 , 17/* "<=" */,-7 , 28/* "$" */,-7 , 16/* "," */,-7 , 3/* ")" */,-7 ),
709 
                /* State 40 */ new Array( 14/* "/" */,-6 , 13/* "*" */,-6 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,-6 , 12/* "-" */,-6 , 11/* "+" */,-6 , 22/* ">" */,-6 , 21/* "<" */,-6 , 20/* "!=" */,-6 , 19/* "==" */,-6 , 18/* ">=" */,-6 , 17/* "<=" */,-6 , 28/* "$" */,-6 , 16/* "," */,-6 , 3/* ")" */,-6 ),
710 
                /* State 41 */ new Array( 14/* "/" */,-5 , 13/* "*" */,-5 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,-5 , 12/* "-" */,-5 , 11/* "+" */,-5 , 22/* ">" */,-5 , 21/* "<" */,-5 , 20/* "!=" */,-5 , 19/* "==" */,-5 , 18/* ">=" */,-5 , 17/* "<=" */,-5 , 28/* "$" */,-5 , 16/* "," */,-5 , 3/* ")" */,-5 ),
711 
                /* State 42 */ new Array( 14/* "/" */,-4 , 13/* "*" */,-4 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,-4 , 12/* "-" */,-4 , 11/* "+" */,-4 , 22/* ">" */,-4 , 21/* "<" */,-4 , 20/* "!=" */,-4 , 19/* "==" */,-4 , 18/* ">=" */,-4 , 17/* "<=" */,-4 , 28/* "$" */,-4 , 16/* "," */,-4 , 3/* ")" */,-4 ),
712 
                /* State 43 */ new Array( 14/* "/" */,-3 , 13/* "*" */,-3 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,-3 , 12/* "-" */,-3 , 11/* "+" */,-3 , 22/* ">" */,-3 , 21/* "<" */,-3 , 20/* "!=" */,-3 , 19/* "==" */,-3 , 18/* ">=" */,-3 , 17/* "<=" */,-3 , 28/* "$" */,-3 , 16/* "," */,-3 , 3/* ")" */,-3 ),
713 
                /* State 44 */ new Array( 2/* "(" */,3 , 23/* "!" */,4 , 12/* "-" */,5 , 9/* "STRING" */,6 , 4/* "INT" */,7 , 5/* "FLOAT" */,8 , 6/* "PARAM" */,9 , 8/* "HTML" */,10 , 10/* "COMMAND" */,11 , 7/* "VAR" */,12 ),
714 
                /* State 45 */ new Array( 28/* "$" */,-18 , 17/* "<=" */,-18 , 18/* ">=" */,-18 , 19/* "==" */,-18 , 20/* "!=" */,-18 , 21/* "<" */,-18 , 22/* ">" */,-18 , 11/* "+" */,-18 , 12/* "-" */,-18 , 15/* "^" */,-18 , 24/* "||" */,-18 , 25/* "&&" */,-18 , 13/* "*" */,-18 , 14/* "/" */,-18 , 16/* "," */,-18 , 3/* ")" */,-18 ),
715 
                /* State 46 */ new Array( 14/* "/" */,13 , 13/* "*" */,14 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,17 , 12/* "-" */,-19 , 11/* "+" */,-19 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 28/* "$" */,-19 , 16/* "," */,-19 , 3/* ")" */,-19 ),
716 
                /* State 47 */ new Array( 14/* "/" */,13 , 13/* "*" */,14 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,17 , 12/* "-" */,18 , 11/* "+" */,19 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 3/* ")" */,49 ),
717 
                /* State 48 */ new Array( 14/* "/" */,13 , 13/* "*" */,14 , 25/* "&&" */,15 , 24/* "||" */,16 , 15/* "^" */,17 , 12/* "-" */,18 , 11/* "+" */,19 , 22/* ">" */,20 , 21/* "<" */,21 , 20/* "!=" */,22 , 19/* "==" */,23 , 18/* ">=" */,24 , 17/* "<=" */,25 , 3/* ")" */,50 ),
718 
                /* State 49 */ new Array( 28/* "$" */,-26 , 17/* "<=" */,-26 , 18/* ">=" */,-26 , 19/* "==" */,-26 , 20/* "!=" */,-26 , 21/* "<" */,-26 , 22/* ">" */,-26 , 11/* "+" */,-26 , 12/* "-" */,-26 , 15/* "^" */,-26 , 24/* "||" */,-26 , 25/* "&&" */,-26 , 13/* "*" */,-26 , 14/* "/" */,-26 , 16/* "," */,-26 , 3/* ")" */,-26 ),
719 
                /* State 50 */ new Array( 28/* "$" */,-2 , 17/* "<=" */,-2 , 18/* ">=" */,-2 , 19/* "==" */,-2 , 20/* "!=" */,-2 , 21/* "<" */,-2 , 22/* ">" */,-2 , 11/* "+" */,-2 , 12/* "-" */,-2 , 15/* "^" */,-2 , 24/* "||" */,-2 , 25/* "&&" */,-2 , 13/* "*" */,-2 , 14/* "/" */,-2 , 16/* "," */,-2 , 3/* ")" */,-2 )
720 
        );
721 
 
722 
        /* Goto-Table */
723 
        var goto_tab = new Array(
724 
                /* State 0 */ new Array( 27/* p */,1 , 26/* e */,2 ),
725 
                /* State 1 */ new Array(  ),
726 
                /* State 2 */ new Array(  ),
727 
                /* State 3 */ new Array( 26/* e */,26 ),
728 
                /* State 4 */ new Array( 26/* e */,27 ),
729 
                /* State 5 */ new Array( 26/* e */,28 ),
730 
                /* State 6 */ new Array(  ),
731 
                /* State 7 */ new Array(  ),
732 
                /* State 8 */ new Array(  ),
733 
                /* State 9 */ new Array(  ),
734 
                /* State 10 */ new Array(  ),
735 
                /* State 11 */ new Array(  ),
736 
                /* State 12 */ new Array(  ),
737 
                /* State 13 */ new Array( 26/* e */,31 ),
738 
                /* State 14 */ new Array( 26/* e */,32 ),
739 
                /* State 15 */ new Array( 26/* e */,33 ),
740 
                /* State 16 */ new Array( 26/* e */,34 ),
741 
                /* State 17 */ new Array( 26/* e */,35 ),
742 
                /* State 18 */ new Array( 26/* e */,36 ),
743 
                /* State 19 */ new Array( 26/* e */,37 ),
744 
                /* State 20 */ new Array( 26/* e */,38 ),
745 
                /* State 21 */ new Array( 26/* e */,39 ),
746 
                /* State 22 */ new Array( 26/* e */,40 ),
747 
                /* State 23 */ new Array( 26/* e */,41 ),
748 
                /* State 24 */ new Array( 26/* e */,42 ),
749 
                /* State 25 */ new Array( 26/* e */,43 ),
750 
                /* State 26 */ new Array(  ),
751 
                /* State 27 */ new Array(  ),
752 
                /* State 28 */ new Array(  ),
753 
                /* State 29 */ new Array( 26/* e */,46 ),
754 
                /* State 30 */ new Array( 26/* e */,47 ),
755 
                /* State 31 */ new Array(  ),
756 
                /* State 32 */ new Array(  ),
757 
                /* State 33 */ new Array(  ),
758 
                /* State 34 */ new Array(  ),
759 
                /* State 35 */ new Array(  ),
760 
                /* State 36 */ new Array(  ),
761 
                /* State 37 */ new Array(  ),
762 
                /* State 38 */ new Array(  ),
763 
                /* State 39 */ new Array(  ),
764 
                /* State 40 */ new Array(  ),
765 
                /* State 41 */ new Array(  ),
766 
                /* State 42 */ new Array(  ),
767 
                /* State 43 */ new Array(  ),
768 
                /* State 44 */ new Array( 26/* e */,48 ),
769 
                /* State 45 */ new Array(  ),
770 
                /* State 46 */ new Array(  ),
771 
                /* State 47 */ new Array(  ),
772 
                /* State 48 */ new Array(  ),
773 
                /* State 49 */ new Array(  ),
774 
                /* State 50 */ new Array(  )
775 
        );
776 
 
777 
 
778 
 
779 
        /* Symbol labels */
780 
        var labels = new Array(
781 
                "p'" /* Non-terminal symbol */,
782 
                "WHITESPACE" /* Terminal symbol */,
783 
                "(" /* Terminal symbol */,
784 
                ")" /* Terminal symbol */,
785 
                "INT" /* Terminal symbol */,
786 
                "FLOAT" /* Terminal symbol */,
787 
                "PARAM" /* Terminal symbol */,
788 
                "VAR" /* Terminal symbol */,
789 
                "HTML" /* Terminal symbol */,
790 
                "STRING" /* Terminal symbol */,
791 
                "COMMAND" /* Terminal symbol */,
792 
                "+" /* Terminal symbol */,
793 
                "-" /* Terminal symbol */,
794 
                "*" /* Terminal symbol */,
795 
                "/" /* Terminal symbol */,
796 
                "^" /* Terminal symbol */,
797 
                "," /* Terminal symbol */,
798 
                "<=" /* Terminal symbol */,
799 
                ">=" /* Terminal symbol */,
800 
                "==" /* Terminal symbol */,
801 
                "!=" /* Terminal symbol */,
802 
                "<" /* Terminal symbol */,
803 
                ">" /* Terminal symbol */,
804 
                "!" /* Terminal symbol */,
805 
                "||" /* Terminal symbol */,
806 
                "&&" /* Terminal symbol */,
807 
                "e" /* Non-terminal symbol */,
808 
                "p" /* Non-terminal symbol */,
809 
                "$" /* Terminal symbol */
810 
        );
811 
 
812 
 
813 
 
814 
                info.offset = 0;
815 
                info.src = src;
816 
                info.att = new String();
817 
 
818 
                if( !err_off )
819 
                        err_off = new Array();
820 
                if( !err_la )
821 
                err_la = new Array();
822 
 
823 
                sstack.push( 0 );
824 
                vstack.push( 0 );
825 
 
826 
                la = __lex( info );
827 
 
828 
                while( true )
829 
                {
830 
                        act = 52;
831 
                        for( var i = 0; i < act_tab[sstack[sstack.length-1]].length; i+=2 )
832 
                        {
833 
                                if( act_tab[sstack[sstack.length-1]][i] == la )
834 
                                {
835 
                                        act = act_tab[sstack[sstack.length-1]][i+1];
836 
                                        break;
837 
                                }
838 
                        }
839 
 
840 
                        if( _dbg_withtrace && sstack.length > 0 )
841 
                        {
842 
                                __dbg_print( "\nState " + sstack[sstack.length-1] + "\n" +
843 
                                                                "\tLookahead: " + labels[la] + " (\"" + info.att + "\")\n" +
844 
                                                                "\tAction: " + act + "\n" +
845 
                                                                "\tSource: \"" + info.src.substr( info.offset, 30 ) + ( ( info.offset + 30 < info.src.length ) ?
846 
                                                                                "..." : "" ) + "\"\n" +
847 
                                                                "\tStack: " + sstack.join() + "\n" +
848 
                                                                "\tValue stack: " + vstack.join() + "\n" );
849 
                        }
850 
 
851 
 
852 
                        //Panic-mode: Try recovery when parse-error occurs!
853 
                        if( act == 52 )
854 
                        {
855 
                                if( _dbg_withtrace )
856 
                                        __dbg_print( "Error detected: There is no reduce or shift on the symbol " + labels[la] );
857 
 
858 
                                err_cnt++;
859 
                                err_off.push( info.offset - info.att.length );                 
860 
                                err_la.push( new Array() );
861 
                                for( var i = 0; i < act_tab[sstack[sstack.length-1]].length; i+=2 )
862 
                                        err_la[err_la.length-1].push( labels[act_tab[sstack[sstack.length-1]][i]] );
863 
 
864 
                                //Remember the original stack!
865 
                                var rsstack = new Array();
866 
                                var rvstack = new Array();
867 
                                for( var i = 0; i < sstack.length; i++ )
868 
                                {
869 
                                        rsstack[i] = sstack[i];
870 
                                        rvstack[i] = vstack[i];
871 
                                }
872 
 
873 
                                while( act == 52 && la != 28 )
874 
                                {
875 
                                        if( _dbg_withtrace )
876 
                                                __dbg_print( "\tError recovery\n" +
877 
                                                                                "Current lookahead: " + labels[la] + " (" + info.att + ")\n" +
878 
                                                                                "Action: " + act + "\n\n" );
879 
                                        if( la == -1 )
880 
                                                info.offset++;
881 
 
882 
                                        while( act == 52 && sstack.length > 0 )
883 
                                        {
884 
                                                sstack.pop();
885 
                                                vstack.pop();
886 
 
887 
                                                if( sstack.length == 0 )
888 
                                                        break;
889 
 
890 
                                                act = 52;
891 
                                                for( var i = 0; i < act_tab[sstack[sstack.length-1]].length; i+=2 )
892 
                                                {
893 
                                                        if( act_tab[sstack[sstack.length-1]][i] == la )
894 
                                                        {
895 
                                                                act = act_tab[sstack[sstack.length-1]][i+1];
896 
                                                                break;
897 
                                                        }
898 
                                                }
899 
                                        }
900 
 
901 
                                        if( act != 52 )
902 
                                                break;
903 
 
904 
                                        for( var i = 0; i < rsstack.length; i++ )
905 
                                        {
906 
                                                sstack.push( rsstack[i] );
907 
                                                vstack.push( rvstack[i] );
908 
                                        }
909 
 
910 
                                        la = __lex( info );
911 
                                }
912 
 
913 
                                if( act == 52 )
914 
                                {
915 
                                        if( _dbg_withtrace )
916 
                                                __dbg_print( "\tError recovery failed, terminating parse process..." );
917 
                                        break;
918 
                                }
919 
 
920 
 
921 
                                if( _dbg_withtrace )
922 
                                        __dbg_print( "\tError recovery succeeded, continuing" );
923 
                        }
924 
 
925 
                        /*
926 
                        if( act == 52 )
927 
                                break;
928 
                        */
929 
 
930 
 
931 
                        //Shift
932 
                        if( act > 0 )
933 
                        {                      
934 
                                if( _dbg_withtrace )
935 
                                        __dbg_print( "Shifting symbol: " + labels[la] + " (" + info.att + ")" );
936 
 
937 
                                sstack.push( act );
938 
                                vstack.push( info.att );
939 
 
940 
                                la = __lex( info );
941 
 
942 
                                if( _dbg_withtrace )
943 
                                        __dbg_print( "\tNew lookahead symbol: " + labels[la] + " (" + info.att + ")" );
944 
                        }
945 
                        //Reduce
946 
                        else
947 
                        {              
948 
                                act *= -1;
949 
 
950 
                                if( _dbg_withtrace )
951 
                                        __dbg_print( "Reducing by producution: " + act );
952 
 
953 
                                rval = void(0);
954 
 
955 
                                if( _dbg_withtrace )
956 
                                        __dbg_print( "\tPerforming semantic action..." );
957 
 
958 
        switch( act )
959 
        {
960 
                case 0:
961 
                {
962 
                        rval = vstack[ vstack.length - 1 ];
963 
                }
964 
                break;
965 
                case 1:
966 
                {
967 
                         rval = JXG.GeogebraReader.ggbAct('end', vstack[ vstack.length - 1 ]);
968 
                }
969 
                break;
970 
                case 2:
971 
                {
972 
                         rval = JXG.GeogebraReader.ggbAct('coord', vstack[ vstack.length - 4 ], vstack[ vstack.length - 2 ], element);
973 
                }
974 
                break;
975 
                case 3:
976 
                {
977 
                         rval = JXG.GeogebraReader.ggbAct('le', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
978 
                }
979 
                break;
980 
                case 4:
981 
                {
982 
                         rval = JXG.GeogebraReader.ggbAct('ge', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
983 
                }
984 
                break;
985 
                case 5:
986 
                {
987 
                         rval = JXG.GeogebraReader.ggbAct('eq', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
988 
                }
989 
                break;
990 
                case 6:
991 
                {
992 
                         rval = JXG.GeogebraReader.ggbAct('neq', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
993 
                }
994 
                break;
995 
                case 7:
996 
                {
997 
                         rval = JXG.GeogebraReader.ggbAct('lt', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
998 
                }
999 
                break;
1000 
                case 8:
1001 
                {
1002 
                         rval = JXG.GeogebraReader.ggbAct('gt', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
1003 
                }
1004 
                break;
1005 
                case 9:
1006 
                {
1007 
                         rval = JXG.GeogebraReader.ggbAct('add', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
1008 
                }
1009 
                break;
1010 
                case 10:
1011 
                {
1012 
                         rval = JXG.GeogebraReader.ggbAct('sub', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
1013 
                }
1014 
                break;
1015 
                case 11:
1016 
                {
1017 
                         rval = JXG.GeogebraReader.ggbAct('neg', vstack[ vstack.length - 1 ]);
1018 
                }
1019 
                break;
1020 
                case 12:
1021 
                {
1022 
                         rval = JXG.GeogebraReader.ggbAct('pow', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
1023 
                }
1024 
                break;
1025 
                case 13:
1026 
                {
1027 
                         rval = JXG.GeogebraReader.ggbAct('or', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
1028 
                }
1029 
                break;
1030 
                case 14:
1031 
                {
1032 
                         rval = JXG.GeogebraReader.ggbAct('and', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
1033 
                }
1034 
                break;
1035 
                case 15:
1036 
                {
1037 
                         rval = JXG.GeogebraReader.ggbAct('mul', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
1038 
                }
1039 
                break;
1040 
                case 16:
1041 
                {
1042 
                         rval = JXG.GeogebraReader.ggbAct('div', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
1043 
                }
1044 
                break;
1045 
                case 17:
1046 
                {
1047 
                         rval = JXG.GeogebraReader.ggbAct('negmult', vstack[ vstack.length - 1 ]);
1048 
                }
1049 
                break;
1050 
                case 18:
1051 
                {
1052 
                         rval = JXG.GeogebraReader.ggbAct('bra', vstack[ vstack.length - 2 ]);
1053 
                }
1054 
                break;
1055 
                case 19:
1056 
                {
1057 
                         rval = JXG.GeogebraReader.ggbAct('string', vstack[ vstack.length - 3 ], vstack[ vstack.length - 1 ]);
1058 
                }
1059 
                break;
1060 
                case 20:
1061 
                {
1062 
                         rval = JXG.GeogebraReader.ggbAct('int', vstack[ vstack.length - 1 ]);
1063 
                }
1064 
                break;
1065 
                case 21:
1066 
                {
1067 
                         rval = JXG.GeogebraReader.ggbAct('float', vstack[ vstack.length - 1 ]);
1068 
                }
1069 
                break;
1070 
                case 22:
1071 
                {
1072 
                         rval = JXG.GeogebraReader.ggbAct('param', vstack[ vstack.length - 1 ]);
1073 
                }
1074 
                break;
1075 
                case 23:
1076 
                {
1077 
                         rval = JXG.GeogebraReader.ggbAct('html', vstack[ vstack.length - 1 ]);
1078 
                }
1079 
                break;
1080 
                case 24:
1081 
                {
1082 
                         rval = JXG.GeogebraReader.ggbAct('string', vstack[ vstack.length - 1 ]);
1083 
                }
1084 
                break;
1085 
                case 25:
1086 
                {
1087 
                         rval = JXG.GeogebraReader.ggbAct('command', vstack[ vstack.length - 1 ]);
1088 
                }
1089 
                break;
1090 
                case 26:
1091 
                {
1092 
                         rval = JXG.GeogebraReader.ggbAct('var', vstack[ vstack.length - 4 ], vstack[ vstack.length - 2 ]);
1093 
                }
1094 
                break;
1095 
                case 27:
1096 
                {
1097 
                         rval = JXG.GeogebraReader.ggbAct('var', vstack[ vstack.length - 1 ]);
1098 
                }
1099 
                break;
1100 
        }
1101 
 
1102 
 
1103 
 
1104 
                                if( _dbg_withtrace )
1105 
                                        __dbg_print( "\tPopping " + pop_tab[act][1] + " off the stack..." );
1106 
 
1107 
                                for( var i = 0; i < pop_tab[act][1]; i++ )
1108 
                                {
1109 
                                        sstack.pop();
1110 
                                        str = vstack.pop();
1111 
                                }
1112 
 
1113 
                                go = -1;
1114 
                                for( var i = 0; i < goto_tab[sstack[sstack.length-1]].length; i+=2 )
1115 
                                {
1116 
                                        if( goto_tab[sstack[sstack.length-1]][i] == pop_tab[act][0] )
1117 
                                        {
1118 
                                                go = goto_tab[sstack[sstack.length-1]][i+1];
1119 
                                                break;
1120 
                                        }
1121 
                                }
1122 
 
1123 
                                if( act == 0 )
1124 
                                        break;
1125 
 
1126 
                                if( _dbg_withtrace )
1127 
                                        __dbg_print( "\tPushing non-terminal " + labels[ pop_tab[act][0] ] );
1128 
 
1129 
                                sstack.push( go );
1130 
                                vstack.push( rval );                   
1131 
                        }
1132 
 
1133 
                        if( _dbg_withtrace )
1134 
                        {              
1135 
                                JXG.debug( _dbg_string );
1136 
                                _dbg_string = new String();
1137 
                        }
1138 
                }
1139 
 
1140 
                if( _dbg_withtrace )
1141 
                {
1142 
                        __dbg_print( "\nParse complete." );
1143 
                        JXG.debug( _dbg_string );
1144 
                }
1145 
 
1146 
                return err_cnt;
1147 
        }
1148 
/***** end replace *****/
1149 
 
1150 
  var error_offsets = new Array();
1151 
  var error_lookaheads = new Array();
1152 
  var error_count = 0;
1153 
  var str = exp;
1154 
  if( ( error_count = __parse( str, error_offsets, error_lookaheads ) ) > 0 ) {
1155 
    var errstr = new String();
1156 
    for( var i = 0; i < error_count; i++ )
1157 
      errstr += "Parse error in line " + ( str.substr( 0, error_offsets[i] ).match( /\n/g ) ?
1158 
                  str.substr( 0, error_offsets[i] ).match( /\n/g ).length : 1 )
1159 
                + " near \"" + str.substr( error_offsets[i] ) + "\", expecting \"" + error_lookaheads[i].join() + "\"\n" ;
1160 
    JXG.debug( errstr );
1161 
  }
1162 
 
1163 
  return str;
1164 
}; //end: ggbParse()
1165 
 
1166 
 
1167 
/**
1168 
 * Override JSxGraph defaults with Geogebra settings
1169 
 * @param {Object} board object
1170 
 * @return {Object} board oject
1171 
 */
1172 
this.setDefaultOptions = function(board){
1173 
  board.options.elements.strokeWidth = '1px'; // TODO: board.options.line.strokeWidth
1174 
  board.options.elements.withLabel = true;
1175 
 
1176 
  board.options.point.face = 'circle';
1177 
  board.options.point.size = 3;
1178 
  board.options.point.fillColor = 'blue';
1179 
  board.options.point.fillOpacity = 1;
1180 
  board.options.point.highlightFillOpacity = 1;
1181 
  board.options.point.strokeColor = 'black';
1182 
  board.options.point.highlightStrokeColor = 'black';
1183 
  board.options.point.strokeWidth = '2px';
1184 
 
1185 
  board.options.line.strokeWidth = '1px';
1186 
  board.options.line.highlightStrokeColor = '#000000';
1187 
  board.options.line.strokeColor = '#000000';
1188 
 
1189 
  board.options.polygon.fillColor = JXG.rgb2hex(153, 51, 0);
1190 
  board.options.polygon.fillOpacity = 0.1;
1191 
  board.options.polygon.highlightFillColor = board.options.polygon.fillColor;
1192 
  board.options.polygon.highlightFillOpacity = 0.1;
1193 
 
1194 
  board.options.sector.fillColor = JXG.rgb2hex(153, 51, 0);
1195 
  board.options.sector.fillOpacity = 0.1;
1196 
  board.options.sector.highlightFillColor = board.options.sector.fillColor;
1197 
  board.options.sector.highlightFillOpacity = 0.1;
1198 
 
1199 
  board.options.angle.fillColor = JXG.rgb2hex(0, 100, 0);
1200 
  board.options.angle.fillOpacity = 0.1;
1201 
  //board.options.angle.highlightFillColor = board.options.angle.fillColor;
1202 
  board.options.angle.highlightFillOpacity = 0.1;
1203 
 
1204 
  return board;
1205 
};
1206 
 
1207 
/**
1208 
 * Set color properties of a geogebra element.
1209 
 * Set stroke, fill, lighting, label and draft color attributes.
1210 
 * @param {Object} gxtEl element of which attributes are to set
1211 
 * @param {Object} attr object carrying all necessary attribute values
1212 
 * @return {Object} returning the updated attr-attributes object
1213 
 */
1214 
this.colorProperties = function(Data, attr) {
1215 
  var a,r,g,b;
1216 
  a = (Data.getElementsByTagName("objColor").length > 0 && Data.getElementsByTagName("objColor")[0].getAttribute("alpha")) ? parseFloat(Data.getElementsByTagName("objColor")[0].getAttribute("alpha")) : 0;
1217 
  r = (Data.getElementsByTagName("objColor").length > 0 && Data.getElementsByTagName("objColor")[0].getAttribute("r")) ? parseInt(Data.getElementsByTagName("objColor")[0].getAttribute("r")).toString(16) : 0;
1218 
  g = (Data.getElementsByTagName("objColor").length > 0 && Data.getElementsByTagName("objColor")[0].getAttribute("g")) ? parseInt(Data.getElementsByTagName("objColor")[0].getAttribute("g")).toString(16) : 0;
1219 
  b = (Data.getElementsByTagName("objColor").length > 0 && Data.getElementsByTagName("objColor")[0].getAttribute("b")) ? parseInt(Data.getElementsByTagName("objColor")[0].getAttribute("b")).toString(16) : 0;
1220 
  if (r.length == 1) r = '0' + r;
1221 
  if (g.length == 1) g = '0' + g;
1222 
  if (b.length == 1) b = '0' + b;
1223 
 
1224 
  attr.fillColor = '#'+ r + g + b;
1225 
  attr.strokeColor = attr.fillColor;
1226 
  attr.highlightFillColor = attr.fillColor;
1227 
  attr.highlightStrokeColor = attr.strokeColor;
1228 
  attr.fillOpacity = a;
1229 
  attr.highlightFillOpacity = a;
1230 
  attr.labelColor = attr.fillColor;
1231 
 
1232 
  return attr;
1233 
};
1234 
 
1235 
/**
1236 
 * Set the board properties.
1237 
 * Set active, area, dash, draft and showinfo attributes.
1238 
 * @param {Object} gxtEl element of which attributes are to set
1239 
 * @param {Object} Data element of which attributes are to set
1240 
 * @param {Object} attr object containing the necessary attribute values
1241 
 */
1242 
this.boardProperties = function(gxtEl, Data, attr) {
1243 
  return attr;
1244 
};
1245 
 
1246 
/**
1247 
 * @param {Object} gxtEl element of which attributes are to set
1248 
 * @param {Object} Data element of which attributes are to set
1249 
 * @return {Object} updated element
1250 
 */
1251 
this.coordinates = function(gxtEl, Data) {
1252 
  var labelOffset = {}, tmp;
1253 
  labelOffset.x = 0; labelOffset.y = 0; labelOffset.z = 0;
1254 
 
1255 
  if(Data.getElementsByTagName('labelOffset')[0]) {
1256 
    // tmp = new JXG.Coords(JXG.COORDS_BY_SCREEN, [,
1257 
    //                                             parseFloat(Data.getElementsByTagName("labelOffset")[0].attributes["y"].value)], JXG.GeogebraReader.board);
1258 
    labelOffset.x = parseFloat(Data.getElementsByTagName("labelOffset")[0].getAttribute("x"))/JXG.GeogebraReader.board.unitX;
1259 
    labelOffset.y = parseFloat(Data.getElementsByTagName("labelOffset")[0].getAttribute("y"))/JXG.GeogebraReader.board.unitY;
1260 
  }
1261 
 
1262 
  if(Data.getElementsByTagName("coords")[0]) {
1263 
    gxtEl.x = parseFloat(Data.getElementsByTagName("coords")[0].getAttribute("x"));
1264 
    gxtEl.y = parseFloat(Data.getElementsByTagName("coords")[0].getAttribute("y"));
1265 
    gxtEl.z = parseFloat(Data.getElementsByTagName("coords")[0].getAttribute("z"));
1266 
  } else if(Data.getElementsByTagName("startPoint")[0]) {
1267 
    if(Data.getElementsByTagName("startPoint")[0].getAttribute('exp')) {
1268 
      var a = JXG.getReference(JXG.GeogebraReader.board, Data.getElementsByTagName("startPoint")[0].getAttribute('exp'));
1269 
      gxtEl.x = function() {return a.X()+labelOffset.x;};
1270 
      gxtEl.y = function() {return a.Y()-labelOffset.y;}; // minus because geogebra starts on the other side
1271 
      gxtEl.z = false;
1272 
    } else {
1273 
      gxtEl.x = parseFloat(Data.getElementsByTagName("startPoint")[0].getAttribute("x"));
1274 
      gxtEl.y = parseFloat(Data.getElementsByTagName("startPoint")[0].getAttribute("y"));
1275 
      gxtEl.z = parseFloat(Data.getElementsByTagName("startPoint")[0].getAttribute("z"));
1276 
    }
1277 
  } else if(Data.getElementsByTagName("absoluteScreenLocation")[0]) {
1278 
    var tmp = new JXG.Coords(JXG.COORDS_BY_SCREEN, [parseFloat(Data.getElementsByTagName("absoluteScreenLocation")[0].getAttribute("x")),
1279 
                                                    parseFloat(Data.getElementsByTagName("absoluteScreenLocation")[0].getAttribute("y"))], JXG.GeogebraReader.board);
1280 
    gxtEl.x = tmp.usrCoords[1]+labelOffset.x;
1281 
    gxtEl.y = tmp.usrCoords[2]+labelOffset.y;
1282 
    gxtEl.z = false;
1283 
  } else {
1284 
    return false;
1285 
  }
1286 
 
1287 
  return gxtEl;
1288 
};
1289 
 
1290 
/**
1291 
 * Writing element attributes to the given object
1292 
 * @param {XMLNode} Data expects the content of the current element
1293 
 * @return {Object} object with according attributes
1294 
 */
1295 
this.visualProperties = function(Data, attr) {
1296 
  (Data.getElementsByTagName("show").length != 0 && Data.getElementsByTagName("show")[0].getAttribute("object")) ? attr.visible = Data.getElementsByTagName("show")[0].getAttribute("object") : false;
1297 
  (Data.getElementsByTagName("show").length != 0 && Data.getElementsByTagName("show")[0].getAttribute("label")) ? attr.withLabel = Data.getElementsByTagName("show")[0].getAttribute("label") : true;
1298 
  if(attr.withLabel == 'true') {
1299 
     attr.withLabel = true;
1300 
  }
1301 
  else if(attr.withLabel == 'false') {
1302 
     attr.withLabel = false;
1303 
  }
1304 
  (Data.getElementsByTagName('pointSize')[0]) ? attr.size = Data.getElementsByTagName('pointSize')[0].getAttribute("val") : false;
1305 
  (Data.getElementsByTagName('pointStyle')[0]) ? attr.styleGGB = Data.getElementsByTagName('pointStyle')[0].getAttribute("val") : false;
1306 
   if(attr.styleGGB == 0 || attr.styleGGB == 2) {
1307 
      attr.face = 'circle';
1308 
      if(attr.styleGGB == 0) {
1309 
        attr.fillColor = attr.strokeColor;
1310 
        attr.fillOpacity = 1;
1311 
        attr.highlightFillColor = attr.strokeColor;
1312 
        attr.highlightFillOpacity = 1;
1313 
        attr.strokeColor = 'black';
1314 
        attr.strokeWidth = '1px';
1315 
      }
1316 
      else if(attr.styleGGB == 2) {
1317 
        attr.fillColor = 'none';
1318 
      }
1319 
   }
1320 
   else if(attr.styleGGB == 1) {
1321 
      attr.face = 'x';
1322 
   }
1323 
   else if(attr.styleGGB == 3) {
1324 
      attr.face = '+';
1325 
      attr.strokeOpacity = 1;
1326 
   }
1327 
   else if(attr.styleGGB == 4 || attr.styleGGB == 5) {
1328 
      attr.face = 'diamond';
1329 
      if(attr.styleGGB == 4) {
1330 
         attr.fillColor = attr.strokeColor;
1331 
         attr.fillOpacity = 1;
1332 
      }
1333 
      else if(attr.styleGGB == 5) {
1334 
        attr.fillColor = 'none';
1335 
      }
1336 
   }
1337 
   else if(attr.styleGGB == 6) {
1338 
      attr.face = 'triangleUp';
1339 
      attr.fillColor = attr.strokeColor;
1340 
      attr.fillOpacity = 1;
1341 
   }
1342 
   else if(attr.styleGGB == 7) {
1343 
      attr.face = 'triangleDown';
1344 
      attr.fillColor = attr.strokeColor;
1345 
      attr.fillOpacity = 1;
1346 
   }
1347 
   else if(attr.styleGGB == 8) {
1348 
      attr.face = 'triangleRight';
1349 
      attr.fillColor = attr.strokeColor;
1350 
      attr.fillOpacity = 1;
1351 
   }
1352 
   else if(attr.styleGGB == 9) {
1353 
      attr.face = 'triangleLeft';
1354 
      attr.fillColor = attr.strokeColor;
1355 
      attr.fillOpacity = 1;
1356 
   }
1357 
  (Data.getElementsByTagName('slopeTriangleSize')[0]) ? attr.slopeWidth = Data.getElementsByTagName('slopeTriangleSize')[0].getAttribute("val") : false;
1358 
  (Data.getElementsByTagName('lineStyle')[0]) ? attr.strokeWidth = (Data.getElementsByTagName('lineStyle')[0].getAttribute("thickness")/2.0)+'px' : false;
1359 
  if(attr.strokeWidth) {
1360 
    attr.highlightStrokeWidth = (1*attr.strokeWidth.substr(0,attr.strokeWidth.length-2)+1)+'px';
1361 
  }
1362 
  (Data.getElementsByTagName('lineStyle')[0]) ? attr.dashGGB = Data.getElementsByTagName('lineStyle')[0].getAttribute("type") : false;
1363 
 
1364 
   if(attr.dashGGB == 0) {
1365 
      attr.dash = 0;
1366 
   }
1367 
   else if(attr.dashGGB == 10) {
1368 
      attr.dash = 2;
1369 
   }
1370 
   else if(attr.dashGGB == 15) {
1371 
      attr.dash = 3;
1372 
   }
1373 
   else if(attr.dashGGB == 20) {
1374 
      attr.dash = 1;
1375 
   }
1376 
   else if(attr.dashGGB == 30) {
1377 
      attr.dash = 6;
1378 
   }
1379 
  (Data.getElementsByTagName("labelOffset")[0]) ? attr.labelX = 1*Data.getElementsByTagName("labelOffset")[0].getAttribute("x") : false;
1380 
  (Data.getElementsByTagName("labelOffset")[0]) ? attr.labelY = 1*Data.getElementsByTagName("labelOffset")[0].getAttribute("y") : false;
1381 
  (Data.getElementsByTagName("trace")[0]) ? attr.trace = Data.getElementsByTagName("trace")[0].getAttribute("val") : false;
1382 
  (Data.getElementsByTagName('fix')[0]) ? attr.fixed = Data.getElementsByTagName('fix')[0].getAttribute("val") : false;
1383 
  return attr;
1384 
};
1385 
 
1386 
/**
1387 
 * Searching for an element in the geogebra tree
1388 
 * @param {String} the name of the element to search for
1389 
 * @param {Boolean} whether it is search for an expression or not
1390 
 * @return {Object} object with according label
1391 
 */
1392 
this.getElement = function(name, expr) {
1393 
  var Data, i, j;
1394 
  expr = expr || false;
1395 
  for(i=0; i<JXG.GeogebraReader.tree.getElementsByTagName("construction").length; i++)
1396 
    if(expr == false) {
1397 
      for(j=0; j<JXG.GeogebraReader.tree.getElementsByTagName("construction")[i].getElementsByTagName("element").length; j++) {
1398 
        Data = JXG.GeogebraReader.tree.getElementsByTagName("construction")[i].getElementsByTagName("element")[j];
1399 
        if(name == Data.getAttribute("label")) {
1400 
          return Data;
1401 
        }
1402 
      };
1403 
    } else {
1404 
      for(j=0; j<JXG.GeogebraReader.tree.getElementsByTagName("construction")[i].getElementsByTagName("expression").length; j++) {
1405 
        Data = JXG.GeogebraReader.tree.getElementsByTagName("construction")[i].getElementsByTagName("expression")[j];
1406 
        if(name == Data.getAttribute("label")) {
1407 
          return Data;
1408 
        }
1409 
      };
1410 
    }
1411 
  return false;
1412 
};
1413 
 
1414 
/**
1415 
 * Check if an element is already registered in the temporary ggbElements register. If not, create and register the element.
1416 
 * @param {String} the name of the element to check
1417 
 * @return {Object} newly created element
1418 
 */
1419 
this.checkElement = function(name) {
1420 
// Segment[A, B] nur bis Version 2.4 ? In 2.5 schon (x(A), x(B)) und durch Parser loesbar
1421 
  // if(name.match(/[a-zA-Z]+\[[a-zA-Z0-9]+[a-zA-Z0-9,\ ]*\]/)) {
1422 
  //   var tmp, type, input, output, i;
1423 
  //   tmp = name.split('[');
1424 
  //   type = tmp[0];
1425 
  //   input = tmp[1].split(']');
1426 
  //   input = input[0].split(', ');
1427 
  //   for(i=0; i<input.length; i++) {
1428 
  //     input[i] = JXG.GeogebraReader.checkElement(input[i]);
1429 
  //   }
1430 
  //   output = {
1431 
  //     'attributes' : []
1432 
  //   };
1433 
  //   output.attributes['type'] = {value: type };
1434 
  //   output.attributes['label'] = {value: name};
1435 
  //
1436 
  //   JXG.GeogebraReader.board.ggbElements[name] = JXG.GeogebraReader.writeElement(JXG.GeogebraReader.board, name, input, type);
1437 
  // } else
1438 
  if(typeof JXG.GeogebraReader.board.ggbElements[name] == 'undefined' || JXG.GeogebraReader.board.ggbElements[name] == '') {
1439 
    var input = JXG.GeogebraReader.getElement(name);
1440 
    JXG.GeogebraReader.board.ggbElements[name] = JXG.GeogebraReader.writeElement(JXG.GeogebraReader.board, input);
1441 
  }
1442 
  return JXG.GeogebraReader.board.ggbElements[name];
1443 
};
1444 
 
1445 
/**
1446 
 * Prepare expression for this.ggbParse with solving multiplications and replacing mathematical functions.
1447 
 * @param {String} exp Expression to parse and correct
1448 
 * @return {String} correct expression with fixed function and multiplication
1449 
 */
1450 
this.functionParse = function(type, exp) {
1451 
 var input, vars, expr, output, i, s, o;
1452 
 switch(type) {
1453 
  case 'c':
1454 
    // search for function params
1455 
    if(exp.match(/[a-zA-Z0-9\']+\([a-zA-Z0-9]+[a-zA-Z0-9,\ ]*\)[\ ]*[=][\ ]*[a-zA-Z0-9\+\-\*\/ \( \) \u005E]+/)) {
1456 
      input = exp.split('(')[1].split(')')[0];
1457 
      vars = input.split(', ');
1458 
 
1459 
      output = [];
1460 
      for(i=0; i<vars.length; i++)
1461 
        output.push("__"+vars[i]);
1462 
 
1463 
      expr = exp.split('=')[1];
1464 
 
1465 
      // separate and replace function parameters
1466 
      for(i=0; i<vars.length; i++) {
1467 
        if(vars[i] == 'x') {
1468 
          expr = expr.replace(/(?![e])x(?!\()(?![p])/g, '__'+vars[i]);
1469 
        } else if(vars[i] == 'y') {
1470 
          expr = expr.replace(/(?![e])y(?!\()(?![p])/g, '__'+vars[i]);
1471 
        } else {
1472 
          expr = expr.replace( eval('/'+vars[i]+'/g'), '__'+vars[i] );
1473 
        }
1474 
      }
1475 
 
1476 
      // replace -__x to -1*__x
1477 
      expr = expr.replace(/-__/g, '-1*__');
1478 
 
1479 
          if(JXG.GeogebraReader.format <= 3.01) {
1480 
            // prepare string: "solve" multiplications 'a b' to 'a*b'
1481 
            s = expr.split(' ');
1482 
            o = '';
1483 
            for(var i=0; i<s.length; i++) {
1484 
              if(s.length != i+1)
1485 
                if(s[i].search(/\)$/) > -1 || s[i].search(/[0-9]+$/) > -1 || s[i].search(/[a-zA-Z]+(\_*[a-zA-Z0-9]+)*$/) > -1)
1486 
                  if(s[i+1].search(/^\(/) > -1 ||
1487 
                 s[i+1].search(/^[0-9]+/) > -1 ||
1488 
                 s[i+1].search(/^[a-zA-Z]+(\_*[a-zA-Z0-9]+)*/) > -1 ||
1489 
                 s[i+1].search(/\_\_[a-zA-Z0-9]+/) > -1) {
1490 
                       s[i] = s[i] + "*";
1491 
                 }
1492 
              o += s[i];
1493 
            };
1494 
            expr = o;
1495 
          }
1496 
 
1497 
      output.push(expr);
1498 
      return output;
1499 
    } else {
1500 
      return exp;
1501 
    }
1502 
  break;
1503 
  case 's':
1504 
    exp = exp.replace(/(?![e])x(?!\()(?![p])/g, '__x');
1505 
    return ['__x', exp];
1506 
  break;
1507 
  default:
1508 
    if(JXG.GeogebraReader.format <= 3.01) {
1509 
          // prepare string: "solve" multiplications 'a b' to 'a*b'
1510 
          s = exp.split(' ');
1511 
          o = '';
1512 
      for(i=0; i<s.length; i++) {
1513 
        if(s.length != i+1)
1514 
          if(s[i].search(/\)$/) > -1 || s[i].search(/[0-9]+$/) > -1 || s[i].search(/[a-zA-Z]+(\_*[a-zA-Z0-9]+)*$/) > -1)
1515 
            if(s[i+1].search(/^\(/) > -1 ||
1516 
              s[i+1].search(/^[0-9]+/) > -1 ||
1517 
              s[i+1].search(/^[a-zA-Z]+(\_*[a-zA-Z0-9]+)*/) > -1 ||
1518 
              s[i+1].search(/\_\_[a-zA-Z0-9]+/) > -1) {
1519 
                s[i] = s[i] + "*";
1520 
            }
1521 
            o += s[i];
1522 
          };
1523 
          exp = o;
1524 
        }
1525 
    return exp;
1526 
  break;
1527 
 }
1528 
};
1529 
 
1530 
/**
1531 
 * Searching for an element in the geogebra tree
1532 
 * @param {Object} board object
1533 
 */
1534 
this.writeBoard = function(board) {
1535 
  var boardData = JXG.GeogebraReader.tree.getElementsByTagName("euclidianView")[0];
1536 
 
1537 
  board.origin = {};
1538 
  board.origin.usrCoords = [1, 0, 0];
1539 
  board.origin.scrCoords = [1, 1*boardData.getElementsByTagName("coordSystem")[0].getAttribute("xZero"), 1*boardData.getElementsByTagName("coordSystem")[0].getAttribute("yZero")];
1540 
  board.unitX = (boardData.getElementsByTagName("coordSystem")[0].getAttribute("scale")) ? 1*boardData.getElementsByTagName("coordSystem")[0].getAttribute("scale") : 1;
1541 
  board.unitY = (boardData.getElementsByTagName("coordSystem")[0].getAttribute("yscale")) ? 1*boardData.getElementsByTagName("coordSystem")[0].getAttribute("yscale") : board.unitX;
1542 
 
1543 
  board.fontSize = (JXG.GeogebraReader.tree.getElementsByTagName("gui")[0] && JXG.GeogebraReader.tree.getElementsByTagName("gui")[0].getElementsByTagName("font")[0]) ? 1*JXG.GeogebraReader.tree.getElementsByTagName("gui")[0].getElementsByTagName("font")[0].getAttribute("size") : '12px';
1544 
 
1545 
  JXG.JSXGraph.boards[board.id] = board;
1546 
 
1547 
  // Update of properties during update() is not necessary in GEONExT files
1548 
  board.renderer.enhancedRendering = true;
1549 
 
1550 
  // snap to point
1551 
  var snapToPoint = (boardData.getElementsByTagName('evSettings')[0].getAttribute("pointCapturing") == "true");
1552 
 
1553 
  var grid = (boardData.getElementsByTagName('evSettings')[0].getAttribute("grid") == "true") ? board.create('grid') : null;
1554 
 
1555 
  if(boardData.getElementsByTagName('evSettings')[0].getAttribute("axes") && boardData.getElementsByTagName('evSettings')[0].getAttribute("axes") == "true") {
1556 
      board.ggbElements["xAxis"] = board.create('axis', [[0, 0], [1, 0]], {strokeColor:'black', minorTicks: 0});
1557 
      board.ggbElements["yAxis"] = board.create('axis', [[0, 0], [0, 1]], {strokeColor:'black', minorTicks: 0});
1558 
  }
1559 
};
1560 
 
1561 
/**
1562 
 * Searching for an element in the geogebra tree
1563 
 * @param {Object} board object
1564 
 * @param {Object} ggb element whose attributes are to parse
1565 
 * @param {Array} input list of all input elements
1566 
 * @param {String} typeName output construction method
1567 
 * @return {Object} return newly created element or false
1568 
 */
1569 
this.writeElement = function(board, output, input, cmd) {
1570 
  var element, gxtEl, attr, p, exp, coord, type, points, border, length, m, s, e, sx, sy, ex, ey, func, range;
1571 
  element = (JXG.isArray(output)) ? output[0] : output;
1572 
 
1573 
  gxtEl = {}; // geometric element
1574 
  attr = {}; // Attributes of geometric elements
1575 
 
1576 
  JXG.debug(element);
1577 
 
1578 
  gxtEl.type = (element && element.attributes && typeof cmd === 'undefined') ? element.getAttribute('type').toLowerCase() : cmd;
1579 
  gxtEl.label = element.getAttribute('label');
1580 
  attr.name  = gxtEl.label;
1581 
 
1582 
  JXG.debug("<br><b>Konstruiere</b> "+ attr.name +"("+ gxtEl.type +"):");
1583 
 
1584 
  switch(gxtEl.type) {
1585 
    case 'point':
1586 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1587 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1588 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1589 
 
1590 
      if(JXG.GeogebraReader.getElement(attr.name, true)) {
1591 
        exp = JXG.GeogebraReader.getElement(attr.name, true).getAttribute('exp');
1592 
        coord = JXG.GeogebraReader.ggbParse(exp);
1593 
        gxtEl.x = new Function('return '+ coord[0] +';');
1594 
        gxtEl.y = new Function('return '+ coord[1] +';');
1595 
      } else {
1596 
        gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1597 
      }
1598 
      if(!JXG.exists(attr.styleGGB)) {
1599 
         attr.face = 'circle';
1600 
         attr.fillColor = attr.strokeColor;
1601 
         attr.fillOpacity = 1;
1602 
         attr.highlightFillColor = attr.strokeColor;
1603 
         attr.highlightFillOpacity = 1;
1604 
         attr.strokeColor = 'black';
1605 
         attr.strokeWidth = '1px';
1606 
      }
1607 
 
1608 
      JXG.debug(gxtEl);
1609 
      JXG.debug(input);
1610 
 
1611 
      try {
1612 
        var ma = /Circle\[\s*(\w+)\s*,\s*([\d\.]+)\s*\]/.exec(input);
1613 
        if(typeof input != 'undefined') {
1614 
          if (ma!=null && ma.length==3) {
1615 
            // from Circle[A, 5] take "A" and "5", stored in ma[1] and ma[2]
1616 
            var q = JXG.GeogebraReader.checkElement(ma[1]);
1617 
            var c = board.create('circle', [q, parseFloat(ma[2])], {fillColor:'none',visible:false,name:''});
1618 
            p = board.create('glider', [gxtEl.x, gxtEl.y, c], attr);
1619 
          } else if(JXG.isArray(input)) {
1620 
            p = board.create('glider', [gxtEl.x, gxtEl.y, input[0]], attr);
1621 
          } else {
1622 
            p = board.create('glider', [gxtEl.x, gxtEl.y, input], attr);
1623 
          }
1624 
        } else {
1625 
          p = board.create('point', [gxtEl.x, gxtEl.y], attr);
1626 
        }
1627 
        return p;
1628 
      } catch(e) {
1629 
          JXG.debug("* <b>Err:</b> Point " + attr.name +"<br>\n");
1630 
          return false;
1631 
      }
1632 
    break;
1633 
    case 'segment':
1634 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1635 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1636 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1637 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1638 
 
1639 
      try {
1640 
        JXG.debug("* <b>Segment:</b> ("+ attr.name +") First: " + input[0].name + ", Last: " + input[1].name + "<br>\n");
1641 
        attr.straightFirst = false;
1642 
        attr.straightLast =  false;
1643 
        p = board.create('line', input, attr);
1644 
        return p;
1645 
      } catch(e) {
1646 
        JXG.debug("* <b>Err:</b> Segment " + attr.name +" First: " + input[0].name + ", Last: " + input[1].name + "<br>\n");
1647 
        return false;
1648 
      }
1649 
    break;
1650 
    case 'line':
1651 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1652 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1653 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1654 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1655 
 
1656 
      type = 'line';
1657 
      if(!input) {
1658 
        input = [ parseFloat(element.getElementsByTagName('coords')[0].getAttribute('z')),
1659 
                      parseFloat(element.getElementsByTagName('coords')[0].getAttribute('x')),
1660 
                      parseFloat(element.getElementsByTagName('coords')[0].getAttribute('y'))
1661 
                    ];
1662 
      } else if(JXG.getReference(board, input[1].id).type == 1330924622) {
1663 
         type = 'parallel'; // Parallele durch Punkt
1664 
      }
1665 
 
1666 
      try {
1667 
        p = board.create(type, input, attr);
1668 
        return p;
1669 
      } catch(e) {
1670 
        JXG.debug("* <b>Err:</b> Line " + attr.label +"<br>\n");
1671 
        return false;
1672 
      }
1673 
    break;
1674 
    case "orthogonalline":
1675 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1676 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1677 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1678 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1679 
 
1680 
      try {
1681 
        JXG.debug("* <b>Orthogonalline:</b> First: " + input[0].id + ", Last: " + input[1].id + "<br>\n");
1682 
        p = board.create('normal', input, attr);
1683 
        return p;
1684 
      } catch(e) {
1685 
        JXG.debug("* <b>Err:</b> Orthogonalline " + attr.label +"<br>\n");
1686 
        return false;
1687 
      }
1688 
    break;
1689 
    case "polygon":
1690 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1691 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1692 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1693 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1694 
 
1695 
      // test if polygon is regular
1696 
      if(input.length == 3 && output.length != 4) {
1697 
        input[2] = parseInt(input[2]);
1698 
        type = 'regular';
1699 
      }
1700 
 
1701 
      try {
1702 
        JXG.debug("* <b>Polygon:</b> First: " + input[0].name + ", Second: " + input[1].name + ", Third: " + input[2] + "<br>\n");
1703 
 
1704 
        var borders = [];
1705 
        var borderatts = [];
1706 
        length = (type == 'regular') ? output.length-input[2]+2 : output.length;
1707 
 
1708 
        for(var i=1; i<length; i++) {
1709 
          borders[i-1] = {};
1710 
          borderatts[i-1] = {};
1711 
          borders[i-1].id = '';
1712 
          borders[i-1].name = output[i].getAttribute('label');
1713 
          borderatts[i-1] = JXG.GeogebraReader.colorProperties(output[i], borderatts[i-1]);
1714 
          borderatts[i-1] = JXG.GeogebraReader.visualProperties(output[i], borderatts[i-1]);
1715 
          // JXG.debug("border["+ typeof borders[i-1] +"]: "+ borders[i-1].name);
1716 
        }
1717 
        attr.borders = borders;
1718 
 
1719 
        points = [];
1720 
        if(type == 'regular') {
1721 
          points.push(input[0]);
1722 
          points.push(input[1]);
1723 
 
1724 
          for(i=input[2]+1; i<output.length; i++){
1725 
            if(output[i].attributes)
1726 
              points.push(JXG.GeogebraReader.checkElement(output[i].getAttribute('label')));
1727 
            else
1728 
              points.push(output[i]);
1729 
          }
1730 
        } else {
1731 
          for(i=0; i<input.length; i++) {
1732 
            if(typeof input[i] === 'object') {
1733 
              points.push(input[i]);
1734 
              // JXG.debug("input-queue: added "+ input[i].name);
1735 
            }
1736 
          }
1737 
        }
1738 
 
1739 
        if(type == 'regular') {
1740 
          p = board.create('regularpolygon', points, attr);
1741 
        }
1742 
        else {
1743 
          p = board.create('polygon', points, attr);
1744 
        }
1745 
        for(i=0; i<p.borders.length; i++) {
1746 
            if(borderatts[i].withLabel) {
1747 
                p.borders[i].createLabel();
1748 
            }
1749 
            p.borders[i].setProperty(borderatts[i]);
1750 
        }
1751 
        return p;
1752 
      } catch(e) {
1753 
        JXG.debug("* <b>Err:</b> Polygon " + attr.name +"<br>\n");
1754 
        return false;
1755 
      }
1756 
    break;
1757 
    case 'intersect':
1758 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1759 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1760 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1761 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1762 
 
1763 
      try {
1764 
        JXG.debug("* <b>Intersection:</b> First: " + input[0].name + ", Second: " + input[1].name + "<br>\n");
1765 
        if(!JXG.exists(attr.styleGGB)) {
1766 
           attr.face = 'circle';
1767 
           attr.fillColor = attr.strokeColor;
1768 
           attr.fillOpacity = 1;
1769 
           attr.highlightFillColor = attr.strokeColor;
1770 
           attr.highlightFillOpacity = 1;
1771 
           attr.strokeColor = 'black';
1772 
           attr.strokeWidth = '1px';
1773 
        }
1774 
        if(output.length == 1) {
1775 
           p = board.create('intersection', [input[0], input[1], 0], attr);
1776 
        }
1777 
        else {
1778 
           p = board.create('intersection', [input[0], input[1], 1], attr);
1779 
           var attr2 = {};
1780 
           attr2 = JXG.GeogebraReader.colorProperties(output[1], attr2);
1781 
           attr2 = JXG.GeogebraReader.visualProperties(output[1], attr2);
1782 
           attr2.name = output[1].getAttribute('label');
1783 
           var p2 = board.create('otherintersection', [input[0], input[1], p], attr2);
1784 
           board.ggbElements[attr2.name] = p2;
1785 
        }
1786 
 
1787 
        return p;
1788 
      } catch(e) {
1789 
        JXG.debug("* <b>Err:</b> Intersection " + attr.name +"<br>\n");
1790 
        return false;
1791 
      }
1792 
    break;
1793 
    case 'distance':
1794 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1795 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1796 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1797 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1798 
 
1799 
 
1800 
      try {
1801 
        JXG.debug("* <b>Distance:</b> First: " + input[0].name + ", Second: " + input[1].name + "<br>\n");
1802 
 
1803 
        if(false && output[0].getAtribute('type') && output[0].getAttribute('type') == 'numeric') {
1804 
          input[1].Value = function(){ return this.X(); };
1805 
          p = input[1];
1806 
          board.elementsByName[attr.name] = p;
1807 
        } else {
1808 
          m = board.create('midpoint', input, {visible: 'false'});
1809 
          attr.visible = 'true';
1810 
          p = board.create('text', [function(){return m.X();}, function(){return m.Y();}, function(){
1811 
              return "<span style='text-decoration: overline'>"+ input[0].name + input[1].name +"</span> = "
1812 
                     + JXG.trimNumber(JXG.getReference(board, input[0].id).Dist(JXG.getReference(board, input[1].id)).toFixed(JXG.GeogebraReader.decimals));
1813 
                }], attr);
1814 
          p.Value = function () {
1815 
            return (JXG.getReference(board, input[0].id).Dist(JXG.getReference(board, input[1].id)));
1816 
          }
1817 
        }
1818 
        return p;
1819 
      } catch(e) {
1820 
        JXG.debug("* <b>Err:</b> Distance " + attr.name +"<br>\n");
1821 
        return false;
1822 
      }
1823 
    break;
1824 
    case 'vector':
1825 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1826 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1827 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1828 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1829 
 
1830 
      if(element.getElementsByTagName("startPoint")[0]) {
1831 
 
1832 
        if(input && input.length == 2) {
1833 
            e = JXG.GeogebraReader.checkElement(input[1].name);
1834 
        } else {
1835 
            e = [parseFloat(element.getElementsByTagName("coords")[0].getAttribute("x")), parseFloat(element.getElementsByTagName("coords")[0].getAttribute("y"))];
1836 
        }
1837 
        if(element.getElementsByTagName("startPoint")[0].getAttribute("x") && element.getElementsByTagName("startPoint")[0].getAttribute("y")) {
1838 
            s = [parseFloat(element.getElementsByTagName("startPoint")[0].getAttribute("x")), parseFloat(element.getElementsByTagName("startPoint")[0].getAttribute("y"))];
1839 
        } else if(element.getElementsByTagName("startPoint")[0].getAttribute("exp")) {
1840 
            var startpoint = element.getElementsByTagName("startPoint")[0].getAttribute("exp");
1841 
            s = JXG.GeogebraReader.checkElement(startpoint);
1842 
        }
1843 
      } else if(input && input.length != 0) {
1844 
        s = input[0];
1845 
        e = input[1];
1846 
      } else {
1847 
        exp = JXG.GeogebraReader.getElement(element.getAttribute('label'), true);
1848 
        if(exp) {// experimental
1849 
            exp = exp.getAttribute('exp');
1850 
            // exp = JXG.GeogebraReader.functionParse('', exp);
1851 
            exp = JXG.GeogebraReader.ggbParse(exp);
1852 
            if (JXG.isArray(exp))
1853 
                exp = new Array(new Function('return '+ exp[1] +';'), new Function('return '+ exp[2] +';'));
1854 
            else
1855 
                exp = new Function('return '+ exp +';');
1856 
            JXG.debug('exp: '+ exp);
1857 
            p = board.create('arrow', [[0,0], [exp[0], exp[1]]], attr);
1858 
            return p;
1859 
            //t = JXG.getReference(board, 'a');
1860 
            //s = t.point1;
1861 
            // var e = [-1*vector.point2.X(), -1*vector.point2.Y()];
1862 
            // attr.type = 'rotate';
1863 
            // var angle;
1864 
            // if(exp < 0) {
1865 
            //   angle = Math.PI;
1866 
            // } else if(exp == 0) {
1867 
            //   angle = 0;
1868 
            // } else {
1869 
            //   angle = Math.PI/exp;
1870 
            // }
1871 
            // needed: a clean rotating based on factor 'exp'
1872 
 
1873 
            // priorization of expression like 't*a' --> a := startPoint
1874 
        }
1875 
      }
1876 
 
1877 
      try {
1878 
        JXG.debug("* <b>Vector:</b> First: " + attr.name);
1879 
        p = board.create('arrow', [s, e], attr);
1880 
        return p;
1881 
      } catch(e) {
1882 
        JXG.debug("* <b>Err:</b> Vector " + attr.name + e +"<br>\n");
1883 
        return false;
1884 
      }
1885 
    break;
1886 
    case 'rotate':
1887 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1888 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1889 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1890 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1891 
 
1892 
      try {
1893 
        JXG.debug("* <b>Rotate:</b> First: " + input[0].name + ", Second: " + input[1] + "<br>\n");
1894 
        attr.type = 'rotate';
1895 
 
1896 
        if(!JXG.exists(attr.styleGGB)) {
1897 
           attr.face = 'circle';
1898 
           attr.fillColor = attr.strokeColor;
1899 
           attr.fillOpacity = 1;
1900 
           attr.highlightFillColor = attr.strokeColor;
1901 
           attr.highlightFillOpacity = 1;
1902 
           attr.strokeColor = 'black';
1903 
           attr.strokeWidth = '1px';
1904 
        }
1905 
 
1906 
        t = board.create('transform', [parseInt(input[1])*Math.PI/180, input[2]], {type:'rotate'});
1907 
        p = board.create('point', [input[0], t], attr);
1908 
        return p;
1909 
      } catch(e) {
1910 
        JXG.debug("* <b>Err:</b> Rotate " + attr.name +"<br>\n");
1911 
        return false;
1912 
      }
1913 
    break;
1914 
    case 'dilate':
1915 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1916 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1917 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1918 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1919 
 
1920 
      try {
1921 
        JXG.debug("* <b>Dilate:</b> First: " + input[0].name + ", Second: " + input[1] + "<br>\n");
1922 
        attr.type = 'rotate';
1923 
        var d = parseInt(input[1]);
1924 
        var d1 = board.create('transform', [d, d], {type:'scale'});
1925 
        var d2 = board.create('transform', [function() { return (1-d) * input[2].X(); },
1926 
                                               function() { return (1-d) * input[2].Y(); }], {type:'translate'});
1927 
 
1928 
        if(!JXG.exists(attr.styleGGB)) {
1929 
           attr.face = 'circle';
1930 
           attr.fillColor = attr.strokeColor;
1931 
           attr.fillOpacity = 1;
1932 
           attr.highlightFillColor = attr.strokeColor;
1933 
           attr.highlightFillOpacity = 1;
1934 
           attr.strokeColor = 'black';
1935 
           attr.strokeWidth = '1px';
1936 
        }
1937 
        p = board.create('point', [input[0], [d1, d2]], attr);
1938 
 
1939 
        return p;
1940 
      } catch(e) {
1941 
        JXG.debug("* <b>Err:</b> Dilate " + attr.name +"<br>\n");
1942 
        return false;
1943 
      }
1944 
    break;
1945 
    case 'translate':
1946 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1947 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1948 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1949 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1950 
 
1951 
      try {
1952 
          t = board.create('transform', [function() { return input[1].point2.X()-input[1].point1.X(); },
1953 
                                         function() { return input[1].point2.Y()-input[1].point1.Y(); }], {type:'translate'});
1954 
          if(!JXG.exists(attr.styleGGB)) {
1955 
             attr.face = 'circle';
1956 
             attr.fillColor = attr.strokeColor;
1957 
             attr.fillOpacity = 1;
1958 
             attr.highlightFillColor = attr.strokeColor;
1959 
             attr.highlightFillOpacity = 1;
1960 
             attr.strokeColor = 'black';
1961 
             attr.strokeWidth = '1px';
1962 
          }
1963 
          p = board.create('point', [input[0], t], attr);
1964 
          return p;
1965 
      } catch(e) {
1966 
        JXG.debug("* <b>Err:</b> Translate " + attr.name +"<br>\n");
1967 
        return false;
1968 
      }
1969 
    break;
1970 
    case 'mirror':
1971 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1972 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1973 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1974 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1975 
 
1976 
      if(JXG.getReference(board, input[1].id).type == 1330925652) var type = 'mirrorpoint'; // Punktspiegelung
1977 
      else if(JXG.getReference(board, input[1].id).type == 1330924622) var type = 'reflection'; // Geradenspiegelung
1978 
 
1979 
      try {
1980 
        JXG.debug("* <b>Mirror:</b> First: " + input[0].name + ", Second: " + input[1].name + "<br>\n");
1981 
        p = board.create(type, [input[1], input[0]], attr);
1982 
        return p;
1983 
      } catch(e) {
1984 
        JXG.debug("* <b>Err:</b> Mirror " + attr.name +"<br>\n");
1985 
        return false;
1986 
      }
1987 
    break;
1988 
    case 'circle':
1989 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
1990 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
1991 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
1992 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
1993 
 
1994 
      try {
1995 
        JXG.debug("* <b>Circle:</b> First: " + input[0].name + ", Second: " + input[1] + "<br>\n");
1996 
        p = board.create('circle', input, attr);
1997 
        return p;
1998 
      } catch(e) {
1999 
        JXG.debug("* <b>Err:</b> Circle " + attr.name +"<br>\n");
2000 
        return false;
2001 
      }
2002 
    break;
2003 
    case 'circlearc':
2004 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2005 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2006 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2007 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2008 
 
2009 
      try {
2010 
        JXG.debug("* <b>CircleArc:</b> First: " + input[0].name + ", Second: " + input[1].name + "<br>\n");
2011 
        p = board.create('arc', input, attr);
2012 
        return p;
2013 
      } catch(e) {
2014 
        JXG.debug("* <b>Err:</b> CircleArc " + attr.name +"<br>\n");
2015 
        return false;
2016 
      }
2017 
    break;
2018 
    case 'ellipse':
2019 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2020 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2021 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2022 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2023 
 
2024 
      try {
2025 
        JXG.debug("* <b>Ellipse:</b> First: " + input[0].name + ", Second: " + input[1].name + ", Third: "+ input[2] +"<br>\n");
2026 
        // if third parameters is the major axis, else the third parameter is a point
2027 
        if(parseInt(input[2]) == input[2])
2028 
          input[2] = parseInt(input[2]*2); // Geogebra delivers the half major axis
2029 
 
2030 
        p = board.create('ellipse', input, attr);
2031 
        return p;
2032 
      } catch(e) {
2033 
        JXG.debug("* <b>Err:</b> Ellipse " + attr.name +"<br>\n");
2034 
        return false;
2035 
      }
2036 
    break;
2037 
    case 'conic':
2038 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2039 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2040 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2041 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2042 
 
2043 
//      try {
2044 
        /*
2045 
        // is there an expression named like the conic?
2046 
        var exp = JXG.GeogebraReader.getElement(attr.name, true);
2047 
 
2048 
        // then get the function parameteres
2049 
        if(exp.attributes['exp']){
2050 
          // exp = JXG.GeogebraReader.functionParse(exp.attributes['exp'].value);
2051 
          // exp = JXG.GeogebraReader.ggbParse(exp.attributes['exp'].value);
2052 
 
2053 
 
2054 
 
2055 
          // (exp.getElementsByTagName('value')) ? exp = parseFloat(exp.getElementsByTagName('value')[0].attributes['val'].value) : false;
2056 
 
2057 
        } else */ if(input && input.length == 5) {
2058 
          p = board.create('conic', input, attr);
2059 
        } else if(element.getElementsByTagName('matrix')) {
2060 
          m = [];
2061 
          for(var i=0; i<element.getElementsByTagName('matrix')[0].attributes.length; i++) {
2062 
            m[i] = parseFloat(element.getElementsByTagName('matrix')[0].attributes[i].value);
2063 
          }
2064 
          p = board.create('conic', m, attr);
2065 
        }
2066 
 
2067 
        return p;
2068 
//      } catch(e) {
2069 
//        JXG.debug("* <b>Err:</b> Conic " + attr.name +"<br>\n");
2070 
//        return false;
2071 
//      }
2072 
    break;
2073 
    case 'circlesector':
2074 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2075 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2076 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2077 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2078 
      //attr.names = [attr.name,'','',''];
2079 
      //attr2 = {};
2080 
      //attr2.names = attr.names;
2081 
      try {
2082 
        JXG.debug("* <b>CircleSector:</b> First: " + input[0].name + ", Second: " + input[1].name + ", Third: " + input[2].name + "<br>\n");
2083 
        p = board.create('sector', [input[0],input[1],input[2]], attr);
2084 
        /*
2085 
        p.point4.hideElement();
2086 
        p.arc.setProperty(attr);
2087 
        p.arc.visProp.highlightstrokewidth = (1*p.arc.visProp.strokewidth.substr(0,p.arc.visProp.strokewidth.length-2)+1)+'px';
2088 
        p.lines[0].setProperty(attr);
2089 
        p.lines[1].setProperty(attr);
2090 
        p.lines[0].visProp.highlightstrokewidth = (1*p.lines[0].visProp.strokerwWidth.substr(0,p.lines[0].visProp.strokewidth.length-2)+1)+'px';
2091 
        p.lines[1].visProp.highlightstrokewidth = (1*p.lines[1].visProp.strokerwWidth.substr(0,p.lines[1].visProp.strokewidth.length-2)+1)+'px';
2092 
        p.arc.hasPoint = p.arc.hasPointSector;
2093 
        p.arc.highlight = (function(el){ return function() {
2094 
            this.board.renderer.highlight(this);
2095 
            this.board.renderer.highlight(el.lines[0]);
2096 
            this.board.renderer.highlight(el.lines[1]);
2097 
        };})(p);
2098 
        p.arc.noHighlight = (function(el){ return function() {
2099 
            this.board.renderer.noHighlight(this);
2100 
            this.board.renderer.noHighlight(el.lines[0]);
2101 
            this.board.renderer.noHighlight(el.lines[1]);
2102 
        };})(p);
2103 
        p.lines[0].highlight = (function(el){ return function() {
2104 
            this.board.renderer.highlight(this);
2105 
            this.board.renderer.highlight(el.arc);
2106 
            this.board.renderer.highlight(el.lines[1]);
2107 
        };})(p);
2108 
        p.lines[1].highlight = (function(el){ return function() {
2109 
            this.board.renderer.highlight(this);
2110 
            this.board.renderer.highlight(el.arc);
2111 
            this.board.renderer.highlight(el.lines[0]);
2112 
        };})(p);
2113 
        p.lines[0].noHighlight = (function(el){ return function() {
2114 
            this.board.renderer.noHighlight(this);
2115 
            this.board.renderer.noHighlight(el.arc);
2116 
            this.board.renderer.noHighlight(el.lines[1]);
2117 
        };})(p);
2118 
        p.lines[1].noHighlight = (function(el){ return function() {
2119 
            this.board.renderer.noHighlight(this);
2120 
            this.board.renderer.noHighlight(el.arc);
2121 
            this.board.renderer.noHighlight(el.lines[0]);
2122 
        };})(p);
2123 
        */
2124 
        return p;
2125 
      } catch(e) {
2126 
        JXG.debug("* <b>Err:</b> CircleSector " + attr.name +"<br>\n");
2127 
        return false;
2128 
      }
2129 
    break;
2130 
    case 'linebisector':
2131 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2132 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2133 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2134 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2135 
 
2136 
      try {
2137 
        JXG.debug("* <b>LineBiSector (Mittelsenkrechte):</b> First: " + input[0].name + "<br>\n");
2138 
        attr.straightFirst = true;
2139 
        attr.straightLast =  true;
2140 
 
2141 
        m = board.create('midpoint', input, {visible: false});
2142 
        if(JXG.getReference(board, input[0].id).type == 1330925652 && JXG.getReference(board, input[1].id).type == 1330925652) {
2143 
          t = board.create('line', input, {visible: 'false'});
2144 
          p = board.create('perpendicular', [m, t], attr);
2145 
          p.point.setProperty('visible:false');
2146 
        } else {
2147 
          p = board.create('perpendicular', [m, input[0]], attr);
2148 
          p.point.setProperty('visible:false');
2149 
        }
2150 
        return p[0];
2151 
      } catch(e) {
2152 
        JXG.debug("* <b>Err:</b> LineBiSector (Mittelsenkrechte) " + attr.name +"<br>\n");
2153 
        return false;
2154 
      }
2155 
    break;
2156 
    case 'ray':
2157 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2158 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2159 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2160 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2161 
 
2162 
      try {
2163 
        JXG.debug("* <b>Ray:</b> First: " + input[0].name + "<br>\n");
2164 
        attr.straightFirst = true;
2165 
        attr.straightLast =  false;
2166 
        p = board.create('line', [input[1], input[0]], attr);
2167 
        return p;
2168 
      } catch(e) {
2169 
        JXG.debug("* <b>Err:</b> Ray " + attr.name +"<br>\n");
2170 
        return false;
2171 
      }
2172 
    break;
2173 
    case 'tangent':
2174 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2175 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2176 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2177 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2178 
 
2179 
      try {
2180 
        JXG.debug("* <b>Tangent:</b> First: " + input[0].name + ", Sec.: "+ input[1].name +"("+ input[1].type +")<br>\n");
2181 
        switch(input[1].type) {
2182 
          case 1330923344: // graph
2183 
            input[0].makeGlider(input[1]);
2184 
            p = board.create('tangent', [input[0]], attr);
2185 
            return p;
2186 
          break;
2187 
          case 1330922316: // circle 0x4F54434C
2188 
          case 1330922319: // conic 0x4F54434F
2189 
            /*
2190 
            m = function(circ) {
2191 
                return [[circ.midpoint.X()*circ.midpoint.X()+circ.midpoint.Y()*circ.midpoint.Y()-circ.Radius()*circ.Radius(),
2192 
                             -circ.midpoint.X(),-circ.midpoint.Y()],
2193 
                            [-circ.midpoint.X(),1,0],
2194 
                            [-circ.midpoint.Y(),0,1]
2195 
                           ];
2196 
                    };
2197 
 
2198 
                t = board.create('line', [
2199 
                            function(){ return JXG.Math.matVecMult(m(input[1]), input[0].coords.usrCoords)[0]; },
2200 
                            function(){ return JXG.Math.matVecMult(m(input[1]), input[0].coords.usrCoords)[1]; },
2201 
                            function(){ return JXG.Math.matVecMult(m(input[1]), input[0].coords.usrCoords)[2]; }
2202 
                        ], {visible: false});
2203 
                     */
2204 
            // input[0]: point
2205 
            // input[1]: circle or conic
2206 
            var pol = board.create('polar',[input[1],input[0]],{visible:false});
2207 
                var i1 = board.create('intersection', [input[1], pol, 0], {visible: false});
2208 
                var i2 = board.create('intersection', [input[1], pol, 1], {visible: false});
2209 
                var t1 = board.create('line', [input[0], i1], attr);
2210 
            var attr2 = {};
2211 
            attr2 = JXG.GeogebraReader.colorProperties(output[1], attr2);
2212 
            attr2 = JXG.GeogebraReader.visualProperties(output[1], attr2);
2213 
            attr2.name = output[1].getAttribute('label');
2214 
            var t2 = board.create('line', [input[0], i2], attr2);
2215 
            board.ggbElements[attr2.name] = t2;
2216 
            return [t1, t2];
2217 
          break;
2218 
        }
2219 
      } catch(e) {
2220 
        JXG.debug("* <b>Err:</b> Tangent " + attr.name +" "+ attr2.name + "<br>\n");
2221 
        return false;
2222 
      }
2223 
    break;
2224 
    case 'circumcirclearc':
2225 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2226 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2227 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2228 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2229 
 
2230 
      try {
2231 
        JXG.debug("* <b>CircumcircleArc:</b> First: " + input[0].name + "<br>\n");
2232 
        p = board.create('circumcirclearc', input, attr);
2233 
        return p;
2234 
      } catch(e) {
2235 
        JXG.debug("* <b>Err:</b> CircumcircleArc " + attr.name +"<br>\n");
2236 
        return false;
2237 
      }
2238 
    break;
2239 
    case 'circumcirclesector':
2240 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2241 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2242 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2243 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2244 
 
2245 
      try {
2246 
        JXG.debug("* <b>CircumcircleSector:</b> First: " + input[0].name + "<br>\n");
2247 
        p = board.create('circumcirclesector', [input[0], input[1], input[2]], attr); //{name:attr['name']});
2248 
        /*
2249 
        p.arc.setProperty(attr);
2250 
        p.lines[0].setProperty(attr);
2251 
        p.lines[1].setProperty(attr);
2252 
        p.arc.visProp.highlightstrokewidth = (1*p.arc.visProp.strokewidth.substr(0,p.arc.visProp.strokewidth.length-2)+1)+'px';
2253 
        p.lines[0].visProp.highlightstrokewidth = (1*p.lines[0].visProp.strokewidth.substr(0,p.lines[0].visProp.strokewidth.length-2)+1)+'px';
2254 
        p.lines[1].visProp.highlightstrokewidth = (1*p.lines[1].visProp.strokewidth.substr(0,p.lines[1].visProp.strokewidth.length-2)+1)+'px';
2255 
        p.arc.hasPoint = p.arc.hasPointSector;
2256 
        p.arc.highlight = (function(el){ return function() {
2257 
            this.board.renderer.highlight(this);
2258 
            this.board.renderer.highlight(el.lines[0]);
2259 
            this.board.renderer.highlight(el.lines[1]);
2260 
        };})(p);
2261 
        p.arc.noHighlight = (function(el){ return function() {
2262 
            this.board.renderer.noHighlight(this);
2263 
            this.board.renderer.noHighlight(el.lines[0]);
2264 
            this.board.renderer.noHighlight(el.lines[1]);
2265 
        };})(p);
2266 
        p.lines[0].highlight = (function(el){ return function() {
2267 
            this.board.renderer.highlight(this);
2268 
            this.board.renderer.highlight(el.arc);
2269 
            this.board.renderer.highlight(el.lines[1]);
2270 
        };})(p);
2271 
        p.lines[1].highlight = (function(el){ return function() {
2272 
            this.board.renderer.highlight(this);
2273 
            this.board.renderer.highlight(el.arc);
2274 
            this.board.renderer.highlight(el.lines[0]);
2275 
        };})(p);
2276 
        p.lines[0].noHighlight = (function(el){ return function() {
2277 
            this.board.renderer.noHighlight(this);
2278 
            this.board.renderer.noHighlight(el.arc);
2279 
            this.board.renderer.noHighlight(el.lines[1]);
2280 
        };})(p);
2281 
        p.lines[1].noHighlight = (function(el){ return function() {
2282 
            this.board.renderer.noHighlight(this);
2283 
            this.board.renderer.noHighlight(el.arc);
2284 
            this.board.renderer.noHighlight(el.lines[0]);
2285 
        };})(p);
2286 
        */
2287 
        return p;
2288 
      } catch(e) {
2289 
        JXG.debug("* <b>Err:</b> CircumcircleSector " + attr.name +"<br>\n");
2290 
        return false;
2291 
      }
2292 
    break;
2293 
    case 'semicircle':
2294 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2295 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2296 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2297 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2298 
 
2299 
      try {
2300 
        JXG.debug("* <b>Semicircle:</b> First: " + input[0].name + "<br>\n");
2301 
        p = board.create('semicircle', [input[0], input[1]], attr);
2302 
        return p;
2303 
      } catch(e) {
2304 
        JXG.debug("* <b>Err:</b> Semicircle " + attr.name +"<br>\n");
2305 
        return false;
2306 
      }
2307 
    break;
2308 
    case 'angle':
2309 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2310 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2311 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2312 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2313 
 
2314 
      try {
2315 
        JXG.debug("* <b>Angle:</b> First: " + input[0].name + "<br>\n");
2316 
        p = board.create('angle', input, attr);
2317 
        return p;
2318 
      } catch(e) {
2319 
        JXG.debug("* <b>Err:</b> Angle " + attr.name +"<br>\n");
2320 
        return false;
2321 
      }
2322 
    break;
2323 
    case 'angularbisector':
2324 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2325 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2326 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2327 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2328 
      attr.straightFirst = true;
2329 
      attr.straightLast = true;
2330 
 
2331 
      try {
2332 
        JXG.debug("* <b>Angularbisector:</b> First: " + input[0].name + "<br>\n");
2333 
        p = board.create('bisector', input, attr);
2334 
        return p;
2335 
      } catch(e) {
2336 
        JXG.debug("* <b>Err:</b> Angularbisector " + attr.name +"<br>\n");
2337 
        return false;
2338 
      }
2339 
    break;
2340 
    case 'numeric':
2341 
    if(element.getElementsByTagName('slider').length == 0) {
2342 
      // auxiliary doesn't exist in every numeric
2343 
      //element.getElementsByTagName('auxiliary').length != 0 && element.getElementsByTagName('auxiliary')[0].attributes['val'].value == 'true') {
2344 
      exp = JXG.GeogebraReader.getElement(element.getAttribute('label'), true);
2345 
      if(exp) {
2346 
          exp = exp.getAttribute('exp');
2347 
          exp = JXG.GeogebraReader.functionParse('', exp);
2348 
          exp = JXG.GeogebraReader.ggbParse(exp);
2349 
      }
2350 
      board.ggb[attr.name] = new Function('return '+ exp +';');
2351 
      JXG.debug('value: '+ board.ggb[attr.name]());
2352 
      return board.ggb[attr.name];
2353 
        } else {
2354 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2355 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2356 
      // gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2357 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2358 
      if(element.getElementsByTagName('slider').length == 1) { // it's a slider
2359 
        sx = parseFloat(element.getElementsByTagName('slider')[0].getAttribute('x'));
2360 
        sy = parseFloat(element.getElementsByTagName('slider')[0].getAttribute('y'));
2361 
        length = parseFloat(element.getElementsByTagName('slider')[0].getAttribute('width'));
2362 
        // are coordinates absolut?
2363 
        if(element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') && element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') == 'true') {
2364 
          var tmp = new JXG.Coords(JXG.COORDS_BY_SCREEN, [sx, sy], board);
2365 
          sx = tmp.usrCoords[1];
2366 
          sy = tmp.usrCoords[2];
2367 
        }
2368 
 
2369 
        if(element.getElementsByTagName('slider')[0].getAttribute('horizontal') == 'true') {
2370 
          if(element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') && element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') == 'true')
2371 
          length /= (board.unitX); //*board.zoomX);
2372 
          ex = sx + length;
2373 
          ey = sy;
2374 
        } else {
2375 
          if(element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') && element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') == 'true')
2376 
          length /= (board.unitY); //*board.zoomY);
2377 
          ex = sx;
2378 
          ey = sy + length;
2379 
        }
2380 
 
2381 
        (element.getElementsByTagName('animation')[0]) ? attr.snapWidth = parseFloat(element.getElementsByTagName('animation')[0].getAttribute('step')) : false;
2382 
 
2383 
        try {
2384 
          JXG.debug("* <b>Numeric:</b> First: " + attr.name + "<br>\n");
2385 
          attr['withTicks'] = false;
2386 
          p = board.create('slider', [[sx,sy], [ex,ey], [parseFloat(element.getElementsByTagName('slider')[0].getAttribute('min')),
2387 
                                                         parseFloat(element.getElementsByTagName('value')[0].getAttribute('val')),
2388 
                                                         parseFloat(element.getElementsByTagName('slider')[0].getAttribute('max'))]], attr);
2389 
          p.setProperty({withLabel:false});
2390 
          return p;
2391 
        } catch(e) {
2392 
          JXG.debug("* <b>Err:</b> Numeric " + attr.name +"<br>\n");
2393 
          return false;
2394 
        }
2395 
      }
2396 
    }
2397 
    break;
2398 
    case 'midpoint':
2399 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2400 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2401 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2402 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2403 
 
2404 
      try {
2405 
          if(!JXG.exists(attr.styleGGB)) {
2406 
             attr.face = 'circle';
2407 
             attr.fillColor = attr.strokeColor;
2408 
             attr.fillOpacity = 1;
2409 
             attr.highlightFillColor = attr.strokeColor;
2410 
             attr.highlightFillOpacity = 1;
2411 
             attr.strokeColor = 'black';
2412 
             attr.strokeWidth = '1px';
2413 
          }
2414 
          p = board.create('midpoint', input, attr);
2415 
          JXG.debug("* <b>Midpoint ("+ p.id +"):</b> "+ attr.name + "("+ gxtEl.x +", "+ gxtEl.y +")<br>\n");
2416 
          return p;
2417 
      } catch(e) {
2418 
          JXG.debug("* <b>Err:</b> Midpoint " + attr.name +"<br>\n");
2419 
          return false;
2420 
      }
2421 
    break;
2422 
    case 'center':
2423 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2424 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2425 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2426 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2427 
      try {
2428 
          if(!JXG.exists(attr.styleGGB)) {
2429 
             attr.face = 'circle';
2430 
             attr.fillColor = attr.strokeColor;
2431 
             attr.fillOpacity = 1;
2432 
             attr.highlightFillColor = attr.strokeColor;
2433 
             attr.highlightFillOpacity = 1;
2434 
             attr.strokeColor = 'black';
2435 
             attr.strokeWidth = '1px';
2436 
          }
2437 
          p = board.create('point', [function() { return JXG.getReference(board, input[0].id).midpoint.X(); },
2438 
                                     function() { return JXG.getReference(board, input[0].id).midpoint.Y(); }], attr);
2439 
          JXG.debug("* <b>Center ("+ p.id +"):</b> "+ attr.name + "("+ gxtEl.x +", "+ gxtEl.y +")<br>\n");
2440 
          return p;
2441 
      } catch(e) {
2442 
          JXG.debug("* <b>Err:</b> Center " + attr.name +"<br>\n");
2443 
          return false;
2444 
      }
2445 
    break;
2446 
    case 'function':
2447 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2448 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2449 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2450 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2451 
 
2452 
      if(JXG.GeogebraReader.getElement(attr.name, true)) {
2453 
        func = JXG.GeogebraReader.getElement(attr.name, true).getAttribute('exp');
2454 
        func = JXG.GeogebraReader.functionParse('c', func);
2455 
      } else {
2456 
        func = input[0];
2457 
        func = JXG.GeogebraReader.functionParse('s', func);
2458 
      }
2459 
 
2460 
      JXG.debug(func);
2461 
 
2462 
      length = func.length;
2463 
      func[func.length-1] = 'return '+ JXG.GeogebraReader.ggbParse(func[func.length-1]) +';';
2464 
 
2465 
      JXG.debug(func);
2466 
 
2467 
      range = [(input && input[1]) ? input[1] : null, (input && input[2]) ? input[2] : null];
2468 
 
2469 
      try {
2470 
        if(length == 1)
2471 
          p = board.create('functiongraph', [new Function(func[0]), range[0], range[1]], attr);
2472 
        else if(length==2)
2473 
          p = board.create('functiongraph', [new Function(func[0], func[1]), range[0], range[1]], attr);
2474 
        else if(length==3)
2475 
          p = board.create('functiongraph', [new Function(func[0], func[1], func[2]), range[0], range[1]], attr);
2476 
        else if(length==4)
2477 
          p = board.create('functiongraph', [new Function(func[0], func[1], func[2], func[3]), range[0], range[1]], attr);
2478 
        else if(length==5)
2479 
          p = board.create('functiongraph', [new Function(func[0], func[1], func[2], func[3], func[4]), range[0], range[1]], attr);
2480 
        return p;
2481 
      } catch(e) {
2482 
        JXG.debug("* <b>Err:</b> Functiongraph " + attr.name +"<br>\n");
2483 
        return false;
2484 
      }
2485 
 
2486 
     break;
2487 
     case 'polar':
2488 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2489 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2490 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2491 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2492 
 
2493 
      try {
2494 
        JXG.debug("* <b>Polar:</b> First: " + input[0].name + ", Sec.: "+ input[1].name +"<br>\n");
2495 
        p = board.create('polar', input, attr);
2496 
        return p;
2497 
      } catch(e) {
2498 
        JXG.debug("* <b>Err:</b> Polar " + attr.name +"<br>\n");
2499 
        return false;
2500 
      }
2501 
    break;
2502 
    case 'slope':
2503 
     attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2504 
     attr = JXG.GeogebraReader.colorProperties(element, attr);
2505 
     gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2506 
     attr = JXG.GeogebraReader.visualProperties(element, attr);
2507 
 
2508 
     try {
2509 
       JXG.debug("* <b>Slope ("+ attr.name +"):</b> First: " + input[0].name +"<br>\n");
2510 
       var slopeWidth = parseInt(attr.slopeWidth) || 1.0;
2511 
       var p1 = input[0].glider || input[0].point1;
2512 
       var p2 = board.create('point',[function(){return (slopeWidth+p1.X());}, function(){return p1.Y();}], {visible: false});
2513 
       var l1 = board.create('segment', [p1, p2], {visible: false}); // visible: attr.visible
2514 
       var l2 = board.create('normal', [l1, l1.point2], {visible: false}); // visible attr.visible
2515 
       var i  = board.create('intersection', [input[0], l2, 0], {visible: false});
2516 
       var m  = board.create('midpoint', [l1.point2, i], {visible: false});
2517 
 
2518 
       var t = board.create('text', [function(){return m.X();}, function(){return m.Y();},
2519 
                      function(){ return "&nbsp;&nbsp;" + (slopeWidth > 1 ? slopeWidth.toString() : "") + " " + this.name + " = " + JXG.trimNumber((slopeWidth * input[0].getSlope()).toFixed(JXG.GeogebraReader.decimals)); }], attr);
2520 
       attr.name = "";
2521 
       var t2 = board.create('text', [function(){return (p1.X() + p2.X())/2.;}, function(){return p1.Y();},
2522 
                                     function(){ return "<br/>" + slopeWidth; }], attr);
2523 
       t.Value = (function() { return function(){ return input[0].getSlope(); }; })();
2524 
       var poly = board.create('polygon',[p1,p2,i], attr);
2525 
 
2526 
       poly.borders[2].setProperty({visible: false});
2527 
       poly.borders[0].setProperty({strokeColor: attr.fillColor, strokeWidth: attr.strokeWidth, highlightStrokeColor: attr.fillColor, dash:attr.dash});
2528 
       poly.borders[1].setProperty({strokeColor: attr.fillColor, strokeWidth: attr.strokeWidth, highlightStrokeColor: attr.fillColor, dash:attr.dash});      
2529 
       return t;
2530 
     } catch(e) {
2531 
       JXG.debug("* <b>Err:</b> Slope " + attr.name +"<br>\n");
2532 
       return false;
2533 
     }
2534 
    break;
2535 
    case 'text':
2536 
     attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2537 
     attr = JXG.GeogebraReader.colorProperties(element, attr);
2538 
     gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2539 
     attr = JXG.GeogebraReader.visualProperties(element, attr);
2540 
     var rx, res = '';
2541 
 
2542 
     try {
2543 
       if(element.getElementsByTagName('isLaTeX')[0] && element.getElementsByTagName('isLaTeX')[0].getAttribute('val') == 'true') {
2544 
         JXG.GeogebraReader.board.options.text.useASCIIMathML = true;
2545 
         t = JXG.GeogebraReader.getElement(attr.name, true).getAttribute('exp');
2546 
 
2547 
         // here we're searching for patterns like
2548 
         //    " + ... + "
2549 
         // ... will be sent to the ggbParser and a calculated text element is built from this.
2550 
         while(rx = t.match(/(.*?)" \+ (.+) \+ "(.*)/)) {
2551 
             var re2 = JXG.GeogebraReader.ggbParse(RegExp.$2);
2552 
             if (typeof re2 == 'string') {
2553 
               res = res + RegExp.$1 + re2;
2554 
             } else {
2555 
               res = res + RegExp.$1 + '" + JXG.trimNumber((' + re2 + ').toFixed(JXG.GeogebraReader.decimals)) + "';
2556 
             }
2557 
             t = RegExp.$3;
2558 
         }
2559 
         // we have to look, if the string's ending with a string-part or a formula part:
2560 
         if(rx = t.match(/(.*?)" \+ (.+)/)) {
2561 
             res = res + RegExp.$1 + '" + JXG.trimNumber((' + JXG.GeogebraReader.ggbParse(RegExp.$2) + ').toFixed(JXG.GeogebraReader.decimals))';
2562 
         } else
2563 
             res = res + t;
2564 
 
2565 
         JXG.debug("Text: "+res);
2566 
 
2567 
         p = board.create('text', [gxtEl.x, gxtEl.y, new Function('return ' + res + ';')], attr);
2568 
       } else {
2569 
         JXG.debug(JXG.GeogebraReader.getElement(attr.name, true).getAttribute('exp'));
2570 
         t = JXG.GeogebraReader.ggbParse(JXG.GeogebraReader.functionParse(false, JXG.GeogebraReader.getElement(attr.name, true).getAttribute('exp')));
2571 
         JXG.debug(t[1]);
2572 
         p = board.create('text', [gxtEl.x, gxtEl.y, new Function('return '+t[0]+' + " " + JXG.trimNumber(parseFloat(' + t[1] +').toFixed(JXG.GeogebraReader.decimals));') ], attr);
2573 
       }
2574 
       JXG.debug("* <b>Text:</b> " + t  +"<br>\n");
2575 
       return p;
2576 
     } catch(e) {
2577 
      JXG.debug("* <b>Err:</b> Text: " + t +"<br>\n");
2578 
      return false;
2579 
     }
2580 
    break;
2581 
    case 'root':
2582 
        attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2583 
        attr = JXG.GeogebraReader.colorProperties(element, attr);
2584 
        gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2585 
        attr = JXG.GeogebraReader.visualProperties(element, attr);
2586 
        //JXG.debug(JXG.getReference(board, gxtEl.id));
2587 
 
2588 
        for(var i=0; i<output.length; i++) {
2589 
          output[i] = JXG.GeogebraReader.checkElement(output[i].getAttribute('label'));
2590 
        }
2591 
 
2592 
        var inp;
2593 
        if(JXG.isArray(input)) {
2594 
            inp = input[0];
2595 
        } else {
2596 
            inp = input;
2597 
        }
2598 
 
2599 
        // At this point, the output points already exist.
2600 
        // Bind the root function to all output elements.
2601 
        // The start values for all output elements are the x-coordinates as given
2602 
        // in the ggb file.
2603 
        for(i=0; i<output.length; i++) {
2604 
            output[i].addConstraint([
2605 
                    (function(x){ return function(){ return board.root(inp.Y,x,inp);}; })(output[i].X()),
2606 
                    function(){ return 0;}
2607 
                ]);
2608 
        }
2609 
        //var p = board.create('point', [function(){ return board.root(output);}, function(){ return 1;}], attr);
2610 
        return output; // What to return here????
2611 
    break;
2612 
  case 'integral':
2613 
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
2614 
      attr = JXG.GeogebraReader.colorProperties(element, attr);
2615 
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
2616 
      attr = JXG.GeogebraReader.visualProperties(element, attr);
2617 
 
2618 
      try {
2619 
        JXG.debug("* <b>Integral:</b> First: " + input[0].name + ", Sec.: "+ input[1].name +", Thir.: "+ input[2].name +"<br>\n");
2620 
        JXG.debug([input[1](), input[2]()]);
2621 
        var p = board.create('integral', [JXG.getRef(board, input[0]), [input[1], input[2]]], attr);
2622 
        return p;
2623 
      } catch(e) {
2624 
        JXG.debug("* <b>Err:</b> Integral " + attr.name + e + "<br>\n");
2625 
        return false;
2626 
      }
2627 
    break;
2628 
 
2629 
// case 'transform':
2630 
// break;
2631 
//    case 'radius':
2632 
//    break;
2633 
//    case 'derivative':
2634 
//    break;
2635 
//    case 'root':
2636 
//    break;
2637 
//    case 'corner':
2638 
//    break;
2639 
//    case 'unitvector':
2640 
//    break;
2641 
//    case 'extremum':
2642 
//    break;
2643 
//    case 'turningpoint':
2644 
//    break;
2645 
//    case 'arc':
2646 
//    break;
2647 
//    case 'circlepart':
2648 
//    break;
2649 
//    case 'uppersum':
2650 
//    break;
2651 
//    case 'lowersum':
2652 
//    break;
2653 
//    case 'image':
2654 
//    break;
2655 
    default:
2656 
      return false;
2657 
    break;
2658 
  }
2659 
};
2660 
 
2661 
/**
2662 
 * Reading the elements of a geogebra file
2663 
 * @param {Object} board board object
2664 
 */
2665 
this.readGeogebra = function(tree, board) {
2666 
  var el, Data, i, els = [], expr;
2667 
 
2668 
  board.ggbElements = [];
2669 
  board.ggb = {};
2670 
  JXG.GeogebraReader.tree = tree;
2671 
  JXG.GeogebraReader.board = board;
2672 
  JXG.GeogebraReader.format = parseFloat(JXG.GeogebraReader.tree.getElementsByTagName('geogebra')[0].getAttribute('format'));
2673 
  JXG.GeogebraReader.decimals = parseInt(JXG.GeogebraReader.tree.getElementsByTagName('geogebra')[0].getElementsByTagName('kernel')[0].getElementsByTagName('decimals')[0].getAttribute('val'));
2674 
  JXG.GeogebraReader.writeBoard(board);
2675 
  board = JXG.GeogebraReader.setDefaultOptions(board);
2676 
 
2677 
  // speeding up the drawing process
2678 
  //board.suspendUpdate();
2679 
 
2680 
  var constructions = JXG.GeogebraReader.tree.getElementsByTagName("construction");
2681 
  for (var t=0; t<constructions.length; t++) {
2682 
 
2683 
    var cmds = constructions[t].getElementsByTagName("command");
2684 
    for (var s=0; s<cmds.length; s++) {
2685 
      Data = cmds[s];
2686 
 
2687 
      // JXG.debug('now i\'ll parse the command:');
2688 
      // JXG.debug(Data);
2689 
 
2690 
      var input = [];
2691 
      for (i=0; i<Data.getElementsByTagName("input")[0].attributes.length; i++) {
2692 
        el = Data.getElementsByTagName("input")[0].attributes[i].value;
2693 
        if(el.match(/\u00B0/) || !el.match(/\D/) || el.match(/Circle/) || Data.getAttribute('name') == 'Function' || el == parseFloat(el) ) {
2694 
          input[i] = el;
2695 
        // } else if(el.match(/[a-zA-Z]+\[[a-zA-Z0-9]+[a-zA-Z0-9,\ ]*\]/)) {
2696 
        //   input[i] = JXG.GeogebraReader.writeElement(board, )
2697 
        } else if(el == 'xAxis' || el == 'yAxis') {
2698 
          input[i] = board.ggbElements[el];
2699 
        } else {
2700 
          input[i] = JXG.GeogebraReader.checkElement(el);
2701 
        }
2702 
      };
2703 
 
2704 
      var output = [], elname = Data.getElementsByTagName("output")[0].attributes[0].value;
2705 
      for (i=0; i<Data.getElementsByTagName("output")[0].attributes.length; i++) {
2706 
        el = Data.getElementsByTagName("output")[0].attributes[i].value;
2707 
        output[i] = JXG.GeogebraReader.getElement(el);
2708 
      };
2709 
      if(typeof board.ggbElements[elname] == 'undefined' || board.ggbElements[elname] == '') {
2710 
        board.ggbElements[elname] = JXG.GeogebraReader.writeElement(board, output, input, Data.getAttribute('name').toLowerCase());
2711 
        // JXG.debug("regged: "+board.ggbElements[elname].id+"<br/>");
2712 
 
2713 
        /* register borders to according "parent" */
2714 
        if(board.ggbElements[elname].borders)
2715 
          for(var i=0; i<board.ggbElements[elname].borders.length; i++) {
2716 
            board.ggbElements[board.ggbElements[elname].borders[i].name] = board.ggbElements[elname].borders[i];
2717 
            // JXG.debug(i+") regged: "+board.ggbElements[elname].borders[i].name+"("+ board.ggbElements[board.ggbElements[elname].borders[i].name].id +")<br/>");
2718 
          };
2719 
      }
2720 
    };
2721 
 
2722 
    JXG.debug('Restesammler: ');
2723 
    // create "single" elements which do not depend on any other
2724 
    var elements = constructions[t].getElementsByTagName("element");
2725 
    for (var s=0; s<elements.length; s++) {
2726 
      var Data = elements[s];
2727 
      var el = Data.getAttribute('label');
2728 
 
2729 
      if(typeof board.ggbElements[el] == 'undefined' || board.ggbElements[el] == '') {
2730 
        board.ggbElements[el] = JXG.GeogebraReader.writeElement(board, Data);
2731 
 
2732 
        if(expr = JXG.GeogebraReader.getElement(el, true)) {
2733 
          var type = Data.getAttribute('type');
2734 
          switch(type) {
2735 
            case 'text':
2736 
            case 'function':
2737 
              // board.ggbElements[el] = JXG.GeogebraReader.writeElement(board.ggbElements, board, expr, false, type);
2738 
            break;
2739 
            default:
2740 
              JXG.GeogebraReader.ggbParse(expr.getAttribute('exp'), el);
2741 
            break;
2742 
          }
2743 
        }
2744 
 
2745 
      }
2746 
    };
2747 
 
2748 
  }; // end: for construction
2749 
 
2750 
  // speeding up the drawing process
2751 
  board.unsuspendUpdate();
2752 
 
2753 
  board.fullUpdate();
2754 
 // delete(board.ggbElements);
2755 
};
2756 
 
2757 
/**
2758 
 * Clean the utf8-symbols in a Geogebra expression in JavaScript syntax
2759 
 * @param {String} string to clean
2760 
 * @return {String} replaced string
2761 
 */
2762 
this.utf8replace = function(exp) {
2763 
  exp = (exp.match(/\u03C0/)) ? exp.replace(/\u03C0/g, 'PI') : exp;
2764 
  exp = (exp.match(/\u00B2/)) ? exp.replace(/\u00B2/g, '^2') : exp;
2765 
  exp = (exp.match(/\u00B3/)) ? exp.replace(/\u00B3/g, '^3') : exp;
2766 
  exp = (exp.match(/\u225F/)) ? exp.replace(/\u225F/g, '==') : exp;
2767 
  exp = (exp.match(/\u2260/)) ? exp.replace(/\u2260/g, '!=') : exp;
2768 
  exp = (exp.match(/\u2264/)) ? exp.replace(/\u2264/g, '<=') : exp;
2769 
  exp = (exp.match(/\u2265/)) ? exp.replace(/\u2265/g, '>=') : exp;
2770 
  exp = (exp.match(/\u2227/)) ? exp.replace(/\u2227/g, '&&') : exp;
2771 
  exp = (exp.match(/\u2228/)) ? exp.replace(/\u2228/g, '//') : exp;
2772 
  return exp;
2773 
};
2774 
 
2775 
/**
2776 
 * Extracting the packed geogebra file in order to return the "blank" xml-tree for further parsing.
2777 
 * @param {String} archive containing geogebra.xml-file or raw input string (eg. xml-tree)
2778 
 * @return {String} content of geogebra.xml-file if archive was passed in
2779 
 */
2780 
this.prepareString = function(fileStr, isString) {
2781 
    var i, bA, len, fstr;
2782 
 
2783 
    // here we have to deal with two different base64 encoded streams
2784 
    // first one: base64 encoded xml (geogebra's web export)
2785 
    // second one: base64 encoded ggb file, this is our recommendation for an IE & Opera
2786 
    // workaround, which can't deal with binary data transferred via AJAX.
2787 
 
2788 
    // first try to decode assuming we got a base64 encoded ggb file
2789 
    if(isString) {
2790 
        fstr = JXG.Util.Base64.decode(fileStr);
2791 
        if(fstr.slice(0,2)!=="PK") {
2792 
            // ooops, that was no ggb file. try again with utf8 parameter set.
2793 
            fstr = JXG.Util.Base64.decode(fileStr, true);
2794 
        }
2795 
        fileStr = fstr;
2796 
    }
2797 
 
2798 
    if (fileStr.indexOf('<') != 0) {
2799 
        bA = [];
2800 
        len = fileStr.length;
2801 
        for (i=0;i<len;i++)
2802 
            bA[i]=JXG.Util.asciiCharCodeAt(fileStr,i);
2803 
        // Unzip
2804 
        fileStr = (new JXG.Util.Unzip(bA)).unzipFile("geogebra.xml");
2805 
    }
2806 
    fileStr = JXG.Util.utf8Decode(fileStr);
2807 
    fileStr = JXG.GeogebraReader.utf8replace(fileStr);
2808 
    return fileStr;
2809 
};
2810 
 
2811 
/**
2812 
 * Checking if a parameter is a Geogebra vector (array with length 3)
2813 
 * @param {Object} possible Geogebra vector
2814 
 * @return {boolean}
2815 
 */
2816 
this.isGGBVector = function(v){
2817 
        return JXG.isArray(v) && v.length == 3 && v[0] == 1;   
2818 
};
2819 
}; // end: GeogebraReader()