home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / flash078.zip / flashsource-r0_7_8.zip / FAction.h < prev    next >
C/C++ Source or Header  |  2001-08-02  |  14KB  |  371 lines
  1. #ifndef FACTION_H_FILE
  2. #define FACTION_H_FILE
  3.  
  4. #include <iostream>
  5. #include <strstream>
  6. #include <vector>
  7.  
  8. #include "FBase.h"
  9.  
  10. class FlashActionRecord
  11. {
  12. public:
  13.     FlashActionRecord() : m_size(0) {}
  14.         virtual ~FlashActionRecord() { }
  15.  
  16.     virtual void Write(std::ostream &out) { WriteHeader(out,m_size); out.write(unknowndata,m_size); }
  17.     
  18.     virtual void Read(std::istream &in) { ReadHeader(in); if(m_size != 0) { unknowndata = (char *)malloc(m_size+1); gcstrings.push_back(unknowndata); in.read(unknowndata,m_size); } }
  19. protected:
  20.     void WriteHeader(std::ostream &out, UWORD size=0);
  21.     void ReadHeader(std::istream &in)  { m_code = in.get(); if(m_code < 0x80) return; READ_UWORD(m_size); }
  22.     
  23.     char *unknowndata;
  24.     gc_vector<char*> gcstrings;
  25.     
  26.     UWORD m_code;
  27.     UWORD m_size;
  28. };
  29.  
  30.  
  31.  
  32. //ACTION WITH NO PARAMS
  33. #define DECLARE_SIMPLE_ACTION_CLASS(ActionName, ActionID)        \
  34. class ActionName : public FlashActionRecord                        \
  35. {                                                                \
  36. public:                                                            \
  37.     ActionName() { m_code=ActionID; }                            \
  38.         virtual ~ActionName() {}                                                                                        \
  39.     virtual void Write(std::ostream &out) { WriteHeader(out); }    \
  40. private:                                                        \
  41. };
  42. //ACTION WITH WORD PARAM
  43. #define DECLARE_SIMPLE_ACTION_CLASS2(ActionName, ActionID, pName)    \
  44. class ActionName : public FlashActionRecord                            \
  45. {                                                                    \
  46. public:                                                                \
  47.     ActionName(SWORD pName) : data(pName) { m_code=ActionID; }        \
  48.         virtual ~ActionName() {}                                                                                                \
  49.     virtual void Write(std::ostream &out) { WriteHeader(out,2);        \
  50.                                             WRITE_SWORD(data); }    \
  51.     SWORD Get##pName() { return data; }                                \
  52.     virtual void Read(std::istream &in) { ReadHeader(in); READ_SWORD(data); } \
  53. private:                                                            \
  54.     ActionName() {}                                                    \
  55.     friend class FlashActionVectorImporter;                        \
  56.     SWORD data;                                                        \
  57. };
  58.  
  59. //ACTION WITH STRING PARAM
  60. #define DECLARE_SIMPLE_ACTION_CLASS3(ActionName, ActionID, pName)                    \
  61. class ActionName : public FlashActionRecord                                            \
  62. {                                                                                    \
  63. public:                                                                                \
  64.         ActionName(char *pName) : data(pName) { m_code=ActionID; }                               \
  65.         virtual ~ActionName() {  }                                                                                                                                \
  66.     virtual void Write(std::ostream &out) { WriteHeader(out,strlen(data)+1);        \
  67.                                             out << data; out.put((char)0); }            \
  68.     const char *Get##pName() { return data; }                                \
  69.         virtual void Read(std::istream &in) { ReadHeader(in); std::vector<char> str; unsigned int i;     while((i = in.get()) != 0)      { str.push_back((char)i); } data = (char*)malloc(str.size()+1); garbage.push_back(data); i=0; for(;i < str.size(); i++) { data[i]=str[i]; }      data[i]=0; } \
  70. private:                                                                            \
  71.         ActionName() {}                                                                                                     \
  72.     friend class FlashActionVectorImporter;                        \
  73.     char *data;                                                                \
  74.         gc_vector<char *> garbage; \
  75. };
  76. //ACTION WITH BYTE PARAM
  77. #define DECLARE_SIMPLE_ACTION_CLASS4(ActionName, ActionID, pName)    \
  78. class ActionName : public FlashActionRecord                            \
  79. {                                                                    \
  80. public:                                                                \
  81.     ActionName(char pName) : data(pName) { m_code=ActionID; }        \
  82.         virtual ~ActionName() {}                                                                                                \
  83.     virtual void Write(std::ostream &out) { WriteHeader(out,1);        \
  84.                                             out.put(data); }            \
  85.     char Get##pName() { return data; }                                \
  86.     virtual void Read(std::istream &in) { ReadHeader(in); data=in.get(); } \
  87. private:                                                            \
  88.     ActionName() {}                                                    \
  89.     friend class FlashActionVectorImporter;                        \
  90.     char data;                                                        \
  91. };
  92.  
  93. /* FLASH 3.0 SIMPLE ACTIONS */
  94. DECLARE_SIMPLE_ACTION_CLASS(FlashActionNextFrame,0x04);
  95. DECLARE_SIMPLE_ACTION_CLASS(FlashActionPreviousFrame,0x05);
  96. DECLARE_SIMPLE_ACTION_CLASS(FlashActionPlay,0x06);
  97. DECLARE_SIMPLE_ACTION_CLASS(FlashActionStop,0x07);
  98. DECLARE_SIMPLE_ACTION_CLASS(FlashActionToggleQuality,0x08);
  99. DECLARE_SIMPLE_ACTION_CLASS(FlashActionStopSounds,0x09);
  100. DECLARE_SIMPLE_ACTION_CLASS2(FlashActionGotoFrame,0x81,frame);
  101. DECLARE_SIMPLE_ACTION_CLASS3(FlashActionSetTarget,0x8B,target);
  102. DECLARE_SIMPLE_ACTION_CLASS3(FlashActionGotoLabel,0x8C,label);
  103.  
  104. /* FLASH 3.0 COMPLEX ACTIONS */
  105. class FlashActionGetURL : public FlashActionRecord                                            
  106. {                                                                                    
  107. public:
  108.     FlashActionGetURL(char *url, char *target) : data1(url), data2(target) { m_code=0x83; }
  109.         virtual ~FlashActionGetURL() 
  110.     { 
  111.     }
  112.  
  113.     
  114.     virtual void Write(std::ostream &out) { WriteHeader(out,strlen(data1)+strlen(data2)+2);
  115.                                             out << data1; out.put((char)0);
  116.                                             out << data2; out.put((char)0);}
  117.     
  118.     const char *GetURL(void) { return data1; }
  119.     const char *GetTarget(void) { return data2; }
  120.  
  121.     virtual void Read(std::istream &in) 
  122.     {    
  123.         ReadHeader(in);
  124.         std::vector<char> str; 
  125.         unsigned int i;    
  126.         while((i  = in.get()) != 0)    
  127.         { 
  128.             str.push_back((char)i); 
  129.         } 
  130.         data1 = (char*)malloc(str.size()+1); 
  131.         i=0; 
  132.         for(;i < str.size(); i++) 
  133.         { 
  134.             data1[i]=str[i]; 
  135.         }     
  136.         data1[i]=0; 
  137.         
  138.         std::vector<char> str2; 
  139.         unsigned int i2;
  140.         while((i2 = in.get()) != 0)    
  141.         { 
  142.             str2.push_back((char)i2); 
  143.         } 
  144.         data2 = (char*)malloc(str2.size()+1); 
  145.         i2=0; 
  146.         for(;i2 < str2.size(); i2++) 
  147.         { 
  148.             data2[i2]=str2[i2]; 
  149.         }     
  150.         data2[i2]=0;
  151.         gcstrings.push_back(data1);
  152.         gcstrings.push_back(data2);
  153.     }
  154. private:
  155.     gc_vector<char *> gcstrings;
  156.     FlashActionGetURL() {}                                                    
  157.     friend class FlashActionVectorImporter;                        
  158.     char *data1;
  159.     char *data2;
  160. };
  161.  
  162. class FlashActionWaitForFrame : public FlashActionRecord                                            
  163. {                                                                                    
  164.     FlashActionWaitForFrame(SWORD frame, char skipcount) : data1(frame), data2(skipcount) { m_code=0x8A; }                    
  165.         virtual ~FlashActionWaitForFrame() {}                                                                                                                            
  166.     virtual void Write(std::ostream &out) { WriteHeader(out,3);
  167.                                             WRITE_SWORD(data1);
  168.                                             out.put((char)data2);}
  169.     virtual void Read(std::istream &in) { ReadHeader(in); READ_SWORD(data1); data2 = in.get(); }
  170.     SWORD GetFrame(void) { return data1; }
  171.     char GetSkipCount(void) { return data2; }
  172. private:    
  173.     FlashActionWaitForFrame() {}
  174.     friend class FlashActionVectorImporter;
  175.  
  176.     SWORD data1;
  177.     char data2;
  178. };
  179.  
  180. /* FLASH 4.0 SIMPLE ACTIONS */
  181. DECLARE_SIMPLE_ACTION_CLASS(FlashActionAdd,0x0A);
  182. DECLARE_SIMPLE_ACTION_CLASS(FlashActionSubtract,0x0B);
  183. DECLARE_SIMPLE_ACTION_CLASS(FlashActionMultiply,0x0C);
  184. DECLARE_SIMPLE_ACTION_CLASS(FlashActionDivide,0x0D);
  185. DECLARE_SIMPLE_ACTION_CLASS(FlashActionEquals,0x0E);
  186. DECLARE_SIMPLE_ACTION_CLASS(FlashActionLess,0x0F);
  187. DECLARE_SIMPLE_ACTION_CLASS(FlashActionAnd,0x10);
  188. DECLARE_SIMPLE_ACTION_CLASS(FlashActionOr,0x11);
  189. DECLARE_SIMPLE_ACTION_CLASS(FlashActionNot,0x12);
  190. DECLARE_SIMPLE_ACTION_CLASS(FlashActionStringEquals,0x13);
  191. DECLARE_SIMPLE_ACTION_CLASS(FlashActionStringLength,0x14);
  192. DECLARE_SIMPLE_ACTION_CLASS(FlashActionStringExtract,0x15);
  193. DECLARE_SIMPLE_ACTION_CLASS(FlashActionPop,0x17);
  194. DECLARE_SIMPLE_ACTION_CLASS(FlashActionToInteger,0x18);
  195. DECLARE_SIMPLE_ACTION_CLASS(FlashActionGetVariable,0x1C);
  196. DECLARE_SIMPLE_ACTION_CLASS(FlashActionSetVariable,0x1D);
  197. DECLARE_SIMPLE_ACTION_CLASS(FlashActionSetTarget2,0x20);
  198. DECLARE_SIMPLE_ACTION_CLASS(FlashActionGetProperty,0x22);
  199. DECLARE_SIMPLE_ACTION_CLASS(FlashActionSetProperty,0x23);
  200. DECLARE_SIMPLE_ACTION_CLASS(FlashActionCloneSprite,0x24);
  201. DECLARE_SIMPLE_ACTION_CLASS(FlashActionRemoveSprite,0x25);
  202. DECLARE_SIMPLE_ACTION_CLASS(FlashActionTrace,0x26);
  203. DECLARE_SIMPLE_ACTION_CLASS(FlashActionStartDrag,0x27);
  204. DECLARE_SIMPLE_ACTION_CLASS(FlashActionEndDrag,0x28);
  205. DECLARE_SIMPLE_ACTION_CLASS(FlashActionStringAdd,0x21);
  206. DECLARE_SIMPLE_ACTION_CLASS(FlashActionStringLess,0x29);
  207. DECLARE_SIMPLE_ACTION_CLASS(FlashActionRandomNumber,0x30);
  208. DECLARE_SIMPLE_ACTION_CLASS(FlashActionMBStringLength,0x31);
  209. DECLARE_SIMPLE_ACTION_CLASS(FlashActionCharToAscii,0x32);
  210. DECLARE_SIMPLE_ACTION_CLASS(FlashActionAsciiToChar,0x33);
  211. DECLARE_SIMPLE_ACTION_CLASS(FlashActionGetTime,0x34);
  212. DECLARE_SIMPLE_ACTION_CLASS(FlashActionMBCharToAscii,0x36);
  213. DECLARE_SIMPLE_ACTION_CLASS(FlashActionMBStringExtract,0x35);
  214. DECLARE_SIMPLE_ACTION_CLASS(FlashActionMBAsciToChar,0x37);
  215. DECLARE_SIMPLE_ACTION_CLASS4(FlashActionWaitForFrame2,0x8D, skipcount);
  216. DECLARE_SIMPLE_ACTION_CLASS2(FlashActionJump,0x99,offset);
  217. DECLARE_SIMPLE_ACTION_CLASS4(FlashActionGetURL2,0x9A,method);
  218. DECLARE_SIMPLE_ACTION_CLASS2(FlashActionIf,0x9D,offset);
  219. DECLARE_SIMPLE_ACTION_CLASS(FlashActionCall,0x9E);
  220. DECLARE_SIMPLE_ACTION_CLASS4(FlashActionGotoFrame2,0x9F,play);
  221.  
  222. /* FLASH 4.0 COMPLEX ACTIONS */
  223. class FlashActionPush : public FlashActionRecord
  224. {
  225. public:
  226.     FlashActionPush(char _type, char *_data, UWORD _len) : type(_type), data(_data), len(_len) { m_code = 0x96;}
  227.         virtual ~FlashActionPush() { }
  228.  
  229.     virtual void Write(std::ostream &out);
  230.     virtual void Read(std::istream &in);
  231.  
  232.     char GetType() { return type; }
  233.     virtual UWORD GetDataSize() { return len; }
  234.     virtual const char *GetData() { return data; }
  235. protected:
  236.     FlashActionPush() {};
  237. private:
  238.     friend class FlashActionVectorImporter;
  239.     gc_vector<char*> gcstrings;
  240.     char type;
  241.     char *data;
  242.     UWORD len;
  243. };
  244.  
  245.  
  246. /* FLASH 5.0 SIMPLE ACTIONS */
  247. DECLARE_SIMPLE_ACTION_CLASS(FlashActionDelete,0x3a);
  248. DECLARE_SIMPLE_ACTION_CLASS(FlashActionDelete2,0x3b);
  249. DECLARE_SIMPLE_ACTION_CLASS(FlashActionDefineLocal,0x3c);
  250. DECLARE_SIMPLE_ACTION_CLASS(FlashActionCallFunction,0x3d);
  251. DECLARE_SIMPLE_ACTION_CLASS(FlashActionReturn,0x3e);
  252. DECLARE_SIMPLE_ACTION_CLASS(FlashActionModulo,0x3f);
  253. DECLARE_SIMPLE_ACTION_CLASS(FlashActionNewObject,0x40);
  254. DECLARE_SIMPLE_ACTION_CLASS(FlashActionDefineLocal2,0x41);
  255. DECLARE_SIMPLE_ACTION_CLASS(FlashActionInitArray,0x42);
  256. DECLARE_SIMPLE_ACTION_CLASS(FlashActionInitObject,0x42);
  257. DECLARE_SIMPLE_ACTION_CLASS(FlashActionTypeOf,0x44);
  258. DECLARE_SIMPLE_ACTION_CLASS(FlashActionTargetPath,0x45);
  259. DECLARE_SIMPLE_ACTION_CLASS(FlashActionEnumerate,0x46);
  260. DECLARE_SIMPLE_ACTION_CLASS(FlashActionAdd2,0x47);
  261. DECLARE_SIMPLE_ACTION_CLASS(FlashActionLess2,0x48);
  262. DECLARE_SIMPLE_ACTION_CLASS(FlashActionEquals2,0x49);
  263. DECLARE_SIMPLE_ACTION_CLASS(FlashActionToNumber,0x4a);
  264. DECLARE_SIMPLE_ACTION_CLASS(FlashActionToString,0x4b);
  265. DECLARE_SIMPLE_ACTION_CLASS(FlashActionPushDuplicate,0x4c);
  266. DECLARE_SIMPLE_ACTION_CLASS(FlashActionStackSwap,0x4d);
  267. DECLARE_SIMPLE_ACTION_CLASS(FlashActionGetMember,0x4e);
  268. DECLARE_SIMPLE_ACTION_CLASS(FlashActionSetMember,0x4f);
  269. DECLARE_SIMPLE_ACTION_CLASS(FlashActionIncrement,0x50);
  270. DECLARE_SIMPLE_ACTION_CLASS(FlashActionDecrement,0x51);
  271. DECLARE_SIMPLE_ACTION_CLASS(FlashActionCallMethod,0x52);
  272. DECLARE_SIMPLE_ACTION_CLASS(FlashActionNewMethod,0x53);
  273. DECLARE_SIMPLE_ACTION_CLASS(FlashActionBitAnd,0x60);
  274. DECLARE_SIMPLE_ACTION_CLASS(FlashActionBitOr,0x61);
  275. DECLARE_SIMPLE_ACTION_CLASS(FlashActionBitXor,0x62);
  276. DECLARE_SIMPLE_ACTION_CLASS(FlashActionBitLShift,0x63);
  277. DECLARE_SIMPLE_ACTION_CLASS(FlashActionBitRShift,0x64);
  278. DECLARE_SIMPLE_ACTION_CLASS(FlashActionBitURShift,0x65);
  279. DECLARE_SIMPLE_ACTION_CLASS4(FlashActionStoreRegister,0x87,registernumber);
  280.  
  281. /* FLASH 5.0 COMPLEX ACTIONS */
  282.  
  283. class FlashActionDefineFunction : public FlashActionRecord
  284. {
  285. public:    
  286.     FlashActionDefineFunction(char *function ...); 
  287.         // Function Name, Arg1, Arg2, ... Arg n
  288.         virtual ~FlashActionDefineFunction();
  289.     
  290.     virtual void Write(std::ostream &out);
  291.     virtual void Read(std::istream &in);
  292.  
  293.     void AddAction(FlashActionRecord *r);
  294. private:
  295.     FlashActionDefineFunction() {}
  296.  
  297.     friend class FlashActionVectorImporter;
  298.     char *m_functionName;
  299.     UWORD m_numParams;    
  300.     std::vector<char *> m_paramNames;
  301.     std::vector<FlashActionRecord *> m_actions;
  302.     gc_vector<char *> m_gcstrings;
  303.     gc_vector<FlashActionRecord *> records_delete;
  304. };
  305.  
  306. class FlashActionWith : public FlashActionRecord
  307. {
  308. public:    
  309.     FlashActionWith() {}
  310.         virtual ~FlashActionWith() { }
  311.     
  312.     virtual void Write(std::ostream &out);
  313.     virtual void Read(std::istream &in);
  314.  
  315.     void AddAction(FlashActionRecord *r);
  316. private:
  317.     std::vector<FlashActionRecord *> m_actions;
  318.     gc_vector<FlashActionRecord *> records_delete;
  319. };
  320.  
  321. class FlashActionConstantPool : public FlashActionRecord
  322. {
  323. public:
  324.     FlashActionConstantPool(char *c ...);
  325.         virtual ~FlashActionConstantPool() {}
  326.  
  327.     virtual void Write(std::ostream &out);
  328.     virtual void Read(std::istream &in);
  329.  
  330. private:
  331.     FlashActionConstantPool() {}
  332.     friend class FlashActionVectorImporter;
  333.     int m_length;
  334.     std::vector<char *>m_strings;
  335.     gc_vector<char *>m_gcstrings;
  336. };
  337.  
  338. /* Do Action Tag */
  339. class FlashTagDoAction : public FlashSpriteEnabled
  340. {
  341. DEFINE_RW_INTERFACE
  342. public:
  343.     FlashTagDoAction() {}
  344.         virtual ~FlashTagDoAction();
  345.  
  346.     UWORD GetNumActions() { return records.size(); }
  347.     FlashActionRecord *GetAction(UWORD pos) { return records[pos]; }
  348.  
  349.     void AddAction(FlashActionRecord *r);
  350.  
  351.     friend std::ostream &operator<< (std::ostream &out, FlashTagDoAction &data);
  352.     friend std::istream &operator>> (std::istream &in,  FlashTagDoAction &data);
  353.  
  354. private:
  355.     std::vector<FlashActionRecord *> records;
  356.     gc_vector<FlashActionRecord *> records_delete;
  357. };
  358.  
  359. class FlashActionVectorImporter
  360. {
  361. public:
  362.     FlashActionVectorImporter() {}
  363.         virtual ~FlashActionVectorImporter() {}
  364.  
  365.     void Import(std::istream &in, std::vector<FlashActionRecord *> &v, gc_vector<FlashActionRecord*> &d);
  366.     void Import(std::istream &in, std::vector<FlashActionRecord *> &v, gc_vector<FlashActionRecord*> &d, UDWORD num_actions);
  367. private:
  368. };
  369. #endif  // FACTION_H_FILE
  370.  
  371.