home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 October / Chip_2002-10_cd1.bin / zkuste / dwarf / download / _SETUP.1 / vmsvg23.js < prev    next >
Text File  |  2001-09-20  |  47KB  |  1,842 lines
  1. //*********************************************************************************//
  2. // (C) Copyright Virtual Mechanics 1999-2001 Version 2.4, All rights reserved.     //
  3. // All copies of any portions of this software must include this Copyright notice. //
  4. //*********************************************************************************//
  5. objStep = new Array();
  6. objTime = new Array();
  7. noStep = new Array();
  8. TotTime = new Array();
  9. maxTime = new Array();
  10. noStep = new Array();
  11. Mctl = new Array();
  12.  
  13. var Version = 0;
  14. var newPage = 0;
  15. var pgScObj =-1;
  16. var Svgdoc;
  17. nm = new Array();
  18. Active = new Array();
  19. ob   = new Array();
  20. cpox = new Array();
  21. cpoy = new Array();
  22. spox = new Array();
  23. spoy = new Array();
  24. epox = new Array();
  25. epoy = new Array();
  26. crot = new Array();
  27. cscx = new Array();
  28. cscy = new Array();
  29. cjtx = new Array();
  30. cjty = new Array();
  31. cshd = new Array();
  32. rate = new Array();
  33. rotate= new Array();
  34. scale= new Array();
  35. shade= new Array();
  36. var Lpox;
  37. var Lpoy;
  38. dpox = new Array();
  39. dpoy = new Array();
  40. atDis  = new Array();
  41. DisPt  = new Array();
  42. disStep = new Array();
  43. Plen = new Array();
  44. Path = new Array();
  45. obRef= new Array();
  46. Gtyp = new Array();
  47. Gnpt = new Array();
  48. Gnam = new Array();
  49. Glen = new Array();
  50. Gszx = new Array();
  51. Gszy = new Array();
  52. Gpxl = new Array();
  53. Gpyl = new Array();
  54. Gbrl = new Array();
  55. Gbrt = new Array();
  56. Gbrr = new Array();
  57. Gbrb = new Array();
  58. Grps = new Array();
  59. Grpl = new Array();
  60. Gspt = new Array();
  61. Snam = new Array();
  62. Scnt = new Array();
  63. PathCount = new Array();
  64. LastPt  = new Array();
  65. lstVal = new Array();
  66.  
  67. TimeLeft = new Array();
  68. AEvent = new Array();
  69. WDEvent = new Array();
  70. WAEvent = new Array();
  71. AValue = new Array();
  72. ATime = new Array();
  73. AEnter = new Array();
  74. ALeave = new Array();
  75. AKey = new Array();
  76. IKey = new Array();
  77. DEvent = new Array();
  78. DValue = new Array();
  79. DTime = new Array();
  80. DEnter = new Array();
  81. DLeave = new Array();
  82. DAKey = new Array();
  83. DIKey = new Array();
  84. WASOp  = new Array();
  85. WAGOp  = new Array();
  86. OpForm = new Array();
  87. WAAObj = new Array();
  88. WADObj = new Array();
  89. WAForm = new Array();
  90. WASVal = new Array();
  91. WAGVal = new Array();
  92. WACgeo = new Array();
  93. WACsnd = new Array();
  94. WACact = new Array();
  95. WACevt = new Array();
  96. WACatt = new Array();
  97. WACobj = new Array();
  98. WANobj = new Array();
  99. WALink = new Array();
  100. WDAObj = new Array();
  101. WDDObj = new Array();
  102. EndPath = new Array();
  103. MType = new Array();
  104.  
  105. ATyp   = new Array();
  106. ACol  = new Array();
  107. ATrn  = new Array();
  108. AVc1x  = new Array();
  109. AVc1y  = new Array();
  110. ACol2  = new Array();
  111. ATrn2  = new Array();
  112. AVc2x  = new Array();
  113. AVc2y  = new Array();
  114. Aid1   = new Array();
  115. Aid2   = new Array();
  116. Agrd   = new Array();
  117. Astp1  = new Array();
  118. Astp2  = new Array();
  119. Astp3  = new Array();
  120. MPath  = new Array();
  121. MRate  = new Array();
  122. MTime  = new Array();
  123. MDelay = new Array();
  124. MStart = new Array();
  125. MRepeat= new Array();
  126. MCount = new Array();
  127. MPLen  = new Array();
  128. MDir   = new Array();
  129. MGWst  = new Array();
  130. MGNth  = new Array();
  131. MGEst  = new Array();
  132. MGSth  = new Array();
  133. MALst  = new Array();
  134. MRotate= new Array();
  135. MScale = new Array();
  136. MFlags = new Array();
  137. MShade = new Array();
  138.  
  139. eDELAY = (1);
  140. eDELAY_TIME = (2);
  141. eMOUSE = (4);
  142. eMOUSE_OVER = (8);
  143. eLMOUSE = (16);
  144. eRMOUSE = (32);
  145. eKEY = (64);
  146. eOBJECT_ENTER = (128);
  147. eOBJECT_ENTER_LIST = (256);
  148. eOBJECT_LEAVE = (512);
  149. eOBJECT_LEAVE_LIST = (1024);
  150. eLT_VALUE =    (2048);
  151. eEQ_VALUE = (4096);
  152. eGT_VALUE =    (8192);
  153. eVALUE      = (16384);
  154. eENDPATH  = (32768);
  155. eACTIVATE_1 = (65536);
  156. eACTIVATE_2    = (131072);
  157. eANDtest = (1<<30);
  158. var pageTime = -1;
  159. var Cobj;
  160. var Coid;
  161. var Csty;
  162. var Catt;
  163. var Cact;
  164. var Cevt;
  165. var Cgrp;
  166. var Cgeo;
  167. var Csnd;
  168. var Cpob;
  169. var Gpgo;
  170. var gcx;
  171. var gcy;
  172. var gcx;
  173. var gcy;
  174. var cmx = 300;
  175. var cmy = 200;
  176. var smx = -9999;
  177. var smy = -9999;
  178. var slm = 0;
  179. var llm = -9999;
  180. var sky = " ";
  181. var lstsnd = -1;
  182. var red;
  183. var grn;
  184. var blu;
  185. var alp;
  186. var fact;
  187. var ifact;
  188.  
  189. var lmx = -9999;
  190. var lmy = -9999;
  191. var lky = 0;
  192. var totObj;
  193. var mS;
  194. var mW;
  195. var fps = 15;
  196. var waitTime = 40;
  197. var tickTime = 1;
  198. var strDate;
  199. var curDate;
  200. var GEO_TYPE = 7;
  201. var GEO_OPEN = 8;
  202. var GEO_COUNT= 32;
  203. ACT_XPATH_STOP     =(0);
  204. ACT_XPATH_OBJPTH =(1<<0);
  205. ACT_XPATH_OBJXYZ =(1<<1);
  206. ACT_XPATH_LEFT   =(1<<2);
  207. ACT_XPATH_RIGHT  =(1<<3);
  208. ACT_XPATH_MOUSE     =(1<<4);
  209. ACT_XPATH_KEYPTH =(1<<5);
  210. ACT_YPATH_STOP     =(0);
  211. ACT_YPATH_OBJPTH =(1<<8);
  212. ACT_YPATH_OBJXYZ =(1<<9);
  213. ACT_YPATH_UP     =(1<<10);
  214. ACT_YPATH_DOWN   =(1<<11);
  215. ACT_YPATH_MOUSE     =(1<<12);
  216. ACT_ZPATH_STOP     =(0);
  217. ACT_ZPATH_OBJPTH =(1<<16);
  218. ACT_ZPATH_OBJXYZ =(1<<17);
  219. ACT_ZPATH_IN     =(1<<18);
  220. ACT_ZPATH_OUT     =(1<<19);
  221. ACT_ZPATH_KEY     =(1<<20);
  222. ACT_PATH_STOP     =(0);
  223. ACT_PATH_START     =(1<<24);
  224. ACT_PATH_CENTER     =(1<<25);
  225. ACT_PATH_END     =(1<<26);
  226. ACT_GEO_WEST     =(1<<28);
  227. ACT_GEO_EAST     =(1<<29);
  228. ACT_GEO_NORTH    =(1<<30);
  229. ACT_GEO_SOUTH    =(1<<31);
  230. ACT_SETX         =(0xffffff00);
  231. ACT_SETY         =(0xffff00ff);
  232. ACT_SETZ         =(0xff00ffff);
  233. ACT_SETO         =(0xf0ffffff);
  234. ACT_SETF         =(0x0fffffff);
  235. ACT_GETX         =(0x000000ff);
  236. ACT_GETY         =(0x0000ff00);
  237. ACT_GETZ         =(0x00ff0000);
  238. ACT_GETO         =(0x0f000000);
  239. ACT_GETF         =(0xf0000000);
  240.  
  241. /**************************************************************************/
  242. function min(x,y) {if(x < y) return x; return y;}
  243. function max(x,y) {if(y > x) return y; return x;}
  244.   
  245. function mouseMove(evt) {
  246.     cmx = evt.getClientX();
  247.     cmy = evt.getClientY();
  248.     sclx = 0;
  249.     scly = 0;
  250. }
  251. function mouseDown(evt) {
  252.     slm = slm | 1;
  253.     smx=evt.getClientX();
  254.     smy=evt.getClientY();
  255.     return true;
  256. }
  257. function enddrag(evt) {
  258.     slm = slm | 2;
  259.     smx = evt.getClientX();
  260.     smy = evt.getClientY();
  261.     evt.onmousemove=0;
  262.     return false;
  263. }
  264. function drag(evt) {
  265.     cmx = evt.getClientX();
  266.     cmy = evt.getClientY();
  267. }
  268.  
  269. function mouseUp(evt) {
  270.     slm = slm | 2 + window.pageXOffset;
  271.     smx = evt.pageX + window.pageXOffset;
  272.     smy = evt.pageY + window.pageYOffset;
  273. }
  274.  
  275. function keyPress(evt) {
  276.     sky = evt.getCharCode();
  277. }
  278.  
  279. function Setup(svgdoc) {
  280. // setup defaults
  281.     Svgdoc = svgdoc;
  282.     tmCount=0;
  283.  
  284.     strDate = new Date();
  285.     waitTime = 1000 / fps;
  286.     frmTime = 0;
  287.     tickTime = 0;
  288.     
  289.     ob[0] = new Array();
  290.     ob[0] = 0;
  291.     ob[0].obj = 0;
  292.     ob[0].sty = 0;
  293.     ob[0].name = "Geo0";
  294.     ob[0].geo = 0;
  295.     ob[0].att = 0; 
  296.     ob[0].evt = 0; 
  297.     ob[0].act = 0;
  298.     ob[0].grp = 0;
  299.     ob[0].cpox =0.000000;
  300.     ob[0].cpoy =0.000000;
  301.     ob[0].cscx =1.000000;
  302.     ob[0].cscy =1.000000;
  303.     ob[0].crot =0.000000;
  304.     ob[0].flg = 0;
  305.  
  306.     MPath[0]  = 0;
  307.     MStart[0] = 0;
  308.     MCount[0] = 0;
  309.  
  310.     red = 255;
  311.     grn = 255;
  312.     blu = 255;
  313.     alp = 1.;
  314.     fact = 1.0;
  315.     ifact= 0.0;
  316.  
  317.  
  318.     for(nob=0; nob< pageObj; nob++) {
  319.         Cobj = pObjLst[nob];
  320.         spox[Cobj] = ob[Cobj].cpox;  
  321.         spoy[Cobj] = ob[Cobj].cpoy;
  322.         SetPath(Cobj);
  323.  
  324.         if(ob[Cobj].grp == 0)
  325.             reset(Cobj);
  326.  
  327.         if(ob[Cobj].flg & 16)
  328.             Active[Cobj] =  4;    // set to initial active state
  329.     }
  330. }
  331.  
  332. function doObjectList() {
  333.  
  334.     curDate = new Date();
  335.     tickTime = (curDate - strDate) * 0.1;
  336.     frmTime++;
  337.  
  338. //    if(newPage != 0) window.location=WALink[newPage];
  339.  
  340.     newPage = 0;
  341.     if(pageTime >= 0)
  342.     {
  343.         tmCount++;
  344.         if(tmCount > pageTime) 
  345.         {
  346.             window.location=pgLink;
  347.             pageTime = -1;
  348.         }
  349.     }
  350.  
  351.     if(lmx == smx) smx = -99999;
  352.     if(lmy == smy) smy = -99999;
  353.     if(lky == sky) sky = " ";
  354.     llt = 0;
  355.     if((llm & 2) == (slm & 2)) slm = (slm  & ~2);
  356.     if((llm & 1) == (slm & 1)) slm = (slm  & ~1);
  357.     lmx = smx;
  358.     lmy = smy;
  359.     lky = sky;
  360.     llm = slm;
  361.  
  362.     MoOvrTst();
  363.  
  364.     for(nob=0; nob< pageObj; nob++) {
  365. //        ref = pObjLst[nob];
  366.         gcx = 0;
  367.         gcy = 0;
  368.         cobj = pObjLst[nob];
  369.         Cgrp = ob[cobj].grp;
  370.         if(!Cgrp) doObject(cobj);
  371.     }
  372. }
  373.  
  374. function doObject(cobj)
  375. {
  376.     Cobj = cobj;
  377.     Coid = ob[Cobj].obj;
  378.     Csty = ob[Cobj].sty
  379.     Cgeo = ob[Cobj].geo;
  380.     Csnd = ob[Cobj].snd;
  381.     Cevt = ob[Cobj].evt;
  382.     Catt = ob[Cobj].att;
  383.     Cact = ob[Cobj].act;
  384.     Gpgo = ob[Cobj].gem;
  385.  
  386.     if(Cact)
  387.     {            
  388.         Cpob = MPath[Cact];
  389.         if(Cpob)
  390.             Cpgo = ob[Cpob].geo;
  391.         else
  392.             Cpgo = 0;
  393.     }
  394.     else
  395.     {
  396.         Cpob = 0;
  397.         Cpgo = 0;
  398.     }
  399.  
  400.     if(Cevt) Evtest();
  401.     if     (Active[Cobj] == 4) whenActive();
  402.     else if(Active[Cobj] == 2) whenDeactive();
  403.     else if(Active[Cobj] == 1) isActive();
  404.     else if(Active[Cobj] == 0) isDeactive();
  405.  
  406. //    if(Cgeo && (Gtyp[Cgeo] & (1<<4)))
  407. //    { 
  408. //        doGroup(Cgeo);
  409. //        return;
  410. //    }
  411. }
  412.  
  413. function doGroup(cgrp)
  414. {
  415.     var gobj;
  416.     gcx = cpox[Cobj];
  417.     gcy = cpoy[Cobj];
  418.     gobj = Cobj;
  419.     for(i = 0; i < Grps[cgrp]; i++)
  420.     { 
  421.         doObject(Grpl[cgrp][i]);
  422.         ob[Cobj].sty.left=gcx+cpox[Cobj] - Gszx[Cgeo] * ob[Cobj].cscx;
  423.         ob[Cobj].sty.top =gcy+cpoy[Cobj] - Gszy[Cgeo] * ob[Cobj].cscy;
  424.     }
  425.     return;
  426. }
  427.  
  428. function setVisibility(code)
  429. {
  430. //    if(Cgeo && (Gtyp[Cgeo] & (1<<4))) {
  431. //        for(i = 0; i < Grps[Cgeo]; i++) {
  432. //            ob[Grpl[Cgeo][i]].obj.setProperty('visibility',code);
  433. //        }
  434. //    }
  435. //    else
  436. //        ob[Cobj].sty.setProperty('visibility', 'hidden');
  437. //window.status = " Cobj=" + Cobj + " Coid=" + Coid + " Csty=" + Csty;
  438. //        ob[Cobj].obj.setProperty('visibility', 'visible');
  439.         Csty.setProperty('visibility', code);
  440. }
  441.  
  442. function UpdGeo() {
  443.     var drx = Lpox - cpox[Cobj];
  444.     var dry = Lpoy - cpoy[Cobj];
  445.     if(Math.abs(dry) > Math.abs(drx))
  446.     {
  447.         if    ((dry < 0) && (MDir[Cobj] != 270))
  448.         {
  449.             if(MType[Cact] & (ACT_GEO_SOUTH))
  450.             {
  451.                 ob[Cobj].image.src = Gspt[MGSth[Cact]].src;
  452.             }
  453.             MDir[Cobj] = 270;
  454.         }
  455.         else  if((dry >= 0) && MDir[Cobj] != 90)
  456.         {
  457.             if(MType[Cact] & (ACT_GEO_NORTH))
  458.             { 
  459.                 ob[Cobj].image.src = Gspt[MGNth[Cact]].src;
  460.             }
  461.             MDir[Cobj] = 90;
  462.         }
  463.     }
  464.     else
  465.     {
  466.         if    ((drx > 0) && (MDir[Cobj] != 0))
  467.         {
  468.             if(MType[Cact] & (ACT_GEO_WEST))
  469.             { 
  470.                 ob[Cobj].image.src = Gspt[MGWst[Cact]].src;
  471.             }
  472.             MDir[Cobj] = 0;
  473.         }
  474.         else  if((drx <= 0) && MDir[Cobj] != 180)
  475.         {
  476.             if(MType[Cact] & (ACT_GEO_EAST))
  477.             { 
  478.                 ob[Cobj].image.src = Gspt[MGEst[Cact]].src;
  479.             }
  480.             MDir[Cobj] = 180;
  481.         }
  482.     }
  483. return;
  484. }
  485.  
  486. function UpdStr() {
  487.     if(lstVal[Cobj] == ob[Cobj].val) return;
  488.     lstVal[Cobj] = ob[Cobj].val;
  489.     if(isIE4 || isIE5)
  490.         ob[Cobj].name.innerText = ob[Cobj].val;
  491.     else
  492.         window.status = "Object " + ob[Cobj].name + " Counter=" + ob[Cobj].val;
  493.  
  494.     return;
  495. }
  496.  
  497. function UpdAudio(on)
  498. {
  499.     if(on > 0)
  500.     {
  501.         if(Scnt[Csnd] < 0) Scnt[Csnd] = 9999;
  502.         SoundEffect.loop= Scnt[Csnd];
  503.         SoundEffect.src = Snam[Csnd];
  504. //            SoundEffect.autostart=1;
  505.         lstsnd = Csnd;
  506.     }
  507.     else
  508.     {
  509.         if(lstsnd != Csnd) return;
  510.         SoundEffect.src= " ";
  511.         SoundEffect.loop= 0;
  512.         SoundEffect.autostart=0;
  513.     }
  514. }
  515.  
  516. function Evtest() 
  517. {
  518.     if(Active[Cobj] == 0) 
  519.     {
  520.         if(AEvent[Cevt] & eANDtest)
  521.             ActANDTest();
  522.         else
  523.             ActORTest();
  524.     }
  525.     else if(Active[Cobj] == 1) {
  526.         if(DEvent[Cevt] & eANDtest)
  527.             DeactANDTest();
  528.         else
  529.             DeactORTest();
  530.     }
  531. return;
  532. }
  533.  
  534. //*********************************************************************************//
  535. function ActORTest()
  536. {
  537. if(((AEvent[Cevt] & eDELAY)         && TimeCount() <= 0  ) ||
  538.   ( (AEvent[Cevt] & eOBJECT_ENTER)    && ObjectEnter(AEnter[Cevt])  ) ||
  539.   ( (AEvent[Cevt] & eOBJECT_LEAVE)     && ObjectLeave(ALeave[Cevt])  ) ||
  540.   ( (AEvent[Cevt] & eMOUSE)            && MouseSelect() > 0 ) ||
  541.   ( (AEvent[Cevt] & eMOUSE_OVER)    && MouseOver()   ) ||
  542.   ( (AEvent[Cevt] & eLMOUSE)        && IsMouseLClick()   ) ||
  543.   ( (AEvent[Cevt] & eRMOUSE)        && IsMouseRClick()   ) ||
  544.   ( (AEvent[Cevt] & eKEY)            && KeyChar()   ) ||
  545.   ( (AEvent[Cevt] & eLT_VALUE)        && ob[Cobj].val <  AValue[Cevt]) ||
  546.   ( (AEvent[Cevt] & eEQ_VALUE)        && ob[Cobj].val == AValue[Cevt]) ||
  547.   ( (AEvent[Cevt] & eGT_VALUE)        && ob[Cobj].val >  AValue[Cevt]) ||
  548.   ( (AEvent[Cevt] & eENDPATH)        && EndPath[Cobj]     )   )
  549. Active[Cobj] = 4;
  550. }
  551.  
  552. function ActANDTest()
  553. {
  554. if(((AEvent[Cevt] & eDELAY)         && !(TimeCount() <= 0)  ) ||
  555.   ( (AEvent[Cevt] & eOBJECT_ENTER)    && !ObjectEnter(AEnter[Cevt])  ) ||
  556.   ( (AEvent[Cevt] & eOBJECT_LEAVE)     && !ObjectLeave(ALeave[Cevt])  ) ||
  557.   ( (AEvent[Cevt] & eMOUSE)            && !(MouseSelect() > 0) ) ||
  558.   ( (AEvent[Cevt] & eMOUSE_OVER)    && !MouseOver()   ) ||
  559.   ( (AEvent[Cevt] & eLMOUSE)        && !IsMouseLClick()   ) ||
  560.   ( (AEvent[Cevt] & eRMOUSE)        && !IsMouseRClick()   ) ||
  561.   ( (AEvent[Cevt] & eKEY)            && !KeyChar()   ) ||
  562.   ( (AEvent[Cevt] & eLT_VALUE)        && !(ob[Cobj].val <  AValue[Cevt])) ||
  563.   ( (AEvent[Cevt] & eEQ_VALUE)        && !(ob[Cobj].val == AValue[Cevt])) ||
  564.   ( (AEvent[Cevt] & eGT_VALUE)        && !(ob[Cobj].val >  AValue[Cevt])) ||
  565.   ( (AEvent[Cevt] & eENDPATH)        && !EndPath[Cobj]     )   )
  566.   {} else Active[Cobj] = 4;
  567. }
  568.  
  569. function DeactORTest()
  570. {
  571.  
  572. if(((DEvent[Cevt] & eDELAY)         && TimeCount() <= 0  ) ||
  573.   ( (DEvent[Cevt] & eOBJECT_ENTER)    && ObjectEnter(DEnter[Cevt])  ) ||
  574.   ( (DEvent[Cevt] & eOBJECT_LEAVE)     && ObjectLeave(DLeave[Cevt])  ) ||
  575.   ( (DEvent[Cevt] & eMOUSE)            && MouseSelect() > 0 ) ||
  576.   ( (DEvent[Cevt] & eMOUSE_OVER)    && !MouseOver()   ) ||
  577.   ( (DEvent[Cevt] & eLMOUSE)        && IsMouseLClick()   ) ||
  578.   ( (DEvent[Cevt] & eRMOUSE)        && IsMouseRClick()   ) ||
  579.   ( (DEvent[Cevt] & eKEY)            && DKeyChar()   ) ||
  580.   ( (DEvent[Cevt] & eLT_VALUE)        && ob[Cobj].val <  AValue[Cevt]) ||
  581.   ( (DEvent[Cevt] & eEQ_VALUE)        && ob[Cobj].val == AValue[Cevt]) ||
  582.   ( (DEvent[Cevt] & eGT_VALUE)        && ob[Cobj].val >  AValue[Cevt]) ||
  583.   ( (DEvent[Cevt] & eENDPATH)        && EndPath[Cobj]     )   )
  584.     Active[Cobj] = 2;
  585. }
  586.  
  587. function DeactANDTest()
  588. {
  589. if(((DEvent[Cevt] & eDELAY)         && !(TimeCount() <= 0)  ) ||
  590.   ( (DEvent[Cevt] & eOBJECT_ENTER)    && !ObjectEnter(DEnter[Cevt])  ) ||
  591.   ( (DEvent[Cevt] & eOBJECT_LEAVE)     && !ObjectLeave(DLeave[Cevt])  ) ||
  592.   ( (DEvent[Cevt] & eMOUSE)            && !(MouseSelect() > 0) ) ||
  593.   ( (DEvent[Cevt] & eMOUSE_OVER)    && !MouseOver()   ) ||
  594.   ( (DEvent[Cevt] & eLMOUSE)        && !IsMouseLClick()   ) ||
  595.   ( (DEvent[Cevt] & eRMOUSE)        && !IsMouseRClick()   ) ||
  596.   ( (DEvent[Cevt] & eKEY)            && !DKeyChar()   ) ||
  597.   ( (DEvent[Cevt] & eLT_VALUE)        && !(ob[Cobj].val <  AValue[Cevt])) ||
  598.   ( (DEvent[Cevt] & eEQ_VALUE)        && !(ob[Cobj].val == AValue[Cevt])) ||
  599.   ( (DEvent[Cevt] & eGT_VALUE)        && !(ob[Cobj].val >  AValue[Cevt])) ||
  600.   ( (DEvent[Cevt] & eENDPATH)        && !EndPath[Cobj]     )   )
  601.   {} else Active[Cobj] = 2;
  602. }
  603. /**************************************************************************/
  604. function TimeCount() {
  605.     return (TimeLeft[Cobj] - tickTime);
  606. }
  607.  
  608. function ObjectEnter(eobj) {
  609. //if(1) return;
  610. x = Gszx[Cgeo] * ob[Cobj].cscx;
  611. y = Gszy[Cgeo] * ob[Cobj].cscy;
  612. if ( cpox[eobj] >= (cpox[Cobj] - x) && cpox[eobj] <= (cpox[Cobj]) + x &&
  613.       cpoy[eobj] >= (cpoy[Cobj] - y) && cpoy[eobj] <= (cpoy[Cobj]) + y )
  614.     return 1;
  615. return 0;
  616. }
  617.  
  618. function ObjectLeave(eobj) {
  619. //if(1) return;
  620. x = Gszx[Cgeo] * ob[Cobj].cscx;
  621. y = Gszy[Cgeo] * ob[Cobj].cscy;
  622. if ( cpox[eobj] >= cpox[Cobj] - x && cpox[eobj] <= cpox[Cobj] + x &&
  623.      cpoy[eobj] >= cpoy[Cobj] - y && cpoy[eobj] <= cpoy[Cobj] + y )
  624.     return 0;
  625. return 1;
  626. }
  627.  
  628. function MouseSelect() {
  629. var val = 0;
  630. if(smx == -99999) return val;
  631. x = Gszx[Cgeo] * ob[Cobj].cscx;
  632. y = Gszy[Cgeo] * ob[Cobj].cscy;
  633. if ( smx >= cpox[Cobj] - x && smx <= cpox[Cobj] + x &&
  634.      smy >= cpoy[Cobj] - y && smy <= cpoy[Cobj] + y )
  635.     return val = 1;
  636. return val;
  637. }
  638.  
  639. function MouseOver() {
  640. x = Gszx[Cgeo] * ob[Cobj].cscx;
  641. y = Gszy[Cgeo] * ob[Cobj].cscy;
  642. if ( cmx >= cpox[Cobj] - x && cmx <= cpox[Cobj] + x &&
  643.      cmy >= cpoy[Cobj] - y && cmy <= cpoy[Cobj] + y ) {
  644.     return 1;}
  645. return 0;
  646. }
  647.  
  648. function IsMouseLClick() {
  649. return (slm && 1);
  650. }
  651.  
  652. function IsMouseRClick() {
  653. return (slm && 2);
  654. }
  655.  
  656. function KeyChar() {
  657. if(!sky) return 0;
  658. if(IKey[Cevt] == lky) return 1;
  659. return 0;
  660. }
  661.  
  662. function DKeyChar() {
  663. if(!sky) return 0;
  664. if(DIKey[Cevt] == sky) return 1;
  665. return 0;
  666. }
  667.  
  668. function MoOvrTst() {
  669. for(i=0; i < MoLNo; i++) {
  670.   Cobj = Molst[i];
  671.   Cgeo = ob[Cobj].geo;
  672.   Csty = ob[Cobj].sty;
  673.   if(ob[Cobj].flg & 512)  {
  674.       if(MouseOver() == 1) 
  675.       {
  676.         if(ob[Cobj].flg & 128) setVisibility("visible");
  677.         else                   setVisibility("hidden");
  678.       }
  679.       else 
  680.       {
  681.         if(ob[Cobj].flg & 256) setVisibility("visible");
  682.         else                   setVisibility("hidden");
  683.       }
  684.   }
  685. }}
  686.  
  687. /***************************************************************************/
  688. function isDeactive() {
  689.     if(PathCount[Cobj] != 0) 
  690.     UpdPos();
  691.     else if(ob[Cobj].jnt) 
  692.        UpdKpt()
  693.  
  694.     if(Gtyp[Cgeo] & GEO_COUNT) UpdStr();
  695.  
  696. return;
  697. }
  698.  
  699. function isActive() {
  700.     if(PathCount[Cobj] != 0) 
  701.        UpdPos();
  702.     else if(ob[Cobj].jnt) 
  703.        UpdKpt()
  704.  
  705.     if(Gtyp[Cgeo] & GEO_COUNT) UpdStr();
  706. return;
  707. }
  708.  
  709. function whenActive()
  710. {
  711.     Active[Cobj]  = 1;
  712.     EndPath[Cobj] = 0;
  713.  
  714.     // set default active events
  715.     if(!Cevt)
  716.     {
  717.         TimeLeft[Cobj]  =  0;
  718.         PathCount[Cobj] = 0;
  719.         setVisibility("visible")
  720.     }
  721.     else
  722.     {
  723. //        if(WAEvent[Cevt] & (1<<14)) window.location=WALink[Cevt];
  724. //        if(WAEvent[Cevt] & (1<<15)) window.location=WALink[Cevt];
  725.         if(WAEvent[Cevt] & (1<<14) || WAEvent[Cevt] & (1<<15)) 
  726.         {
  727.             newPage = Cevt;
  728.         }
  729.  
  730.         if(Csnd > 0) UpdAudio((WAEvent[Cevt] & 16));
  731. //        if(WAEvent[Cevt] & 16) UpdAudio(); //sound
  732.         if(WAEvent[Cevt] & 8) setVisibility("visible");
  733.         else                  setVisibility("hidden");
  734.  
  735.         TimeLeft[Cobj] = tickTime + (DTime[Cevt]);
  736.  
  737.         if(WAEvent[Cevt] & (1<<5)) Active[WAAObj[Cevt]] = 4;
  738.         if(WAEvent[Cevt] & (1<<7)) Active[WADObj[Cevt]] = 2;
  739.  
  740.         // apply value
  741.         if(WAEvent[Cevt] & (1<<13)) {
  742.             if       ((OpForm[Cevt] & 0x000f) == 0)
  743.                 ob[Cobj].val  = WAForm[Cevt];
  744.             else if((OpForm[Cevt] & 0x000f) == 1)
  745.                 ob[Cobj].val += WAForm[Cevt];
  746.             else if((OpForm[Cevt] & 0x000f) == 2)
  747.                 ob[Cobj].val -= WAForm[Cevt];
  748.             else if((OpForm[Cevt] & 0x000f) == 3)
  749.                 ob[Cobj].val *= WAForm[Cevt];
  750.             else if((OpForm[Cevt] & 0x000f) == 4)
  751.                 if(WAForm[Cevt] != 0) ob[Cobj].val /= WAForm[Cevt];
  752.         }
  753.         // get value
  754.         if(WAEvent[Cevt] & (1<<11)) {
  755.             if       ((WAGOp[Cevt] & 0x000f) == 0)
  756.                 ob[Cobj].val  = ob[WAGVal[Cevt]].val;
  757.             else if((WAGOp[Cevt] & 0x000f) == 1)
  758.                 ob[Cobj].val += ob[WAGVal[Cevt]].val;
  759.             else if((WAGOp[Cevt] & 0x000f) == 2)
  760.                 ob[Cobj].val -= ob[WAGVal[Cevt]].val;
  761.             else if((WAGOp[Cevt] & 0x000f) == 3)
  762.                 ob[Cobj].val*= ob[WAGVal[Cevt]].val;
  763.             else if((WAGOp[Cevt] & 0x000f) == 4)
  764.                 if(ob[WAGVal[Cevt]].val != 0) ob[Cobj].val /= ob[WAGVal[Cevt]].val;
  765.         }
  766.         // send result
  767.         if(WAEvent[Cevt] & (1<<9)) {
  768.             if       ((WASOp[Cevt] & 0x000f) == 0)
  769.                 ob[WASVal[Cevt]].val  = ob[Cobj].val;
  770.             else if((WASOp[Cevt] & 0x000f) == 1)
  771.                 ob[WASVal[Cevt]].val += ob[Cobj].val;
  772.             else if((WASOp[Cevt] & 0x000f) == 2)
  773.                 ob[WASVal[Cevt]].val -= ob[Cobj].val;
  774.             else if((WASOp[Cevt] & 0x000f) == 3)
  775.                 ob[WASVal[Cevt]].val *= ob[Cobj].val;
  776.             else if((WASOp[Cevt] & 0x000f) == 4)
  777.                 if(ob[Cobj].val != 0) ob[WASVal[Cobj]].val /= ob[Cobj].val;
  778.         }
  779.         if(WAEvent[Cevt] & 4) PathCount[Cobj] = MCount[Cact]; // motion
  780.         // replace current object components
  781.         if(WAEvent[Cevt] & (1<<17))
  782.         {
  783.             if(WAEvent[Cevt] & (1<<18)) {
  784.                 ob[Cobj].name = Gnam[WACgeo[Cevt]];
  785.                 ob[Cobj].geo  = WACgeo[Cevt];
  786.             }
  787.             if(WAEvent[Cevt] & (1<<18)) ob[Cobj].geo  = WACgeo[Cevt];
  788.             if(WAEvent[Cevt] & (1<<18)) ob[Cobj].image.src = Gspt[ob[Cobj].geo].src;
  789.             if(WAEvent[Cevt] & (1<<19)) ob[Cobj].att  = WACatt[Cevt];
  790.             if(WAEvent[Cevt] & (1<<20)) ob[Cobj].act  = WACact[Cevt];
  791.             if(WAEvent[Cevt] & (1<<22)) ob[Cobj].evt  = WACevt[Cevt];
  792.             spox[Cobj] = cpox[Cobj];  
  793.             spoy[Cobj] = cpoy[Cobj];
  794.             SetPath(Cobj);
  795.         }
  796.         // replace additional object components
  797.         for(ref=0; ref< WACobj[Cevt]; ref++) {
  798.             if(WAEvent[Cevt] & (1<<18)) {
  799.                 ob[WANobj[Cevt][ref]].name = Gnam[WACgeo[Cevt]];
  800.                 ob[WANobj[Cevt][ref]].geo  = WACgeo[Cevt];
  801.             }
  802.             if(WAEvent[Cevt] & (1<<18)) ob[WANobj[Cevt][ref]].geo  = WACgeo[Cevt];
  803.             if(WAEvent[Cevt] & (1<<18)) ob[WANobj[Cevt][ref]].image.src = Gspt[ob[Cobj].geo].src;
  804.             if(WAEvent[Cevt] & (1<<19)) ob[WANobj[Cevt][ref]].att  = WACatt[Cevt];
  805.             if(WAEvent[Cevt] & (1<<20)) ob[WANobj[Cevt][ref]].act  = WACact[Cevt];
  806.             if(WAEvent[Cevt] & (1<<22)) ob[WANobj[Cevt][ref]].evt  = WACevt[Cevt];
  807.             spox[WANobj[Cevt][ref]] = cpox[Cobj];  
  808.             spoy[WANobj[Cevt][ref]] = cpoy[Cobj];
  809.             SetPath(WANobj[Cevt][ref]);
  810.         }
  811.  
  812.         if(WAEvent[Cevt] & (1<<30)) reset(Cobj);
  813.     }
  814. }
  815.  
  816. function whenDeactive()
  817. {
  818.  
  819.     EndPath[Cobj] = 0;
  820.     Active[Cobj]  = -1;    // is disabled unless reset
  821.  
  822.     if(!Cevt) 
  823.     {
  824.         PathCount[Cobj] = -1;
  825.         TimeLeft[Cobj]  =  0;
  826.         setVisibility("hidden");
  827.     }
  828.     else
  829.     {
  830.         if(WDEvent[Cevt] & 4) PathCount[Cobj] = MCount[Cact]; // motion
  831.         if(WDEvent[Cevt] & (1<<30)) reset(Cobj);
  832.  
  833.         if(Csnd > 0) UpdAudio((WDEvent[Cevt] & 16));    //sound
  834.         if(WDEvent[Cevt] & 8) setVisibility("visible");
  835.         else                  setVisibility("hidden");
  836.  
  837.         TimeLeft[Cobj]  = tickTime + ATime[Cevt];
  838.         if(WDEvent[Cevt] & 4) PathCount[Cobj] = MCount[Cact];    // motion
  839.         else                  PathCount[Cobj] = 0;
  840.  
  841.         if(WDEvent[Cevt] & (1<<5)) Active[WDAObj[Cevt]] = 4;
  842.         if(WDEvent[Cevt] & (1<<7)) Active[WDDObj[Cevt]] = 2;
  843.     }
  844. }
  845.  
  846. function reset(cobj) {
  847.  
  848.     Cobj = cobj;
  849.     Coid = ob[cobj].obj;
  850.     Csty = ob[cobj].sty;
  851.     Cevt = ob[cobj].evt;
  852.     Catt = ob[cobj].att;
  853.     Cact = ob[cobj].act;
  854.     Cgrp = ob[cobj].grp;
  855.     Cgeo = ob[cobj].geo;
  856.     Active[cobj]    =  0;    // is deactive
  857.     if(Cevt)
  858.     {
  859.         if(WDEvent[Cevt] & 8) setVisibility("visible");
  860.         else                  setVisibility("hidden");
  861.         if(WDEvent[Cevt] & (1<<31)) {
  862.             PathCount[cobj] = MCount[Cact];            // restart path
  863.             cpox[cobj] = spox[cobj];
  864.             cpoy[cobj] = spoy[cobj];
  865.             cscx[cobj] = ob[cobj].cscx;
  866.             cscy[cobj] = ob[cobj].cscy;
  867.             crot[cobj] = ob[cobj].crot;
  868.             cshd[cobj] = 0.0;
  869.             LastPt[cobj] = 0;
  870. //            atDis[cobj] = 0;
  871.             DisPt[cobj] = 0;
  872.             EndPath[cobj] = 0;
  873.         }
  874.         if(!(WDEvent[Cevt] & 4)) PathCount[cobj] = 0;    // no motion
  875.         TimeLeft[cobj]  = tickTime + ATime[Cevt];
  876.     }
  877.     else if(Cgeo && Csty)
  878.     {
  879.         if(ob[cobj].flg & 64)
  880.             setVisibility("visible");
  881.         else
  882.             setVisibility("hidden");
  883.         // set action variables
  884.         if(Cact) PathCount[cobj] = MCount[Cact]; // motion
  885.         else     PathCount[cobj] = 0;
  886.         TimeLeft[cobj]  = 0;
  887.  
  888.         cpox[cobj] = spox[cobj];
  889.         cpoy[cobj] = spoy[cobj];
  890.         LastPt[cobj] = 0;
  891. //        atDis[cobj] = 0;
  892.         DisPt[cobj] = 0;
  893.         EndPath[cobj] = 0;
  894.     }
  895.  
  896.     if(Cgeo && Cact) {
  897.         resetMatrix();
  898.         appTrans(cobj);
  899.         appMtrx();
  900.     }
  901.  
  902. return;
  903. }
  904.  
  905. /*************************************************************************/
  906. function SetPath(cobj) {
  907.  
  908.     Cobj = cobj;
  909.     Coid = ob[Cobj].obj;    // Object dom id
  910.     Csty = ob[Cobj].sty;    // Style
  911.     Cevt = ob[Cobj].evt;    // Objects event
  912.     Catt = ob[Cobj].att;    // Objects attribute
  913.     Cact = ob[Cobj].act;    // Objects action
  914.     Cgrp = ob[Cobj].grp;    // Objects group
  915.     Cgeo = ob[Cobj].geo;    // Objects geometry
  916.     Csnd = ob[Cobj].snd;    // Objects sound
  917.     Cpob = MPath[Cact];        // Object actions path object
  918.     Cpgo = ob[Cpob].geo;    // Path objects geometry
  919.     lstVal[Cobj] = ob[Cobj].val - 100;
  920.     MDir[Cobj] = -1;
  921.     if(Version > 206)
  922.         rate[Cobj]  = MRate[Cact] * 0.01;
  923.     else
  924.         rate[Cobj]  = MRate[Cact];
  925. if(Cgeo) {
  926. Gszx[Cgeo] = Gszx[Cgeo] * 0.5;
  927. Gszy[Cgeo] = Gszy[Cgeo] * 0.5;
  928. }
  929.     // rotation and scaling
  930.     cscx[Cobj] = ob[Cobj].cscx;
  931.     cscy[Cobj] = ob[Cobj].cscy;
  932.     crot[Cobj] = ob[Cobj].crot;
  933.     cjtx[Cobj] = ob[Cobj].cjtx;
  934.     cjty[Cobj] = ob[Cobj].cjty;
  935.     cshd[Cobj] = 0.0;
  936.     shade[Cobj] = 1. / (MShade[Cact] * 30); //30 is a magic number
  937.     rotate[Cobj]= MRotate[Cact];
  938.     scale[Cobj] = MScale[Cact];
  939. //    rate[Cobj]  = MRate[Cact];
  940. //    Coid.getStyle().setProperty("opacity:","1.0");
  941.  
  942.     // for shading animation
  943.     if(ATyp[Catt] >= 10 && ATyp[Catt] <= 15) {
  944.         Agrd[Catt] = Svgdoc.getElementById(Aid1[Catt]);
  945.         var children = Agrd[Catt].getChildNodes();
  946.         Astp1[Catt]  = children.item(1).getStyle();
  947.         Astp2[Catt]  = children.item(3).getStyle();
  948.         if(ATyp[Catt] == 12)
  949.             Astp3[Catt]  = children.item(5).getStyle();
  950.     }
  951.     if(!Cact || !Cgeo || !Csty) {
  952.         Plen[Cobj] = 0;
  953.         noStep[Cobj] = 0;
  954.         disStep[Cobj] = 0;
  955.         dpox[Cobj] = 0;
  956.         dpoy[Cobj] = 0;
  957.         PathCount[Cobj] = 0;
  958.     }
  959.     else {
  960.         PathCount[Cobj] = MCount[Cact];
  961.  
  962.         if(MType[Cact] & ACT_XPATH_MOUSE || MType[Cact] & ACT_YPATH_MOUSE) { //^^ replaced with linPath??
  963.             Plen[Cobj] = 1;
  964.             noStep[Cobj] = 1;
  965.             disStep[Cobj] = 1;
  966.             dpox[Cobj] = 0;
  967.             dpoy[Cobj] = 0;
  968.         }
  969.         else if(MType[Cact] & ACT_XPATH_OBJPTH || MType[Cact] & ACT_XPATH_OBJXYZ) {
  970.             objPath(Cobj,Cpob,Cpgo);
  971.         }
  972.         else if(MType[Cact] & ACT_XPATH_KEYPTH) {
  973.             motionSetup(Cobj,Cpob,Cpgo);
  974.         }
  975.         else
  976.         {
  977.             linPath(Cobj);
  978.         }
  979.     }
  980.     cpox[Cobj] = spox[Cobj];
  981.     cpoy[Cobj] = spoy[Cobj];
  982.     LastPt[Cobj] = 0;
  983.     atDis[Cobj] = 0;
  984.     DisPt[Cobj] = 0;
  985.     EndPath[Cobj] = 0;
  986.  
  987.     GetStartPos();
  988. //    atDis[Cobj] = Plen[Cobj] * MStart[Cact];
  989.     objStep[Cobj] = 0;
  990.     if(MFlags[Cact] & (1<<20)) 
  991.     {
  992.         noStep[Cobj] = MPLen[Cact] * 30;
  993.     }
  994.     noStep[Cobj] *= (MPLen[Cact] / 100.);
  995.  
  996.     resetMatrix();
  997.     appTrans(Cobj);
  998.     return;
  999. }
  1000.  
  1001. function getPathLenth(Cobj,Cpob,Cgeo)
  1002. {
  1003.     var i, x = 0.0, y = 0.0;
  1004.     Plen[Cobj] = 0;
  1005.     // find length of rectangle
  1006.     if        ((Gtyp[Cgeo] & GEO_TYPE) == 1) {
  1007.         Plen[Cobj] = 2 * (Gpxl[Cgeo][1] - Gpxl[Cgeo][0]) * ob[Cpob].cscx
  1008.                    + 2 * (Gpyl[Cgeo][1] - Gpyl[Cgeo][0]) * ob[Cpob].cscy;
  1009.     }
  1010.     // find length of ellipse
  1011.     else if    ((Gtyp[Cgeo] & GEO_TYPE) == 2) {
  1012.         Plen[Cobj] = 360;
  1013.     }
  1014.     // find length of polygon
  1015.     else if    ((Gtyp[Cgeo] & GEO_TYPE) == 3) {
  1016.         for ( i = 1; i < Gnpt[Cgeo]; i++)
  1017.         {
  1018.             x = (Gpxl[Cgeo][i] - Gpxl[Cgeo][i-1]) * ob[Cpob].cscx;
  1019.             y = (Gpyl[Cgeo][i] - Gpyl[Cgeo][i-1]) * ob[Cpob].cscy;
  1020.             Plen[Cobj] += Math.sqrt(x*x + y*y);
  1021.         }
  1022.  
  1023.         if(!(Gtyp[Cgeo] & GEO_OPEN))
  1024.         {
  1025.             x = (Gpxl[Cgeo][Gnpt[Cgeo]-1] - Gpxl[Cgeo][0]) * ob[Cpob].cscx;
  1026.             y = (Gpyl[Cgeo][Gnpt[Cgeo]-1] - Gpyl[Cgeo][0]) * ob[Cpob].cscy;
  1027.             Plen[Cobj] += Math.sqrt(x*x + y*y);
  1028.         }
  1029.     }
  1030. //    Plen[Cobj] *= (MPLen[Cact] / 100.);
  1031. }
  1032.  
  1033. function linPath(Cobj) {
  1034. epox[Cobj] = spox[Cobj];
  1035. epoy[Cobj] = spoy[Cobj];
  1036.  
  1037. var    lh = mH * (MPLen[Cact] / 100.);
  1038. var    lw = mW * (MPLen[Cact] / 100.);
  1039.  
  1040.     if(MType[Cact] & ACT_YPATH_UP) {
  1041.         if(MType[Cact] & ACT_PATH_CENTER) {
  1042.             spoy[Cobj]     += lh;
  1043.             epoy[Cobj] -= lh;
  1044.         }
  1045.         else if(MType[Cact] & ACT_PATH_END) {
  1046.             spoy[Cobj]     += lh;
  1047.         }
  1048.         else if(MType[Cact] & ACT_PATH_START) {
  1049.             epoy[Cobj] -= lh;
  1050.         }
  1051.     }
  1052.     else if(MType[Cact] & ACT_YPATH_DOWN) {
  1053.         if(MType[Cact] & ACT_PATH_START) {
  1054.             epoy[Cobj] += lh;
  1055.         }
  1056.         else if(MType[Cact] & ACT_PATH_END) {
  1057.             spoy[Cobj]     -= lh;
  1058.         }
  1059.         else if(MType[Cact] & ACT_PATH_CENTER) {
  1060.             spoy[Cobj]     -= lh;
  1061.             epoy[Cobj] += lh;
  1062.         }
  1063.     }
  1064.     else if(MType[Cact] & ACT_YPATH_MOUSE) {
  1065.         Plen[Cobj] = 1;
  1066.         noStep[Cobj] = 1;
  1067.         disStep[Cobj] = 1;
  1068.         dpoy[Cobj] = 0;
  1069.         spoy[Cobj] = cpoy[Cobj];
  1070.     }
  1071.  
  1072.     if(MType[Cact] & ACT_XPATH_LEFT) {
  1073.         if(MType[Cact] & ACT_PATH_CENTER) {
  1074.             spox[Cobj]     += lw;
  1075.             epox[Cobj]  -= lw;
  1076.         }
  1077.         else if(MType[Cact] & ACT_PATH_END) {
  1078.             spox[Cobj]     += lw;
  1079.         }
  1080.         else if(MType[Cact] & ACT_PATH_START) {
  1081.             epox[Cobj]  -= lw;
  1082.         }
  1083.     }
  1084.     else if(MType[Cact] & ACT_XPATH_RIGHT) {
  1085.         if(MType[Cact] & ACT_PATH_START) {
  1086.             epox[Cobj]  += lw;
  1087.         }
  1088.         else if(MType[Cact] & ACT_PATH_END) {
  1089.             spox[Cobj]     -= lw;
  1090.         }
  1091.         else if(MType[Cact] & ACT_PATH_CENTER) {
  1092.             spox[Cobj]     -= lw;
  1093.             epox[Cobj]  += lw;
  1094.         }
  1095.     }
  1096.     else if(MType[Cact] & ACT_YPATH_MOUSE) {
  1097.         Plen[Cobj] = 1;
  1098.         noStep[Cobj] = 1;
  1099.         disStep[Cobj] = 1;
  1100.         dpox[Cobj] = 0;
  1101.         spox[Cobj] = cpox[Cobj];
  1102.     }
  1103.     var x = epox[Cobj] - spox[Cobj];
  1104.     var y = epoy[Cobj] - spoy[Cobj];
  1105.     if(x+y)
  1106.     {
  1107.         Plen[Cobj] = Math.sqrt(x*x + y*y);
  1108.         noStep[Cobj]  = Math.abs(Plen[Cobj] / rate[Cobj]);
  1109.         if(noStep[Cobj] < 1) noStep[Cobj] = 1;
  1110.         disStep[Cobj] = Plen[Cobj] / noStep[Cobj];
  1111.         dpox[Cobj] = x / noStep[Cobj];
  1112.         dpoy[Cobj] = y / noStep[Cobj];
  1113.     }
  1114.     else
  1115.     {
  1116.         Plen[Cobj] = 0;
  1117.         dpox[Cobj] = 0;
  1118.         dpoy[Cobj] = 0;
  1119.         disStep[Cobj] = 0;
  1120.         noStep[Cobj] = 1;
  1121.         disStep[Cobj] = 1;
  1122.         objStep[Cobj] = 1;
  1123.     }
  1124.     return
  1125. }
  1126.  
  1127. function objPath(Cobj,Cpob,Cpgo) 
  1128. {
  1129.     if        ((Gtyp[Cpgo] & GEO_TYPE) == 1) {    
  1130.         spox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + ob[Cpob].cpox;  
  1131.         spoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + ob[Cpob].cpoy;
  1132.         epox[Cobj] = spox[Cobj];
  1133.         epoy[Cobj] = spoy[Cobj];
  1134.     }
  1135.     else if    ((Gtyp[Cpgo] & GEO_TYPE) == 2) {
  1136.         spox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + ob[Cpob].cpox;
  1137. //        spoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + ob[Cpob].cpoy + Gszy[Cpob] * ob[Cpob].cscy;
  1138.         spoy[Cobj] = (Gpyl[Cpgo][0] + Gszy[Cpgo]) * ob[Cpob].cscy + ob[Cpob].cpoy;
  1139.         epox[Cobj] = spox[Cobj];
  1140.         epoy[Cobj] = spoy[Cobj];
  1141.     }
  1142.     else if    ((Gtyp[Cpgo] & GEO_TYPE) == 3) {
  1143.         spox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + ob[Cpob].cpox;
  1144.         spoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + ob[Cpob].cpoy;
  1145.         if(Gtyp[Cpgo] & GEO_OPEN) 
  1146.         {
  1147.             epox[Cobj] = Gpxl[Cpgo][Gnpt[Cpgo]-1] * ob[Cpob].cscx + ob[Cpob].cpox;
  1148.             epoy[Cobj] = Gpyl[Cpgo][Gnpt[Cpgo]-1] * ob[Cpob].cscy + ob[Cpob].cpoy;
  1149.         }
  1150.         else 
  1151.         {
  1152.             epox[Cobj] = spox[Cobj];
  1153.             epoy[Cobj] = spoy[Cobj];
  1154.         }
  1155.     }
  1156.  
  1157.     getPathLenth(Cobj,Cpob,Cpgo);
  1158.     if(Cact)
  1159.         noStep[Cobj]  = Math.abs(Plen[Cobj] / rate[Cobj]);
  1160.     else
  1161.         noStep[Cobj] = 0;
  1162.     if(noStep[Cobj] < 1) noStep[Cobj] = 1;
  1163.     disStep[Cobj] = Plen[Cobj] / noStep[Cobj];
  1164.  
  1165.     
  1166.     objStep[Cobj] = 0;
  1167.     objTime[Cobj] = -MDelay[Cact];
  1168.     return;
  1169. }
  1170.  
  1171. function GetStartPos()
  1172. {
  1173. if(Plen[Cobj] == 0 || (MType[Cact] & ACT_XPATH_OBJXYZ)) return;
  1174.  
  1175.     while(atDis[Cobj] < (Plen[Cobj] * MStart[Cact]))
  1176.     {
  1177.         if(MType[Cact] & ACT_XPATH_OBJPTH)
  1178.         {
  1179.             if     ((Gtyp[Cpgo] & GEO_TYPE) == 1)
  1180.                 GetRectLoc();
  1181.             else if((Gtyp[Cpgo] & GEO_TYPE) == 2) 
  1182.             {
  1183.                 GetArcLoc();
  1184.             }
  1185.             else if((Gtyp[Cpgo] & GEO_TYPE) == 3)
  1186.             {
  1187.                 GetPathLoc();
  1188.             }
  1189.             cpox[Cobj] += cpox[Cpob];
  1190.             cpoy[Cobj] += cpoy[Cpob];
  1191.         }
  1192.         else
  1193.         {
  1194.             if(MType[Cact] & ACT_XPATH_MOUSE)
  1195.                 cpox[Cobj] = cmx;
  1196.             else
  1197.                 cpox[Cobj] += dpox[Cobj];
  1198.  
  1199.             if(MType[Cact] & ACT_YPATH_MOUSE)
  1200.                 cpoy[Cobj] = cmy;
  1201.             else
  1202.                 cpoy[Cobj] += dpoy[Cobj];
  1203.         }
  1204.         atDis[Cobj] += disStep[Cobj];
  1205.     }
  1206.  
  1207. }
  1208.  
  1209. function motionSetup(Cobj,Cpob,Cpgo)
  1210. {
  1211. if(!Cobj || !Cpgo || !Cact) return;
  1212.  
  1213. objStep[Cobj] = 0;
  1214. objTime[Cobj] = -MDelay[Cact];
  1215. maxTime[Cobj] = Mctl[Cpgo][Gnpt[Cpgo]-1].tim;
  1216. if(MRepeat[Cact] >= 0)
  1217.  TotTime[Cobj] = MRepeat[Cact] * maxTime[Cobj];
  1218. else 
  1219.  TotTime[Cobj] = -1;
  1220. }
  1221.  
  1222. /////////////////////////////////////////////////
  1223. function UpdPos() {
  1224.  
  1225. if(Cgeo == 0) return;
  1226. if(MType[Cact] & ACT_XPATH_KEYPTH)
  1227.  motionUpdate();
  1228. else
  1229.  animateUpdate();
  1230. }
  1231.  
  1232. function motionUpdate()
  1233. {
  1234.     var res;
  1235.     objTime[Cobj] = tickTime - MDelay[Cact];
  1236.     if(objTime[Cobj] > maxTime[Cobj]) objStep[Cobj] = 0;
  1237.     if((TotTime[Cobj] < 0 || tickTime < TotTime[Cobj]) && objTime[Cobj] > 0 && maxTime[Cobj] > 0)
  1238.         objTime[Cobj] = objTime[Cobj] % (maxTime[Cobj]+1);
  1239.     else if(objTime[Cobj] > maxTime[Cobj])
  1240.         objTime[Cobj] = maxTime[Cobj];
  1241.     else if(objTime[Cobj] < 0)
  1242.         objTime[Cobj] = 0;
  1243.  
  1244.     res = pathUpdate();
  1245.     if(res == 0)
  1246.     {
  1247.         resetMatrix();
  1248.         x = cpox[Cobj] - ob[Cobj].corx;
  1249.         y = cpoy[Cobj] - ob[Cobj].cory;
  1250.         cpox[Cobj] = x * ob[Cpob].m0 + y * ob[Cpob].m2 + ob[Cpob].m4;
  1251.         cpoy[Cobj] = x * ob[Cpob].m1 + y * ob[Cpob].m3 + ob[Cpob].m5;
  1252.         appTrans(Cobj);
  1253.         transKyPt();
  1254.         appMtrx();
  1255.     }
  1256.     return res;
  1257. }
  1258.  
  1259. function pathUpdate()
  1260. {
  1261. var red1, gre1, blu1, alp1, red2, gre2, blu2, alp2;
  1262.  
  1263. if(objTime[Cobj] < Mctl[Cpgo][0].tim) return -1;
  1264. if(objTime[Cobj] > Mctl[Cpgo][Gnpt[Cpgo]-1].tim) return 1;
  1265. while(objTime[Cobj] > Mctl[Cpgo][objStep[Cobj]+1].tim)
  1266. {
  1267.     if((objStep[Cobj] + 1) >= Gnpt[Cpgo]-1)    {
  1268.         objStep[Cobj] = Gnpt[Cpgo]-1;
  1269.         return 1;
  1270.     }
  1271.     else
  1272.         objStep[Cobj]++;
  1273. }
  1274.  
  1275. var cStep = objStep[Cobj];
  1276. var fact = (objTime[Cobj] - Mctl[Cpgo][cStep].tim) / (Mctl[Cpgo][cStep+1].tim-Mctl[Cpgo][cStep].tim);
  1277. if(fact < 0) fact = 0;
  1278. else if(fact > 1) fact = 1.0;
  1279. var ifact = 1.0 - fact;
  1280.  
  1281. if(ob[Cobj].jnt) {
  1282.     cpox[Cobj] = cjtx[ob[Cobj].jnt];
  1283.     cpoy[Cobj] = cjty[ob[Cobj].jnt];
  1284. }
  1285. else {
  1286.     cpox[Cobj] = Gpxl[Cpgo][cStep] + ((Gpxl[Cpgo][cStep+1] - Gpxl[Cpgo][cStep]) * fact);
  1287.     cpoy[Cobj] = Gpyl[Cpgo][cStep] + ((Gpyl[Cpgo][cStep+1] - Gpyl[Cpgo][cStep]) * fact);
  1288. }
  1289. cscx[Cobj] = Mctl[Cpgo][cStep].sclx + (Mctl[Cpgo][cStep+1].sclx - Mctl[Cpgo][cStep].sclx) * fact;
  1290. cscy[Cobj] = Mctl[Cpgo][cStep].scly + (Mctl[Cpgo][cStep+1].scly - Mctl[Cpgo][cStep].scly) * fact;
  1291. crot[Cobj] = Mctl[Cpgo][cStep].rot + (Mctl[Cpgo][cStep+1].rot - Mctl[Cpgo][cStep].rot) * fact;
  1292.  
  1293. if(Catt && (cStep == 0 || Mctl[Cpgo][cStep].rgb1 != Mctl[Cpgo][cStep+1].rgb1 || Mctl[Cpgo][cStep].rgb2 != Mctl[Cpgo][cStep+1].rgb2)) 
  1294. {
  1295.     red = (Mctl[Cpgo][cStep].rgb1    &255) * ifact + (Mctl[Cpgo][cStep+1].rgb1    &255) * fact;
  1296.     grn = (Mctl[Cpgo][cStep].rgb1>> 8&255) * ifact + (Mctl[Cpgo][cStep+1].rgb1>> 8&255) * fact;
  1297.     blu = (Mctl[Cpgo][cStep].rgb1>>16&255) * ifact + (Mctl[Cpgo][cStep+1].rgb1>>16&255) * fact;
  1298.     alp = (Mctl[Cpgo][cStep].rgb1>>24&255) * ifact + (Mctl[Cpgo][cStep+1].rgb1>>24&255) * fact;
  1299.  
  1300.     if(ATyp[Catt] >= 10 && ATyp[Catt] <= 15)
  1301.     {
  1302.         Astp1[Catt].setProperty("stop-color", "rgb("+red+","+grn+","+blu+");");
  1303.         Astp1[Catt].setProperty("stop-opacity", (1.-alp/255.) + ";");
  1304.         if(ATyp[Catt] >= 12)
  1305.         {
  1306.             Astp3[Catt].setProperty("stop-color", "rgb("+red+","+grn+","+blu+");");
  1307.             Astp3[Catt].setProperty("stop-opacity", (1.-alp/255.) + ";");
  1308.         }
  1309.  
  1310.         red = (Mctl[Cpgo][cStep].rgb2    &255) * ifact + (Mctl[Cpgo][cStep+1].rgb2    &255) * fact;
  1311.         grn = (Mctl[Cpgo][cStep].rgb2>> 8&255) * ifact + (Mctl[Cpgo][cStep+1].rgb2>> 8&255) * fact;
  1312.         blu = (Mctl[Cpgo][cStep].rgb2>>16&255) * ifact + (Mctl[Cpgo][cStep+1].rgb2>>16&255) * fact;
  1313.         alp = (Mctl[Cpgo][cStep].rgb2>>24&255) * ifact + (Mctl[Cpgo][cStep+1].rgb2>>24&255) * fact;
  1314.  
  1315.         Astp2[Catt].setProperty("stop-color", "rgb("+red+","+grn+","+blu+");");
  1316.         Astp2[Catt].setProperty("stop-opacity", (1.-alp/255.) + ";");
  1317.  
  1318.     }
  1319.     else {
  1320.         Coid.setAttribute("style", "fill:" + "rgb("+red+","+grn+","+blu+");opacity:" + (1.-alp/255.));
  1321.     }
  1322. }
  1323.  
  1324. red = (Mctl[Cpgo][cStep].cout    &256) * ifact + (Mctl[Cpgo][cStep+1].cout    &256) * fact;
  1325. grn = (Mctl[Cpgo][cStep].cout>> 8&256) * ifact + (Mctl[Cpgo][cStep+1].cout>> 8&256) * fact;
  1326. blu = (Mctl[Cpgo][cStep].cout>>16&256) * ifact + (Mctl[Cpgo][cStep+1].cout>>16&256) * fact;
  1327. alp = (Mctl[Cpgo][cStep].rgb1>>24&256) * ifact + (Mctl[Cpgo][cStep+1].rgb1>>24&256) * fact;
  1328. alp  = Mctl[Cpgo][cStep].lwid * ifact + Mctl[Cpgo][cStep+1].lwid * fact;
  1329.  
  1330. Gpgo.setAttribute("style", "stroke:rgb("+red+","+grn+","+blu+");stroke-width:"+alp+";");
  1331.  
  1332. return 0;
  1333. }
  1334.  
  1335. /////////////////////////////////////////////////////////////////////////
  1336. function animateUpdate() {
  1337. Lpox = cpox[Cobj];
  1338. Lpoy = cpoy[Cobj];
  1339. // end of path condition
  1340. if(noStep[Cobj] > 0 && objStep[Cobj] >= noStep[Cobj]) 
  1341. {
  1342.     objStep[Cobj] = 0;
  1343.     atDis[Cobj]  = Plen[Cobj] * MStart[Cact];
  1344.     LastPt[Cobj] = 0;
  1345.     DisPt[Cobj]  = 0;
  1346.     cpox[Cobj]   = spox[Cobj];
  1347.     cpoy[Cobj]   = spoy[Cobj];
  1348. //  reverse path, scaling, rotation, shading
  1349.     if(MFlags[Cact] & (1<<11))
  1350.         rate[Cobj] *= -1;
  1351.     if(MFlags[Cact] & (1<<13))
  1352.         rotate[Cobj] *= -1;
  1353.     else
  1354.         crot[cobj] = ob[cobj].crot;
  1355.     if(MFlags[Cact] & (1<<19))
  1356.         scale[Cobj] *= -1;
  1357.     else
  1358.     {
  1359.         cscx[cobj] = ob[cobj].cscx;
  1360.         cscy[cobj] = ob[cobj].cscy;
  1361.     }
  1362.     if(MFlags[Cact] & (1<<21))
  1363.         shade[Cobj] *= -1;
  1364.     else
  1365.         cshd[cobj] = 0.0;
  1366. }
  1367. fact = atDis[Cobj] / Plen[Cobj];
  1368. ifact= 1.-fact;
  1369.  
  1370. // shading and transparency
  1371. if(MALst[Cact] != 0) {
  1372. var f1;
  1373. var f2;
  1374.     if(MFlags[Cact] & (1<<20)) {
  1375.         cshd[Cobj] += shade[Cobj];
  1376.         if((cshd[Cobj] > 1.0 || cshd[Cobj] < 0.0) && MFlags[Cact] && (1<<21)) shade[Cobj] *= -1;
  1377.         cshd[Cobj] = max(0,min(1,cshd[Cobj]));
  1378.         f1 = cshd[Cobj];
  1379.         f2 = 1 - f1;
  1380.     }
  1381.     else if(shade[Cobj] < 0) {
  1382.         f1 = fact; 
  1383.         f2 = ifact; 
  1384.     }
  1385.     else {
  1386.         f2 = fact; 
  1387.         f1 = ifact; 
  1388.     }
  1389.     f1 = max(0.0,min(1.0,f1));
  1390.     f2 = max(0.0,min(1.0,f2));
  1391.     if(ATyp[Catt] >= 10 && ATyp[Catt] <= 15)
  1392.     {
  1393.         var vx = (AVc1x[Catt] * f1 + AVc1x[MALst[Cact]] * f2);
  1394.         var vy = (AVc1y[Catt] * f1 + AVc1y[MALst[Cact]] * f2);
  1395.         Agrd[Catt].setAttribute('x',(vx+50)+'%');
  1396.         Agrd[Catt].setAttribute('y',(vy+50)+'%');
  1397.         if(ATyp[Catt] == 11) {
  1398.             vx = -vx + 50;
  1399.             vy = -vy + 50;
  1400.         }
  1401.         else {
  1402.             vx = (AVc2x[Catt] * f1 + AVc2x[MALst[Cact]] * f2) + 50;
  1403.             vy = (AVc2y[Catt] * f1 + AVc2y[MALst[Cact]] * f2) + 50;
  1404.         }
  1405.         Agrd[Catt].setAttribute('fx',vx+'%');
  1406.         Agrd[Catt].setAttribute('fy',vy+'%');
  1407.  
  1408.         red = (ACol[Catt]    &256) * f1 + (ACol[MALst[Cact]]    &256) * f2;
  1409.         grn = (ACol[Catt]>> 8&256) * f1 + (ACol[MALst[Cact]]>> 8&256) * f2;
  1410.         blu = (ACol[Catt]>>16&256) * f1 + (ACol[MALst[Cact]]>>16&256) * f2;
  1411.         alp = (ACol[Catt]>>24&256) * f1 + (ACol[MALst[Cact]]>>24&256) * f2;
  1412.  
  1413.         Astp1[Catt].setProperty("stop-color", "rgb("+red+","+grn+","+blu+");");
  1414.         Astp1[Catt].setProperty("stop-opacity", (1.-alp/255.) + ";");
  1415.  
  1416.         if(ATyp[Catt] == 12)
  1417.         {
  1418.             Astp3[Catt].setProperty("stop-color", "rgb("+red+","+grn+","+blu+");");
  1419.             Astp3[Catt].setProperty("stop-opacity", (1.-alp/255.) + ";");
  1420.         }
  1421.  
  1422.         red = (ACol2[Catt]    &255) * f1 + (ACol2[MALst[Cact]]    &255) * f2;
  1423.         grn = (ACol2[Catt]>> 8&255) * f1 + (ACol2[MALst[Cact]]>> 8&255) * f2;
  1424.         blu = (ACol2[Catt]>>16&255) * f1 + (ACol2[MALst[Cact]]>>16&255) * f2;
  1425.         alp = (ACol2[Catt]>>24&255) * f1 + (ACol2[MALst[Cact]]>>24&255) * f2;
  1426.  
  1427.         Astp2[Catt].setProperty("stop-color", "rgb("+red+","+grn+","+blu+");");
  1428.         Astp2[Catt].setProperty("stop-opacity", (1.-alp/255.) + ";");
  1429.     }
  1430.     else
  1431.     {
  1432.         red = (ACol[Catt]    &255) * f1 + (ACol[MALst[Cact]]    &255) * f2;
  1433.         grn = (ACol[Catt]>> 8&255) * f1 + (ACol[MALst[Cact]]>> 8&255) * f2;
  1434.         blu = (ACol[Catt]>>16&255) * f1 + (ACol[MALst[Cact]]>>16&255) * f2;
  1435.         alp = (ACol[Catt]>>24&255) * f1 + (ACol[MALst[Cact]]>>24&255) * f2;
  1436.  
  1437.         Coid.setAttribute("style", "fill:" + "rgb("+red+","+grn+","+blu+");opacity:" + (1.-alp/255.));
  1438.     }
  1439. }
  1440.  
  1441. tranUpdate();
  1442.  
  1443. if(Plen[Cobj] != 0) atDis[Cobj] += disStep[Cobj];
  1444. objStep[Cobj]++;
  1445.  
  1446. if(noStep[Cobj] > 0 && objStep[Cobj] >= noStep[Cobj]) 
  1447. {
  1448.     if(PathCount[Cobj] > 0) PathCount[Cobj]--;
  1449.     if(PathCount[Cobj] == 0) {
  1450.         EndPath[Cobj] = 1;
  1451.     }
  1452. }
  1453.  
  1454. if(Cact) UpdGeo();
  1455. if(Cobj == pgScObj) {
  1456. var x = cpox[Cobj]-mW*0.5;
  1457. var y = cpoy[Cobj]-mH*0.5;
  1458. //^^^window.scrollTo(x,y);
  1459. }
  1460.  
  1461. return;
  1462. }
  1463.  
  1464. function tranUpdate() 
  1465. {
  1466.     resetMatrix();
  1467.     // calculate rotation
  1468.     if(rotate[Cobj] != 0) 
  1469.     {
  1470.         if(MFlags[Cact] & (1<<12))
  1471.             crot[Cobj] += rotate[Cobj] * 4;
  1472.         else
  1473.             crot[Cobj] = rotate[Cobj] * fact * 360;
  1474.     }
  1475.     // calculate scaling
  1476.     if(scale[Cobj] != 0) 
  1477.     {
  1478.         if(MFlags[Cact] & (1<<18))
  1479.         {
  1480.             cscx[Cobj] += scale[Cobj] / 360.; 
  1481.             cscy[Cobj] += scale[Cobj] / 360.;
  1482.         }
  1483.         else
  1484.         {
  1485.             var flt = (scale[Cobj] > 0) ? fact : ifact;
  1486.             cscx[Cobj] = ob[Cobj].cscx * (flt + 1.);
  1487.             cscy[Cobj] = ob[Cobj].cscy * (flt + 1.);
  1488.         }
  1489.         var fsize = 12 * cscx[Cobj];
  1490.     }
  1491.     if(ob[Cobj].jnt) {
  1492.         cpox[Cobj] = cjtx[ob[Cobj].jnt];
  1493.         cpoy[Cobj] = cjty[ob[Cobj].jnt];
  1494.     }
  1495.     // attached to the position of another Object
  1496.     else if(MType[Cact] & ACT_XPATH_OBJXYZ) 
  1497.     {    
  1498.         cpox[Cobj] = cpox[Cpob] - ob[Cobj].corx;
  1499.         cpoy[Cobj] = cpoy[Cpob] - ob[Cobj].corx;
  1500.     }
  1501.     // trace an Object path
  1502.     else if(MType[Cact] & ACT_XPATH_OBJPTH)
  1503.     {
  1504.         if     ((Gtyp[Cpgo] & GEO_TYPE) == 1)
  1505.             GetRectLoc();
  1506.         else if((Gtyp[Cpgo] & GEO_TYPE) == 2) 
  1507.         {
  1508.             GetArcLoc();
  1509.         }            
  1510.         else if((Gtyp[Cpgo] & GEO_TYPE) == 3)
  1511.         {
  1512.             GetPathLoc();
  1513.         }
  1514.         x = cpox[Cobj] - ob[Cobj].corx;
  1515.         y = cpoy[Cobj] - ob[Cobj].cory;
  1516.         cpox[Cobj] = x * ob[Cpob].m0 + y * ob[Cpob].m2 + ob[Cpob].m4;
  1517.         cpoy[Cobj] = x * ob[Cpob].m1 + y * ob[Cpob].m3 + ob[Cpob].m5;
  1518. //window.status = 'Cpob='+Cpob+' matrix='+ob[Cpob].m0+','+ob[Cpob].m1+','+ob[Cpob].m2+','+ob[Cpob].m3+','+ob[Cpob].m4+','+ob[Cpob].m5;
  1519. //window.status = 'Cobj='+Cobj+' cpox[Cobj]='+cpox[Cobj]+' cpoy[Cobj]='+cpoy[Cobj]+' x='+x+' y='+y;
  1520. //window.status = 'Cpob='+Cpob+' matrix='+ob[Cpob].m0+','+cpox[Cpob]+','+cpoy[Cpob];
  1521.     }
  1522.     // trace the mouse
  1523.     else
  1524.     {
  1525.         if(MType[Cact] & ACT_XPATH_MOUSE)
  1526.             cpox[Cobj] = cmx - ob[Cobj].corx;
  1527.         else
  1528.             cpox[Cobj] += dpox[Cobj]; //^^ is this STOP?
  1529.  
  1530.         if(MType[Cact] & ACT_YPATH_MOUSE)
  1531.             cpoy[Cobj] = cmy - ob[Cobj].cory;
  1532.         else
  1533.             cpoy[Cobj] += dpoy[Cobj];
  1534.     }
  1535.  
  1536. //window.status = 'Cobj='+Cobj+' cscx[Cobj]='+cscx[Cobj]+' cscy[Cobj]='+cscy[Cobj]+' crot[Cobj]='+crot[Cobj];
  1537.     appTrans(Cobj);
  1538.     transKyPt();
  1539.     appMtrx();
  1540. }
  1541.  
  1542. function GetArcLoc() {
  1543. if(rate[Cobj] > 0) 
  1544. {
  1545.     cpox[Cobj] = (Math.sin(0.017453292*(-atDis[Cobj]-90)) * Gszx[Cpgo]);
  1546.     cpoy[Cobj] = (Math.cos(0.017453292*(-atDis[Cobj]-90)) * Gszy[Cpgo]);
  1547. }
  1548. else 
  1549. {
  1550.     cpox[Cobj] = (Math.sin(0.017453292*(atDis[Cobj]-90)) * Gszx[Cpgo]);
  1551.     cpoy[Cobj] = (Math.cos(0.017453292*(atDis[Cobj]-90)) * Gszy[Cpgo]);
  1552. }
  1553. return;
  1554. }
  1555.  
  1556. function GetPathLoc() {
  1557. var cPt, nPt, x, y, dis=0.0, ratio=0.0, ct = 0;
  1558.  
  1559. if(rate[Cobj] > 0) 
  1560. {
  1561.     while(ct <= Gnpt[Cpgo]) 
  1562.     {
  1563.         ct ++;
  1564.         if(LastPt[Cobj]+1 < Gnpt[Cpgo]) 
  1565.         {
  1566.             cPt = LastPt[Cobj];
  1567.             nPt = cPt + 1; 
  1568.         }
  1569.         else
  1570.         {
  1571.             if(Gtyp[Cpgo] & GEO_OPEN) 
  1572.             {
  1573.                 LastPt[Cobj]  = 0;
  1574.                 cPt = 0;
  1575.                 nPt = 1; 
  1576.             }
  1577.             else 
  1578.             {
  1579.                 LastPt[Cobj]  = Gnpt[Cpgo]-1;
  1580.                 cPt = LastPt[Cobj];
  1581.                 nPt = 0; 
  1582.             }
  1583.         }
  1584.         x  = (Gpxl[Cpgo][nPt] - Gpxl[Cpgo][cPt]);
  1585.         y  = (Gpyl[Cpgo][nPt] - Gpyl[Cpgo][cPt]);
  1586.         dis = Math.sqrt(x*x + y*y);
  1587.         if(atDis[Cobj] < (dis + DisPt[Cobj])) break;
  1588.         DisPt[Cobj] += dis;
  1589.         LastPt[Cobj]++;
  1590.         if(LastPt[Cobj] >= Gnpt[Cpgo]) 
  1591.         {
  1592.             cPt = 0;
  1593.             nPt = 1;
  1594.             LastPt[Cobj] = 0;
  1595.         }
  1596.     }
  1597.     ratio = (atDis[Cobj] - DisPt[Cobj]) / dis;
  1598.     cpox[Cobj] = Gpxl[Cpgo][cPt] + x * ratio;
  1599.     cpoy[Cobj] = Gpyl[Cpgo][cPt] + y * ratio;
  1600.  
  1601.     return;
  1602. }
  1603. else 
  1604. {
  1605.     while(ct <= Gnpt[Cpgo]) 
  1606.     {
  1607.         ct ++;
  1608.         if(LastPt[Cobj]+1 < Gnpt[Cpgo]) 
  1609.         {
  1610.             cPt = Gnpt[Cpgo] - LastPt[Cobj] - 1;
  1611.             nPt = cPt - 1; 
  1612.         }
  1613.         else
  1614.         {
  1615.             if(Gtyp[Cpgo] & GEO_OPEN) 
  1616.             {
  1617.                 LastPt[Cobj]  = Gnpt[Cpgo] - 1;
  1618.                 cPt = Gnpt[Cpgo] - 1;
  1619.                 nPt = cPt - 1; 
  1620.             }
  1621.             else 
  1622.             {
  1623.                 LastPt[Cobj]  = Gnpt[Cpgo];
  1624.                 cPt = 0;
  1625.                 nPt = LastPt[Cobj] - 1; 
  1626.             }
  1627.         }
  1628.         x  = (Gpxl[Cpgo][nPt] - Gpxl[Cpgo][cPt]);
  1629.         y  = (Gpyl[Cpgo][nPt] - Gpyl[Cpgo][cPt]);
  1630.         dis = Math.sqrt(x*x + y*y);
  1631.         if(atDis[Cobj] <= (dis + DisPt[Cobj])) break;
  1632.         DisPt[Cobj] += dis;
  1633.         LastPt[Cobj]++;
  1634.         if(LastPt[Cobj] >= Gnpt[Cpgo]) 
  1635.         {
  1636.             cPt = 0;
  1637.             nPt = 1;
  1638.             LastPt[Cobj] = 0;
  1639.         }
  1640.     }
  1641.     ratio = (atDis[Cobj] - DisPt[Cobj]) / dis;
  1642.     cpox[Cobj] = Gpxl[Cpgo][cPt] + x * ratio;
  1643.     cpoy[Cobj] = Gpyl[Cpgo][cPt] + y * ratio;
  1644.  
  1645.     return;
  1646.     }
  1647. }
  1648.  
  1649. function GetRectLoc() 
  1650. {
  1651.  
  1652. var dis = 0.0;
  1653. while (0==0) 
  1654. {
  1655.     if(rate[Cobj] > 0) 
  1656.     {
  1657.         if(LastPt[Cobj] == 0) 
  1658.         {
  1659.             dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]);
  1660.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1661.             {
  1662.                 cpox[Cobj] = Gpxl[Cpgo][0] + (atDis[Cobj]-DisPt[Cobj]);
  1663.                 cpoy[Cobj] = Gpyl[Cpgo][0];
  1664.                 break; 
  1665.             }
  1666.             LastPt[Cobj] = 1;
  1667.             DisPt[Cobj] += dis; 
  1668.         }
  1669.         if(LastPt[Cobj] == 1) 
  1670.         {
  1671.             dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]);
  1672.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1673.             {
  1674.                 cpox[Cobj] = Gpxl[Cpgo][1];
  1675.                 cpoy[Cobj] = Gpyl[Cpgo][0] + (atDis[Cobj]-DisPt[Cobj]);
  1676.                 break;
  1677.             }
  1678.             DisPt[Cobj] += dis;
  1679.             LastPt[Cobj] = 2;
  1680.         }
  1681.         if(LastPt[Cobj] == 2) 
  1682.         {
  1683.             dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]);
  1684.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1685.             {
  1686.                 cpox[Cobj] = Gpxl[Cpgo][1] - (atDis[Cobj]-DisPt[Cobj]);
  1687.                 cpoy[Cobj] = Gpyl[Cpgo][1];
  1688.                 break; 
  1689.             }
  1690.             DisPt[Cobj] += dis;
  1691.             LastPt[Cobj] = 3; 
  1692.         }
  1693.         if(LastPt[Cobj] == 3) 
  1694.         {
  1695.             dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]);
  1696.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1697.             {
  1698.                 cpox[Cobj] = Gpxl[Cpgo][0];
  1699.                 cpoy[Cobj] = Gpyl[Cpgo][1] - (atDis[Cobj]-DisPt[Cobj]);
  1700.                 break;
  1701.             }
  1702.             DisPt[Cobj] += dis;
  1703.             LastPt[Cobj] = 0;
  1704.         }
  1705.     }
  1706.     else 
  1707.     {
  1708.         if(LastPt[Cobj] == 0) 
  1709.         {
  1710.             dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]);
  1711.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1712.             {
  1713.                 cpox[Cobj] = Gpxl[Cpgo][0];
  1714.                 cpoy[Cobj] = Gpyl[Cpgo][0] + (atDis[Cobj]-DisPt[Cobj]);
  1715.                 break; 
  1716.             }
  1717.             LastPt[Cobj] = 3;
  1718.             DisPt[Cobj] += dis; 
  1719.         }
  1720.         if(LastPt[Cobj] == 3) 
  1721.         {
  1722.             dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]);
  1723.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1724.             {
  1725.                 cpox[Cobj] = Gpxl[Cpgo][0] + (atDis[Cobj]-DisPt[Cobj]);
  1726.                 cpoy[Cobj] = Gpyl[Cpgo][1];
  1727.                 break;
  1728.             }
  1729.             DisPt[Cobj] += dis;
  1730.             LastPt[Cobj] = 2;
  1731.         }
  1732.         if(LastPt[Cobj] == 2) 
  1733.         {
  1734.             dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]);
  1735.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1736.             {
  1737.                 cpox[Cobj] = Gpxl[Cpgo][1];
  1738.                 cpoy[Cobj] = Gpyl[Cpgo][1] - (atDis[Cobj]-DisPt[Cobj]);
  1739.                 break; 
  1740.             }
  1741.             DisPt[Cobj] += dis;
  1742.             LastPt[Cobj] = 1; 
  1743.         }
  1744.         if(LastPt[Cobj] == 1) 
  1745.         {
  1746.             dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]);
  1747.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1748.             {
  1749.                 cpox[Cobj] = Gpxl[Cpgo][1] - (atDis[Cobj]-DisPt[Cobj]);
  1750.                 cpoy[Cobj] = Gpyl[Cpgo][0];
  1751.                 break;
  1752.             }
  1753.             DisPt[Cobj] += dis;
  1754.             LastPt[Cobj] = 0;
  1755.         }
  1756.     }
  1757. }
  1758. return;
  1759. }
  1760.  
  1761. ///////////////////////////////////////////////
  1762.  
  1763. function resetMatrix() {
  1764. cM = 0;
  1765. ob[Cobj].m0 =  1;
  1766. ob[Cobj].m1 =  0;
  1767. ob[Cobj].m2 =  0;
  1768. ob[Cobj].m3 =  1;
  1769. ob[Cobj].m4 =  0;
  1770. ob[Cobj].m5 =  0;
  1771. }
  1772.  
  1773. function appTrans(obj) {
  1774.     moveMatrix(cpox[obj]+ob[Cobj].corx, cpoy[obj]+ob[Cobj].cory);
  1775.     rotateMatrix(crot[obj]);
  1776.     scaleMatrix(cscx[obj],cscy[obj]);
  1777.     moveMatrix(-ob[Cobj].corx, -ob[Cobj].cory);
  1778. }
  1779.  
  1780. function moveMatrix(x, y) {
  1781.     ob[Cobj].m4 += x * ob[Cobj].m0 + y * ob[Cobj].m2;
  1782.     ob[Cobj].m5 += x * ob[Cobj].m1 + y * ob[Cobj].m3;
  1783. }
  1784.  
  1785. function scaleMatrix(x, y) {
  1786.  
  1787.     ob[Cobj].m0 *= x;
  1788.     ob[Cobj].m1 *= x;
  1789.  
  1790.     ob[Cobj].m2 *= y;
  1791.     ob[Cobj].m3 *= y;
  1792. }
  1793.  
  1794. function rotateMatrix(ang) {
  1795. var cosAng = Math.cos(0.017453292*ang);
  1796. var sinAng = Math.sin(0.017453292*ang);
  1797. var a = ob[Cobj].m0;
  1798. var b = ob[Cobj].m1;
  1799. var c = ob[Cobj].m2;
  1800. var d = ob[Cobj].m3;
  1801. var e = ob[Cobj].m4;
  1802. var f = ob[Cobj].m5;
  1803.  
  1804. ob[Cobj].m0 = a *  cosAng + c * sinAng;
  1805. ob[Cobj].m1 = b *  cosAng + d * sinAng;
  1806. ob[Cobj].m2 = a * -sinAng + c * cosAng;
  1807. ob[Cobj].m3 = b * -sinAng + d * cosAng;
  1808. }
  1809.  
  1810. function tranMatrix(cpob) {
  1811. var a = ob[Cobj].m0;
  1812. var b = ob[Cobj].m1;
  1813. var c = ob[Cobj].m2;
  1814. var d = ob[Cobj].m3;
  1815. var tx= ob[Cobj].m4;
  1816. var ty= ob[Cobj].m5;
  1817.     ob[Cobj].m0 = a * ob[cpob].m0 + b * ob[cpob].m2;
  1818.     ob[Cobj].m1 = a * ob[cpob].m1 + b * ob[cpob].m3;
  1819.  
  1820.     ob[Cobj].m2 = c * ob[cpob].m0 + d * ob[cpob].m2;
  1821.     ob[Cobj].m3 = c * ob[cpob].m1 + d * ob[cpob].m3;
  1822.  
  1823.     ob[Cobj].m4 = tx * ob[cpob].m0 + ty * ob[cpob].m2 + ob[cpob].m4;
  1824.     ob[Cobj].m5 = tx * ob[cpob].m1 + ty * ob[cpob].m3 + ob[cpob].m5;
  1825. }
  1826.  
  1827. function UpdKpt() {
  1828. cpox[Cobj] = cjtx[ob[Cobj].jnt] -ob[Cobj].corx;
  1829. cpoy[Cobj] = cjty[ob[Cobj].jnt] -ob[Cobj].cory;
  1830. Coid.setAttribute('transform','translate('+cpox[Cobj]+','+cpoy[Cobj]+'),rotate('+crot[Cobj]+'),scale('+cscx[Cobj]+','+cscy[Cobj]+')');
  1831. }
  1832.  
  1833. function transKyPt() {
  1834.     cjtx[Cobj]  = ob[Cobj].cjtx * ob[Cobj].m0 + ob[Cobj].cjty * ob[Cobj].m2 + ob[Cobj].m4;
  1835.     cjty[Cobj]  = ob[Cobj].cjtx * ob[Cobj].m1 + ob[Cobj].cjty * ob[Cobj].m3 + ob[Cobj].m5;
  1836. }
  1837.  
  1838. function appMtrx() {
  1839. Coid.setAttribute('transform','matrix('+ob[Cobj].m0+','+ob[Cobj].m1+','+ob[Cobj].m2+','+ob[Cobj].m3+','+ob[Cobj].m4+','+ob[Cobj].m5+')');
  1840. //window.status = 'Cobj='+Cobj+'ob[Cobj].m0='+ob[Cobj].m0+' ob[Cobj].m1='+ob[Cobj].m1+' ob[Cobj].m2='+ob[Cobj].m2+' ob[Cobj].m3='+ob[Cobj].m3+ob[Cobj].m3+' ob[Cobj].m4='+ob[Cobj].m4+' ob[Cobj].m5='+ob[Cobj].m5;
  1841. }
  1842.