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