KSGSKlasse.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471
  1. #include "KSGSKlasse.h"
  2. #include "../Error/Error.h"
  3. #include "../Main/KSGScriptObj.h"
  4. #include "../Klassen/KSGSTyp.h"
  5. #include "../Klassen/KSGSBool.h"
  6. #include "../Klassen/KSGSInt.h"
  7. #include "../Klassen/KSGSDouble.h"
  8. #include "../Klassen/KSGSText.h"
  9. #include "../Klassen/KSGSBild.h"
  10. #include "../Klassen/KSGSMausEreignis.h"
  11. #include "../Klassen/KSGSTastaturEreignis.h"
  12. #include "../Klassen/KSGSTextFeld.h"
  13. #include "../Klassen/KSGSKnopf.h"
  14. #include "../Klassen/KSGSFenster.h"
  15. #include "../Klassen/KSGSBildZ.h"
  16. #include "../Klassen/KSGSAnimation2DData.h"
  17. #include "../Klassen/KSGSAnimation2D.h"
  18. #include "../Klassen/KSGSArray.h"
  19. using namespace KSGScript;
  20. // Inhalt der KSGSKlasseInstanz Klasse aus KSGSKlasse.h
  21. // Konstruktor
  22. KSGSKlasseInstanz::KSGSKlasseInstanz( int typ, Array< KSGSVariableDef * > *zVars, RCArray< KSGSFunktion > *funcs, KSGScriptProcessor *zObj )
  23. : ReferenceCounter()
  24. {
  25. lokaleVariablen = new RCArray< KSGSVariable >();
  26. varPublic = new Array< bool >();
  27. funktionen = funcs;
  28. obj = zObj;
  29. lokaleVariablen->add( dynamic_cast<KSGSKlasseInstanz *>( getThis() ), 0 );
  30. varPublic->set( 0, 0 );
  31. int anz = zVars ? zVars->getEintragAnzahl() : 0;
  32. for( int i = 0; i < anz; i++ )
  33. {
  34. lokaleVariablen->set( KSGSKlasseInstanz::erstellVariable( zObj, zVars->get( i ) ), zVars->get( i )->id + 1 );
  35. varPublic->set( zVars->get( i )->sichtbar == 1, zVars->get( i )->id + 1 );
  36. }
  37. this->typ = typ;
  38. }
  39. // Destruktor
  40. KSGSKlasseInstanz::~KSGSKlasseInstanz()
  41. {
  42. lokaleVariablen->release();
  43. if( funktionen )
  44. funktionen->release();
  45. varPublic->release();
  46. }
  47. // nicht constant
  48. KSGSVariable *KSGSKlasseInstanz::startFunktion( int id, bool zugriff, RCArray< KSGSVariable > *parameter )
  49. {
  50. if( !funktionen || ( !zugriff && ( !funktionen->z( id ) || funktionen->z( id )->getSichtbarkeit() != 1 ) ) )
  51. {
  52. error( 18, {}, obj );
  53. parameter->release();
  54. return 0;
  55. }
  56. if( !funktionen->z( id ) )
  57. {
  58. parameter->release();
  59. return 0;
  60. }
  61. KSGSFunktionInstanz *inst = funktionen->z( id )->erstellInstanz( obj, dynamic_cast<KSGSKlasseInstanz *>( getThis() ), parameter );
  62. KSGSVariable *ret = inst->startFunktion();
  63. inst->release();
  64. return ret;
  65. }
  66. KSGSVariable *KSGSKlasseInstanz::doOperator( int id, KSGSVariable *rechts )
  67. {
  68. error( 21, {}, obj );
  69. if( rechts )
  70. rechts->release();
  71. return 0;
  72. }
  73. void KSGSKlasseInstanz::setVariable( int id, KSGSVariable *var )
  74. {
  75. lokaleVariablen->set( var, id );
  76. }
  77. // constant
  78. KSGSVariable *KSGSKlasseInstanz::getVariable( int id, bool zugriff ) const
  79. {
  80. if( !zugriff && ( !varPublic->hat( id ) || !varPublic->get( id ) ) )
  81. {
  82. error( 17, {}, obj );
  83. return 0;
  84. }
  85. return lokaleVariablen->get( id );
  86. }
  87. KSGSVariable *KSGSKlasseInstanz::umwandelnIn( int typ ) const
  88. {
  89. error( 16, {}, obj );
  90. return 0;
  91. }
  92. int KSGSKlasseInstanz::getTyp() const
  93. {
  94. return typ;
  95. }
  96. // verarbeiten
  97. bool KSGSKlasseInstanz::getBool() const
  98. {
  99. if( typ == KSGS_BOOL )
  100. return ( (KSGSBoolKlasse *)this )->getVal();
  101. else
  102. {
  103. KSGSBoolKlasse *tmp = (KSGSBoolKlasse *)umwandelnIn( KSGS_BOOL );
  104. if( tmp )
  105. {
  106. bool ret = tmp->getVal();
  107. tmp->release();
  108. return ret;
  109. }
  110. return 0;
  111. }
  112. }
  113. int KSGSKlasseInstanz::getInt() const
  114. {
  115. if( typ == KSGS_INT )
  116. return ( (KSGSIntKlasse *)this )->getVal();
  117. else
  118. {
  119. KSGSIntKlasse *tmp = (KSGSIntKlasse *)umwandelnIn( KSGS_INT );
  120. if( tmp )
  121. {
  122. int ret = tmp->getVal();
  123. tmp->release();
  124. return ret;
  125. }
  126. return 0;
  127. }
  128. }
  129. double KSGSKlasseInstanz::getDouble() const
  130. {
  131. if( typ == KSGS_DOUBLE )
  132. return ( (KSGSDoubleKlasse *)this )->getVal();
  133. else
  134. {
  135. KSGSDoubleKlasse *tmp = (KSGSDoubleKlasse *)umwandelnIn( KSGS_DOUBLE );
  136. if( tmp )
  137. {
  138. double ret = tmp->getVal();
  139. tmp->release();
  140. return ret;
  141. }
  142. return 0;
  143. }
  144. }
  145. Text *KSGSKlasseInstanz::getText() const
  146. {
  147. if( typ == KSGS_TEXT )
  148. return ( (KSGSTextKlasse *)this )->getVal();
  149. else
  150. {
  151. KSGSTextKlasse *tmp = (KSGSTextKlasse *)umwandelnIn( KSGS_TEXT );
  152. if( tmp )
  153. {
  154. Text *ret = tmp->getVal();
  155. tmp->release();
  156. return ret;
  157. }
  158. return new Text( "" );
  159. }
  160. }
  161. Bild *KSGSKlasseInstanz::getBild() const
  162. {
  163. if( typ == KSGS_BILD )
  164. return ( (KSGSBildKlasse *)this )->getVal();
  165. else
  166. {
  167. KSGSBildKlasse *tmp = (KSGSBildKlasse *)umwandelnIn( KSGS_BILD );
  168. if( tmp )
  169. {
  170. Bild *ret = tmp->getVal();
  171. tmp->release();
  172. return ret;
  173. }
  174. return new Bild();
  175. }
  176. }
  177. MausEreignis KSGSKlasseInstanz::getMausEreignis() const
  178. {
  179. if( typ == KSGS_MAUSEREIGNIS )
  180. return ( (KSGSMausEreignisKlasse *)this )->getVal();
  181. else
  182. {
  183. KSGSMausEreignisKlasse *tmp = (KSGSMausEreignisKlasse *)umwandelnIn( KSGS_MAUSEREIGNIS );
  184. if( tmp )
  185. {
  186. MausEreignis ret = tmp->getVal();
  187. tmp->release();
  188. return ret;
  189. }
  190. return MausEreignis{ 0, 0, 0, 0, 1, 0, 0 };
  191. }
  192. }
  193. TastaturEreignis KSGSKlasseInstanz::getTastaturEreignis() const
  194. {
  195. if( typ == KSGS_TASTATUREREIGNIS )
  196. return ( (KSGSTastaturEreignisKlasse *)this )->getVal();
  197. else
  198. {
  199. KSGSTastaturEreignisKlasse *tmp = (KSGSTastaturEreignisKlasse *)umwandelnIn( KSGS_TASTATUREREIGNIS );
  200. if( tmp )
  201. {
  202. TastaturEreignis ret = tmp->getVal();
  203. tmp->release();
  204. return ret;
  205. }
  206. return TastaturEreignis{ 0, 0, 0 };
  207. }
  208. }
  209. TextFeld *KSGSKlasseInstanz::getTextFeld() const
  210. {
  211. if( typ == KSGS_TEXTFELD )
  212. return ( (KSGSTextFeldKlasse *)this )->getVal();
  213. else
  214. {
  215. KSGSTextFeldKlasse *tmp = (KSGSTextFeldKlasse *)umwandelnIn( KSGS_TEXTFELD );
  216. if( tmp )
  217. {
  218. TextFeld *ret = tmp->getVal();
  219. tmp->release();
  220. return ret;
  221. }
  222. return new TextFeld();
  223. }
  224. }
  225. Knopf *KSGSKlasseInstanz::getKnopf() const
  226. {
  227. if( typ == KSGS_KNOPF )
  228. return ( (KSGSKnopfKlasse *)this )->getVal();
  229. else
  230. {
  231. KSGSKnopfKlasse *tmp = (KSGSKnopfKlasse *)umwandelnIn( KSGS_KNOPF );
  232. if( tmp )
  233. {
  234. Knopf *ret = tmp->getVal();
  235. tmp->release();
  236. return ret;
  237. }
  238. return new Knopf();
  239. }
  240. }
  241. Fenster *KSGSKlasseInstanz::getFenster() const
  242. {
  243. if( typ == KSGS_FENSTER )
  244. return ( (KSGSFensterKlasse *)this )->getVal();
  245. else
  246. {
  247. KSGSFensterKlasse *tmp = (KSGSFensterKlasse *)umwandelnIn( KSGS_FENSTER );
  248. if( tmp )
  249. {
  250. Fenster *ret = tmp->getVal();
  251. tmp->release();
  252. return ret;
  253. }
  254. return new Fenster();
  255. }
  256. }
  257. BildZ *KSGSKlasseInstanz::getBildZ() const
  258. {
  259. if( typ == KSGS_BILDO )
  260. return ( (KSGSBildZKlasse *)this )->getVal();
  261. else
  262. {
  263. KSGSBildZKlasse *tmp = (KSGSBildZKlasse *)umwandelnIn( KSGS_BILDO );
  264. if( tmp )
  265. {
  266. BildZ *ret = tmp->getVal();
  267. tmp->release();
  268. return ret;
  269. }
  270. return new BildZ();
  271. }
  272. }
  273. Animation2DData *KSGSKlasseInstanz::getAnimation2DData() const
  274. {
  275. if( typ == KSGS_ANIMATION2DDATA )
  276. return ( (KSGSAnimation2DDataKlasse *)this )->getVal();
  277. else
  278. {
  279. KSGSAnimation2DDataKlasse *tmp = (KSGSAnimation2DDataKlasse *)umwandelnIn( KSGS_ANIMATION2DDATA );
  280. if( tmp )
  281. {
  282. Animation2DData *ret = tmp->getVal();
  283. tmp->release();
  284. return ret;
  285. }
  286. return new Animation2DData();
  287. }
  288. }
  289. Animation2D *KSGSKlasseInstanz::getAnimation2D() const
  290. {
  291. if( typ == KSGS_ANIMATION2D )
  292. return ( (KSGSAnimation2DKlasse *)this )->getVal();
  293. else
  294. {
  295. KSGSAnimation2DKlasse *tmp = (KSGSAnimation2DKlasse *)umwandelnIn( KSGS_ANIMATION2D );
  296. if( tmp )
  297. {
  298. Animation2D *ret = tmp->getVal();
  299. tmp->release();
  300. return ret;
  301. }
  302. return new Animation2D();
  303. }
  304. }
  305. Zeichnung *KSGSKlasseInstanz::getZeichnung() const
  306. {
  307. switch( typ )
  308. {
  309. case KSGS_TEXTFELD:
  310. return ( (KSGSTextFeldKlasse *)this )->zVal();
  311. case KSGS_KNOPF:
  312. return ( (KSGSKnopfKlasse *)this )->zVal();
  313. case KSGS_FENSTER:
  314. return ( (KSGSFensterKlasse *)this )->zVal();
  315. case KSGS_BILDO:
  316. return ( (KSGSBildZKlasse *)this )->zVal();
  317. case KSGS_ANIMATION2D:
  318. return ( (KSGSAnimation2DKlasse *)this )->zVal();
  319. }
  320. return 0;
  321. }
  322. RCArray< KSGSVariable > *KSGSKlasseInstanz::getArray() const
  323. {
  324. if( typ == KSGS_ARRAY )
  325. return ( (KSGSArrayKlasse *)this )->getVal();
  326. else
  327. {
  328. KSGSArrayKlasse *tmp = (KSGSArrayKlasse *)umwandelnIn( KSGS_ARRAY );
  329. if( tmp )
  330. {
  331. RCArray< KSGSVariable > *ret = tmp->getVal();
  332. tmp->release();
  333. return ret;
  334. }
  335. return new RCArray< KSGSVariable >();
  336. }
  337. }
  338. // static
  339. KSGSVariable *KSGSKlasseInstanz::erstellVariable( KSGScriptProcessor *zObj, KSGSVariableDef *def )
  340. {
  341. if( !def )
  342. {
  343. error( 0, {}, zObj );
  344. return 0;
  345. }
  346. if( def->typId < KSGS_TYP_MIN )
  347. {
  348. error( 0, {}, zObj );
  349. return 0;
  350. }
  351. if( def->typId <= KSGS_TYP_MAX )
  352. { // Vordefinierter Typ
  353. switch( def->typId )
  354. {
  355. case KSGS_BOOL:
  356. if( def->wert.istGleich( "true" ) )
  357. return new KSGSBoolKlasse( zObj, 1 );
  358. if( def->wert.istGleich( "false" ) )
  359. return new KSGSBoolKlasse( zObj, 0 );
  360. if( def->wert.getLength() )
  361. return new KSGSBoolKlasse( zObj, (int)def->wert != 0 );
  362. return new KSGSBoolKlasse( zObj );
  363. case KSGS_INT:
  364. if( def->wert.getLength() )
  365. return new KSGSIntKlasse( zObj, def->wert );
  366. return new KSGSIntKlasse( zObj );
  367. case KSGS_DOUBLE:
  368. if( def->wert.getLength() )
  369. return new KSGSDoubleKlasse( zObj, def->wert );
  370. return new KSGSDoubleKlasse( zObj );
  371. case KSGS_TEXT:
  372. if( def->wert.getLength() )
  373. return new KSGSTextKlasse( zObj, def->wert );
  374. return new KSGSTextKlasse( zObj );
  375. case KSGS_BILD:
  376. return new KSGSBildKlasse( zObj );
  377. case KSGS_MAUSEREIGNIS:
  378. return new KSGSMausEreignisKlasse( zObj );
  379. case KSGS_TASTATUREREIGNIS:
  380. return new KSGSTastaturEreignisKlasse( zObj );
  381. case KSGS_TEXTFELD:
  382. return new KSGSTextFeldKlasse( zObj );
  383. case KSGS_KNOPF:
  384. return new KSGSKnopfKlasse( zObj );
  385. case KSGS_FENSTER:
  386. return new KSGSFensterKlasse( zObj );
  387. case KSGS_BILDO:
  388. return new KSGSBildZKlasse( zObj );
  389. case KSGS_ANIMATION2DDATA:
  390. return new KSGSAnimation2DDataKlasse( zObj );
  391. case KSGS_ANIMATION2D:
  392. return new KSGSAnimation2DKlasse( zObj );
  393. default:
  394. error( 1, {}, zObj );
  395. break;
  396. }
  397. return 0;
  398. }
  399. else if( zObj ) // Im Script Definierter Typ
  400. return zObj->erstellKlassenInstanz( def->typId );
  401. error( 0, {}, zObj );
  402. return 0;
  403. }
  404. // Inhalt der KSGSKlasse Klasse aus KSGSKlasse.h
  405. // Konstruktor
  406. KSGSKlasse::KSGSKlasse( int id )
  407. : ReferenceCounter()
  408. {
  409. var = new Array< KSGSVariableDef * >();
  410. funktionen = new RCArray< KSGSFunktion >();
  411. this->id = id;
  412. }
  413. // Destruktor
  414. KSGSKlasse::~KSGSKlasse()
  415. {
  416. int anz = var->getEintragAnzahl();
  417. for( int i = 0; i < anz; i++ )
  418. delete var->get( i );
  419. var->release();
  420. funktionen->release();
  421. }
  422. // nicht constant
  423. void KSGSKlasse::addVariable( KSGSVariableDef *var )
  424. {
  425. this->var->add( var );
  426. }
  427. void KSGSKlasse::addFunktion( KSGSFunktion *func )
  428. {
  429. funktionen->add( func );
  430. }
  431. KSGSKlasseInstanz *KSGSKlasse::erstellInstanz( KSGScriptProcessor *zObj )
  432. {
  433. return new KSGSKlasseInstanz( id, var, dynamic_cast<RCArray<KSGSFunktion>*>( funktionen->getThis() ), zObj );
  434. }
  435. // constant
  436. int KSGSKlasse::getId() const
  437. {
  438. return id;
  439. }