KEDModel2DEditor.cpp 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224
  1. #include "KEDModel2DEditor.h"
  2. #include <Rahmen.h>
  3. #include <MausEreignis.h>
  4. #include <Text.h>
  5. #include <Schrift.h>
  6. #include <Scroll.h>
  7. #include <Globals.h>
  8. #include <TastaturEreignis.h>
  9. #include "../../../../Global/Initialisierung.h"
  10. #include "../../../../Global/Variablen.h"
  11. using namespace Model2DEditor;
  12. // Inhalt der VertexData Klasse aus KEDModel2DEditor.h
  13. // Konstruktor
  14. VertexData::VertexData( Vec2< float > v, Vertex t )
  15. {
  16. vertex = v;
  17. textur = t;
  18. selected = 0;
  19. sichtbar = 1;
  20. ref = 1;
  21. }
  22. // nicht constant
  23. void VertexData::nachLinks( float num )
  24. {
  25. if( selected )
  26. vertex.x -= num;
  27. }
  28. void VertexData::nachOben( float num )
  29. {
  30. if( selected )
  31. vertex.y -= num;
  32. }
  33. void VertexData::setTextur( Vertex tp )
  34. {
  35. textur = tp;
  36. }
  37. void VertexData::setPosition( Vertex p )
  38. {
  39. vertex = p;
  40. }
  41. void VertexData::saveTextur( Punkt tPos, Punkt tGr )
  42. {
  43. textur = vertex - tPos;
  44. textur.x /= tGr.x;
  45. textur.y /= tGr.y;
  46. }
  47. void VertexData::select( Punkt p1, Punkt p2 )
  48. {
  49. selected |= vertex.istInRegion( p1, p2 ) && sichtbar;
  50. }
  51. void VertexData::deSelect()
  52. {
  53. selected = 0;
  54. }
  55. void VertexData::setAuswahl( bool ausw )
  56. {
  57. selected = ausw;
  58. }
  59. void VertexData::setSichtbar( bool s )
  60. {
  61. sichtbar = s;
  62. selected &= sichtbar;
  63. }
  64. // constant
  65. bool VertexData::istSichtbar() const
  66. {
  67. return sichtbar;
  68. }
  69. bool VertexData::istAusgewählt() const
  70. {
  71. return selected;
  72. }
  73. Vec2< float > VertexData::getPos() const
  74. {
  75. return vertex;
  76. }
  77. Vertex VertexData::getTPos() const
  78. {
  79. return textur;
  80. }
  81. // Reference Counting
  82. VertexData *VertexData::getThis()
  83. {
  84. ref++;
  85. return this;
  86. }
  87. VertexData *VertexData::release()
  88. {
  89. ref--;
  90. if( !ref )
  91. delete this;
  92. return 0;
  93. }
  94. // Inhalt der PolygonData Klasse aus KEDModel2DEditor.h
  95. // Konstruktor
  96. PolygonData::PolygonData( Polygon2D & pg )
  97. {
  98. name = pg.name->getText();
  99. vd = new RCArray< VertexData >();
  100. transparent = pg.transparent;
  101. sichtbar = 1;
  102. ref = 1;
  103. int anz = pg.vertex->getEintragAnzahl();
  104. for( int i = 0; i < anz; i++ )
  105. {
  106. Vec2< float > v( 0, 0 );
  107. Vertex t( 0, 0 );
  108. if( pg.vertex->hat( i ) )
  109. v = pg.vertex->get( i );
  110. if( pg.tKordinaten &&pg.tKordinaten->hat( i ) )
  111. t = pg.tKordinaten->get( i );
  112. vd->add( new VertexData( v, t ) );
  113. }
  114. }
  115. // Destruktor
  116. PolygonData::~PolygonData()
  117. {
  118. vd->release();
  119. }
  120. // nicht constant
  121. void PolygonData::addVertex( Vec2< float >v, Vertex t )
  122. {
  123. vd->add( new VertexData( v, t ) );
  124. }
  125. void PolygonData::removeVertex( int num )
  126. {
  127. vd->remove( num );
  128. }
  129. void PolygonData::nachLinks( float num )
  130. {
  131. for( auto i = vd->getIterator(); i; i++ )
  132. i->nachLinks( num );
  133. }
  134. void PolygonData::nachOben( float num )
  135. {
  136. for( auto i = vd->getIterator(); i; i++ )
  137. i->nachOben( num );
  138. }
  139. void PolygonData::saveTextur( Punkt tPos, Punkt tGr )
  140. {
  141. for( auto i = vd->getIterator(); i; i++ )
  142. i->saveTextur( tPos, tGr );
  143. }
  144. void PolygonData::select( Punkt p1, Punkt p2 )
  145. {
  146. for( auto i = vd->getIterator(); i; i++ )
  147. i->select( p1, p2 );
  148. }
  149. void PolygonData::deSelect()
  150. {
  151. for( auto i = vd->getIterator(); i; i++ )
  152. i->deSelect();
  153. }
  154. void PolygonData::setSichtbar( bool s )
  155. {
  156. sichtbar = s;
  157. }
  158. void PolygonData::setTransparent( bool t )
  159. {
  160. transparent = t;
  161. }
  162. void PolygonData::setName( const char *name )
  163. {
  164. this->name = name;
  165. }
  166. // constant
  167. const char *PolygonData::getName() const
  168. {
  169. return name;
  170. }
  171. bool PolygonData::istSichtbar() const
  172. {
  173. return sichtbar;
  174. }
  175. VertexData *PolygonData::zVertex( int num ) const
  176. {
  177. return vd->z( num );
  178. }
  179. int PolygonData::getVertexAnzahl() const
  180. {
  181. return vd->getEintragAnzahl();
  182. }
  183. void PolygonData::getM2( Polygon2D & pd, bool textur ) const
  184. {
  185. int anz = vd->getEintragAnzahl();
  186. if( !pd.name )
  187. pd.name = new Text( name );
  188. if( !pd.vertex )
  189. pd.vertex = new Array< Vertex >();
  190. if( !pd.tKordinaten )
  191. pd.tKordinaten = new Array< Vertex >();
  192. for( int i = 0; i < anz; i++ )
  193. {
  194. pd.vertex->add( this->vd->z( i )->getPos() );
  195. if( textur )
  196. pd.tKordinaten->add( this->vd->z( i )->getTPos() );
  197. }
  198. }
  199. bool PolygonData::istTransparent() const
  200. {
  201. return transparent;
  202. }
  203. // Reference Counting
  204. PolygonData *PolygonData::getThis()
  205. {
  206. ref++;
  207. return this;
  208. }
  209. PolygonData *PolygonData::release()
  210. {
  211. ref--;
  212. if( !ref )
  213. delete this;
  214. return 0;
  215. }
  216. // Inhalt der Data Klasse aus KEDModel2DEditor.h
  217. // Konstruktor
  218. Data::Data( Model2DData * mdl )
  219. {
  220. pd = new RCArray< PolygonData >();
  221. tPos.x = 0;
  222. tPos.y = 0;
  223. textur = 0;
  224. rTextur = 0;
  225. sp = -1;
  226. ref = 1;
  227. int anz = ( mdl && mdl->polygons ) ? mdl->polygons->getEintragAnzahl() : 0;
  228. for( int i = 0; i < anz; i++ )
  229. {
  230. if( mdl->polygons->hat( i ) )
  231. {
  232. pd->add( new PolygonData( mdl->polygons->get( i ) ) );
  233. }
  234. }
  235. if( mdl )
  236. mdl->release();
  237. }
  238. // Destruktor
  239. Data::~Data()
  240. {
  241. pd->release();
  242. if( textur )
  243. textur->release();
  244. }
  245. // nicht constant
  246. void Data::addPolygon()
  247. {
  248. Polygon2D p;
  249. p.name = new Text();
  250. p.vertex = new Array< Vertex >();
  251. pd->add( new PolygonData( p ) );
  252. p.vertex->release();
  253. p.name->release();
  254. }
  255. void Data::removePolygon( int num )
  256. {
  257. pd->remove( num );
  258. if( sp == num )
  259. sp = -1;
  260. }
  261. void Data::selectPolygon( int num )
  262. {
  263. sp = num;
  264. }
  265. void Data::nachLinks( float num )
  266. {
  267. for( auto i = pd->getIterator(); i; i++ )
  268. i->nachLinks( num );
  269. }
  270. void Data::nachOben( float num )
  271. {
  272. for( auto i = pd->getIterator(); i; i++ )
  273. i->nachOben( num );
  274. }
  275. void Data::tNachLinks( int num )
  276. {
  277. if( !rTextur )
  278. return;
  279. tPos.x -= num;
  280. }
  281. void Data::tNachOben( int num )
  282. {
  283. if( !rTextur )
  284. return;
  285. tPos.y -= num;
  286. }
  287. void Data::setRTextur( bool rt )
  288. {
  289. rTextur = rt;
  290. if( rt && !textur )
  291. {
  292. textur = new Bild();
  293. textur->neuBild( 500, 500, 0xFF505000 );
  294. }
  295. }
  296. void Data::saveTextur()
  297. {
  298. if( !rTextur )
  299. return;
  300. for( auto i = pd->getIterator(); i; i++ )
  301. i->saveTextur( tPos, textur->getSize() );
  302. }
  303. void Data::setTextur( Bild * t )
  304. {
  305. if( textur )
  306. textur->release();
  307. textur = t;
  308. if( pd->getEintragAnzahl() > 0 && pd->z( 0 )->zVertex( 0 ) )
  309. {
  310. Vertex p = pd->z( 0 )->zVertex( 0 )->getPos();
  311. Vertex tp = pd->z( 0 )->zVertex( 0 )->getTPos();
  312. tp.x *= t->getBreite();
  313. tp.y *= t->getHeight();
  314. tPos = p - tp;
  315. }
  316. }
  317. void Data::select( Punkt p1, Punkt p2 )
  318. {
  319. for( auto i = pd->getIterator(); i; i++ )
  320. i->select( p1, p2 );
  321. }
  322. void Data::deSelect()
  323. {
  324. for( auto i = pd->getIterator(); i; i++ )
  325. i->deSelect();
  326. }
  327. // constant
  328. PolygonData *Data::zPolygon( int num ) const
  329. {
  330. return pd->z( num );
  331. }
  332. int Data::getPolygonAnzahl() const
  333. {
  334. return pd->getEintragAnzahl();
  335. }
  336. int Data::getSelectedPolygon() const
  337. {
  338. return sp;
  339. }
  340. Model2DData *Data::getM2() const
  341. {
  342. int anz = pd->getEintragAnzahl();
  343. Array< Polygon2D > *polygons = new Array< Polygon2D >();
  344. for( int i = 0; i < anz; i++ )
  345. {
  346. Polygon2D pd = { 0, 0, 0, 0, 0 };
  347. this->pd->z( i )->getM2( pd, 1 );
  348. pd.transparent = this->pd->z( i )->istTransparent();
  349. polygons->add( pd );
  350. }
  351. Model2DData *ret = new Model2DData();
  352. ret->erstelleModell( polygons );
  353. return ret;
  354. }
  355. Bild *Data::zTextur() const
  356. {
  357. return rTextur ? textur : 0;
  358. }
  359. Punkt Data::getTPos() const
  360. {
  361. return tPos;
  362. }
  363. // Reference Counting
  364. Data *Data::getThis()
  365. {
  366. ref++;
  367. return this;
  368. }
  369. Data *Data::release()
  370. {
  371. ref--;
  372. if( !ref )
  373. delete this;
  374. return 0;
  375. }
  376. // Inhalt der EditorListe Klasse aus KEDModel2DEditor.h
  377. // Konstruktor
  378. EditorListe::EditorListe( Schrift * zSchrift )
  379. : Zeichnung()
  380. {
  381. ram = new LRahmen();
  382. ram->setRamenBreite( 1 );
  383. ram->setFarbe( 0xFFFFFFFF );
  384. ram->setSize( 150, 480 );
  385. ram->setPosition( 720, 10 );
  386. scroll = new VScrollBar();
  387. schrift = zSchrift->getThis();
  388. tr = new TextRenderer( schrift ? schrift->getThis() : 0 );
  389. pName = initTextFeld( 0, 0, 70, 20, schrift, TextFeld::Style::TextFeld, "" );
  390. koordF = initFenster( 10, 10, 150, 140, zSchrift, ( Fenster::Style::normal | Fenster::Style::TitelHintergrund | Fenster::Style::BodyHintergrund ) & ~Fenster::Style::Sichtbar, "Koordinaten" );
  391. koordF->setKBgFarbe( 0xFF000000 );
  392. koordF->setTBgFarbe( 0xFF000000 );
  393. koordF->setClosingMe( _closeFensterME );
  394. kxT = initTextFeld( 10, 10, 30, 20, zSchrift, TextFeld::Style::Text, "x:" );
  395. kyT = initTextFeld( 10, 40, 30, 20, zSchrift, TextFeld::Style::Text, "y:" );
  396. kx = initTextFeld( 40, 10, 90, 20, zSchrift, TextFeld::Style::TextFeld, "" );
  397. ky = initTextFeld( 40, 40, 90, 20, zSchrift, TextFeld::Style::TextFeld, "" );
  398. tkxT = initTextFeld( 10, 70, 30, 20, zSchrift, TextFeld::Style::Text, "tx:" );
  399. tkyT = initTextFeld( 10, 100, 30, 20, zSchrift, TextFeld::Style::Text, "ty:" );
  400. tkx = initTextFeld( 40, 70, 90, 20, zSchrift, TextFeld::Style::TextFeld, "" );
  401. tky = initTextFeld( 40, 100, 90, 20, zSchrift, TextFeld::Style::TextFeld, "" );
  402. int *polIP = &polI, *verIP = &verI;
  403. TextFeld * kxTmp = kx;
  404. TextFeld * kyTmp = ky;
  405. auto saveK = [ polIP, verIP, kxTmp, kyTmp ]( void *p, void *o, TastaturEreignis te )
  406. {
  407. Data *data = (Data *)p;
  408. data->zPolygon( *polIP )->zVertex( *verIP )->setPosition( Vertex( (float)(double)* kxTmp->zText(), (float)(double)* kyTmp->zText() ) );
  409. return 1;
  410. };
  411. kx->setNTastaturEreignis( saveK );
  412. ky->setNTastaturEreignis( saveK );
  413. TextFeld * tkxTmp = tkx;
  414. TextFeld * tkyTmp = tky;
  415. auto saveTK = [ polIP, verIP, tkxTmp, tkyTmp ]( void *p, void *o, TastaturEreignis te )
  416. {
  417. Data *data = (Data *)p;
  418. data->zPolygon( *polIP )->zVertex( *verIP )->setTextur( Vertex( (float)(double)* tkxTmp->zText(), (float)(double)* tkyTmp->zText() ) );
  419. return 1;
  420. };
  421. tkx->setNTastaturEreignis( saveTK );
  422. tky->setNTastaturEreignis( saveTK );
  423. koordF->addMember( kxT->getThis() );
  424. koordF->addMember( kyT->getThis() );
  425. koordF->addMember( kx->getThis() );
  426. koordF->addMember( ky->getThis() );
  427. koordF->addMember( tkxT->getThis() );
  428. koordF->addMember( tkyT->getThis() );
  429. koordF->addMember( tkx->getThis() );
  430. koordF->addMember( tky->getThis() );
  431. polI = 0;
  432. verI = 0;
  433. data = 0;
  434. }
  435. // Destruktor
  436. EditorListe::~EditorListe()
  437. {
  438. pName->release();
  439. ram->release();
  440. scroll->release();
  441. if( data )
  442. data->release();
  443. schrift->release();
  444. koordF->release();
  445. kxT->release();
  446. kyT->release();
  447. kx->release();
  448. ky->release();
  449. tkxT->release();
  450. tkyT->release();
  451. tkx->release();
  452. tky->release();
  453. tr->release();
  454. }
  455. // nicht constant
  456. void EditorListe::setDataZ( Data * d )
  457. {
  458. if( data )
  459. data->release();
  460. data = d;
  461. }
  462. void EditorListe::doMausEreignis( MausEreignis & me )
  463. {
  464. koordF->doMausEreignis( me );
  465. me.mx -= ram->getX();
  466. me.my -= ram->getY();
  467. if( me.mx < 0 || me.my < 0 || me.mx > ram->getBreite() || me.my > ram->getHeight() )
  468. {
  469. me.mx += ram->getX();
  470. me.my += ram->getY();
  471. return;
  472. }
  473. scroll->doMausMessage( ram->getBreite() - 17, 1, 15, ram->getHeight() - 2, me );
  474. if( data->getSelectedPolygon() >= 0 )
  475. pName->doMausEreignis( me );
  476. rend |= scroll->getRend();
  477. if( me.id == ME_RLinks && !me.verarbeitet )
  478. {
  479. int pAnz = data->getPolygonAnzahl();
  480. int y = -scroll->getScroll();
  481. for( int i = 0; i < pAnz; i++ )
  482. {
  483. if( me.mx > 0 && me.my > y && me.mx < 20 && me.my < y + 20 )
  484. { // Ein und Ausklappen
  485. if( !ausgeklappt.hat( i ) )
  486. ausgeklappt.set( 0, i );
  487. ausgeklappt.set( !ausgeklappt.get( i ), i );
  488. rend = 1;
  489. }
  490. else if( me.mx > 115 && me.my > y + 1 && me.mx < 132 && me.my < y + 19 )
  491. { // Löschen
  492. if( polI == i )
  493. koordF->removeStyle( Fenster::Style::Sichtbar );
  494. data->removePolygon( i );
  495. rend = 1;
  496. break;
  497. }
  498. else if( me.mx > 95 && me.my > y + 5 && me.mx < 105 && me.my < y + 15 )
  499. {
  500. data->zPolygon( i )->setTransparent( !data->zPolygon( i )->istTransparent() );
  501. rend = 1;
  502. }
  503. else if( me.mx > 0 && me.my > y &&me.mx < 133 && me.my < y + 20 )
  504. { // Polygon Auswählen und Abwählen
  505. if( data->getSelectedPolygon() != i )
  506. data->selectPolygon( i );
  507. else
  508. data->selectPolygon( -1 );
  509. rend = 1;
  510. }
  511. PolygonData * pd = data->zPolygon( i );
  512. if( pd && ausgeklappt.hat( i ) && ausgeklappt.get( i ) )
  513. {
  514. int vAnz = pd->getVertexAnzahl();
  515. for( int j = 0; j < vAnz; j++ )
  516. {
  517. y += 20;
  518. if( me.mx > 115 && me.my > y + 1 && me.mx < 132 && me.my < y + 19 )
  519. { // Löschen
  520. if( polI == i && verI == j )
  521. koordF->removeStyle( Fenster::Style::Sichtbar );
  522. pd->removeVertex( j );
  523. rend = 1;
  524. }
  525. else if( me.mx > 95 && me.my > y + 5 && me.mx < 105 && me.my < y + 15 )
  526. { // Sichtbar und Unsichtbar
  527. pd->zVertex( j )->setSichtbar( !pd->zVertex( j )->istSichtbar() );
  528. rend = 1;
  529. }
  530. else if( me.mx > 5 && me.my > y + 5 && me.mx < 15 && me.my < y + 15 )
  531. { // Koordinaten fenster sichtbar machen
  532. polI = i;
  533. verI = j;
  534. tkx->setNTastaturEreignisParameter( data );
  535. tky->setNTastaturEreignisParameter( data );
  536. kx->setNTastaturEreignisParameter( data );
  537. ky->setNTastaturEreignisParameter( data );
  538. tkx->setText( Text() += pd->zVertex( j )->getTPos().x );
  539. tky->setText( Text() += pd->zVertex( j )->getTPos().y );
  540. kx->setText( Text() += pd->zVertex( j )->getPos().x );
  541. ky->setText( Text() += pd->zVertex( j )->getPos().y );
  542. koordF->addStyle( Fenster::Style::Sichtbar );
  543. }
  544. else if( me.my > y &&me.my < y + 20 && me.mx > 0 && me.mx < 133 )
  545. { // Auswählen und Abwählen
  546. pd->zVertex( j )->setAuswahl( !pd->zVertex( j )->istAusgewählt() );
  547. rend = 1;
  548. }
  549. }
  550. }
  551. y += 20;
  552. }
  553. }
  554. me.verarbeitet = 1;
  555. me.mx += ram->getX();
  556. me.my += ram->getY();
  557. }
  558. void EditorListe::doTastaturEreignis( TastaturEreignis & te )
  559. {
  560. koordF->doTastaturEreignis( te );
  561. if( data &&data->getSelectedPolygon() >= 0 )
  562. pName->doTastaturEreignis( te );
  563. }
  564. bool EditorListe::tick( double zeit )
  565. {
  566. rend |= koordF->tick( zeit );
  567. if( data &&data->getSelectedPolygon() >= 0 )
  568. rend |= pName->tick( zeit );
  569. bool ret = rend;
  570. rend = 0;
  571. return ret;
  572. }
  573. void EditorListe::render( Bild & zRObj )
  574. {
  575. ram->render( zRObj );
  576. if( !zRObj.setDrawOptions( ram->getPosition() + Punkt( 1, 1 ), ram->getSize() - Punkt( 2, 2 ) ) )
  577. return;
  578. scroll->render( ram->getBreite() - 17, 1, 15, ram->getHeight() - 2, zRObj );
  579. int pAnz = data->getPolygonAnzahl();
  580. int y = -scroll->getScroll();
  581. int maxH = 0;
  582. tr->setSchriftSize( 12 );
  583. Text name;
  584. for( int i = 0; i < pAnz; i++ )
  585. {
  586. if( data->getSelectedPolygon() == i )
  587. {
  588. pName->setPosition( 20, y );
  589. pName->setText( data->zPolygon( data->getSelectedPolygon() )->getName() );
  590. Data *tmpData = data;
  591. pName->setNTastaturEreignis( [ tmpData ]( void *p, void *o, TastaturEreignis te ) -> bool
  592. {
  593. if( tmpData->getSelectedPolygon() >= 0 )
  594. tmpData->zPolygon( tmpData->getSelectedPolygon() )->setName( ( (TextFeld *)o )->zText()->getText() );
  595. return 1;
  596. } );
  597. zRObj.fillRegion( 0, y, 133, 20, 0xFF002000 );
  598. pName->render( zRObj );
  599. }
  600. else
  601. {
  602. if( textLength( data->zPolygon( i )->getName() ) > 0 )
  603. name = data->zPolygon( i )->getName();
  604. else
  605. {
  606. name = "Polygon ";
  607. name += i;
  608. }
  609. tr->renderText( 20, y + 4, name, zRObj, 0xFFFFFFFF );
  610. }
  611. zRObj.drawLinie( Punkt( 115, y + 1 ), Punkt( 132, y + 18 ), 0xFFFF0000 );
  612. zRObj.drawLinie( Punkt( 132, y + 1 ), Punkt( 115, y + 18 ), 0xFFFF0000 );
  613. if( data->zPolygon( i )->istTransparent() )
  614. {
  615. zRObj.drawLinieH( 95, y + 5, 10, 0xFFFFFFFF );
  616. zRObj.drawLinieH( 95, y + 15, 10, 0xFFFFFFFF );
  617. zRObj.drawLinieV( 95, y + 5, 10, 0xFFFFFFFF );
  618. zRObj.drawLinieV( 105, y + 5, 10, 0xFFFFFFFF );
  619. }
  620. else
  621. zRObj.fillRegion( 95, y + 5, 10, 10, 0xFFFFFFFF );
  622. if( ausgeklappt.hat( i ) && ausgeklappt.get( i ) )
  623. {
  624. zRObj.drawDreieck( Punkt( 10, 4 + y ), Punkt( 4, 16 + y ), Punkt( 16, 16 + y ), 0xFFFFFFFF );
  625. PolygonData * pd = data->zPolygon( i );
  626. if( pd )
  627. {
  628. int vAnz = pd->getVertexAnzahl();
  629. for( int j = 0; j < vAnz; j++ )
  630. {
  631. maxH += 20;
  632. y += 20;
  633. if( pd->zVertex( j )->istAusgewählt() )
  634. zRObj.fillRegion( 0, y, 133, 20, 0xFF101010 );
  635. name = " Vertex ";
  636. name += j;
  637. tr->renderText( 20, y + 4, name, zRObj, 0xFFFFFFFF );
  638. zRObj.drawLinieH( 5, y + 5, 10, 0xFFFFFFFF );
  639. zRObj.drawLinieH( 5, y + 10, 10, 0xFFFFFFFF );
  640. zRObj.drawLinieH( 5, y + 15, 10, 0xFFFFFFFF );
  641. zRObj.drawLinieV( 5, y + 5, 10, 0xFFFFFFFF );
  642. zRObj.drawLinieV( 10, y + 5, 10, 0xFFFFFFFF );
  643. zRObj.drawLinieV( 15, y + 5, 10, 0xFFFFFFFF );
  644. zRObj.drawLinie( Punkt( 115, y + 1 ), Punkt( 132, y + 18 ), 0xFFFF0000 );
  645. zRObj.drawLinie( Punkt( 132, y + 1 ), Punkt( 115, y + 18 ), 0xFFFF0000 );
  646. if( pd->zVertex( j )->istSichtbar() )
  647. {
  648. zRObj.drawKreis( 100, y + 10, 5, 0xFFFFFFFF );
  649. zRObj.drawKreis( 100, y + 10, 1, 0xFFFFFFFF );
  650. }
  651. else
  652. {
  653. zRObj.drawKreis( 100, y + 10, 5, 0xFF505050 );
  654. zRObj.drawKreis( 100, y + 10, 1, 0xFF505050 );
  655. }
  656. }
  657. }
  658. }
  659. else
  660. zRObj.drawDreieck( Punkt( 10, 16 + y ), Punkt( 4, 4 + y ), Punkt( 16, 4 + y ), 0xFFFFFFFF );
  661. maxH += 20;
  662. y += 20;
  663. }
  664. scroll->update( maxH, ram->getHeight() - 2 );
  665. zRObj.releaseDrawOptions();
  666. koordF->render( zRObj );
  667. }
  668. // Inhalt der Editor2D Klasse aus KEDModel2DEditor.h
  669. // Konstruktor
  670. Editor2D::Editor2D( Schrift * zSchrift )
  671. : Zeichnung()
  672. {
  673. pos.x = 10;
  674. pos.y = 10;
  675. offs.x = -350;
  676. offs.y = -250;
  677. mausPos.x = 0;
  678. mausPos.y = 0;
  679. data = 0;
  680. ram = new LRahmen();
  681. ram->setFarbe( 0xFFFFFFFF );
  682. ram->setRamenBreite( 1 );
  683. ram->setSize( 700, 480 );
  684. select = new LRahmen();
  685. select->setFarbe( 0xFF5050FF );
  686. select->setRamenBreite( 1 );
  687. schrift = zSchrift->getThis();
  688. tr = new TextRenderer( schrift->getThis() );
  689. addV = Vertex( 0, 0 );
  690. mausIn = 0;
  691. größe = 1;
  692. }
  693. // Destruktor
  694. Editor2D::~Editor2D()
  695. {
  696. ram->release();
  697. select->release();
  698. schrift->release();
  699. tr->release();
  700. if( data )
  701. data->release();
  702. }
  703. // nicht constant
  704. void Editor2D::setDataZ( Data * d )
  705. {
  706. if( data )
  707. data->release();
  708. data = d;
  709. }
  710. void Editor2D::doMausEreignis( MausEreignis & me )
  711. {
  712. me.mx -= pos.x;
  713. me.my -= pos.y;
  714. if( me.mx < 0 || me.my < 0 || me.mx > ram->getBreite() || me.my > ram->getHeight() )
  715. {
  716. me.mx += pos.x;
  717. me.my += pos.y;
  718. mausIn = 0;
  719. return;
  720. }
  721. mausIn = 1;
  722. rend = 1;
  723. addV = Vertex( (float)me.mx, (float)me.my ) / größe + offs;
  724. if( me.id == ME_UScroll )
  725. größe += 0.01f;
  726. if( me.id == ME_DScroll )
  727. größe -= 0.01f;
  728. if( me.id == ME_PLinks )
  729. {
  730. select->setPosition( me.mx, me.my );
  731. select->setSize( 0, 0 );
  732. }
  733. if( me.id == ME_PRechts || me.id == ME_PMitte )
  734. {
  735. mausPos.x = me.mx;
  736. mausPos.y = me.my;
  737. }
  738. if( me.id == ME_Bewegung )
  739. {
  740. if( getMausStand( M_Links ) )
  741. {
  742. select->setSize( me.mx - select->getX(), me.my - select->getY() );
  743. }
  744. if( getMausStand( M_Rechts ) )
  745. {
  746. data->nachLinks( ( mausPos.x - me.mx ) / größe );
  747. data->nachOben( ( mausPos.y - me.my ) / größe );
  748. mausPos.x = me.mx;
  749. mausPos.y = me.my;
  750. }
  751. if( getMausStand( M_Mitte ) )
  752. {
  753. data->tNachLinks( (int)( ( mausPos.x - me.mx ) / größe ) );
  754. data->tNachOben( (int)( ( mausPos.y - me.my ) / größe ) );
  755. mausPos.x = me.mx;
  756. mausPos.y = me.my;
  757. }
  758. }
  759. if( me.id == ME_RLinks )
  760. {
  761. if( !getTastenStand( T_Shift ) )
  762. data->deSelect();
  763. data->select( ( Vec2<float> )select->getPosition() / größe + offs, ( Vec2<float> )( select->getPosition() + select->getSize() ) / größe + offs );
  764. select->setSize( 0, 0 );
  765. select->setPosition( 0, 0 );
  766. }
  767. if( me.id == ME_RRechts )
  768. {
  769. mausPos.x = 0;
  770. mausPos.y = 0;
  771. }
  772. me.verarbeitet = 1;
  773. me.mx += pos.x;
  774. me.my += pos.y;
  775. }
  776. void Editor2D::doTastaturEreignis( TastaturEreignis & te )
  777. {
  778. if( te.id == TE_Release && te.taste == T_Enter && mausIn )
  779. {
  780. PolygonData *pd = data->zPolygon( data->getSelectedPolygon() );
  781. if( pd )
  782. {
  783. pd->addVertex( addV, Punkt( 0, 0 ) );
  784. rend = 1;
  785. }
  786. }
  787. if( te.id == TE_Release && te.taste == T_Einfg )
  788. {
  789. data->addPolygon();
  790. rend = 1;
  791. }
  792. if( te.id == T_Oben )
  793. offs.y -= 2;
  794. if( te.id == T_Links )
  795. offs.x -= 2;
  796. if( te.id == T_Unten )
  797. offs.y += 2;
  798. if( te.id == T_Rechts )
  799. offs.x += 2;
  800. if( te.id == T_Oben || te.id == T_Links || te.id == T_Unten || te.id == T_Rechts )
  801. rend = 1;
  802. }
  803. bool Editor2D::tick( double zeit )
  804. {
  805. if( mausIn )
  806. {
  807. if( getTastenStand( T_Links ) )
  808. {
  809. offs.x--;
  810. rend = 1;
  811. }
  812. if( getTastenStand( T_Rechts ) )
  813. {
  814. offs.x++;
  815. rend = 1;
  816. }
  817. if( getTastenStand( T_Oben ) )
  818. {
  819. offs.y--;
  820. rend = 1;
  821. }
  822. if( getTastenStand( T_Unten ) )
  823. {
  824. offs.y++;
  825. rend = 1;
  826. }
  827. if( getTastenStand( 'w' ) )
  828. {
  829. data->tNachOben( 1 );
  830. rend = 1;
  831. }
  832. if( getTastenStand( 'a' ) )
  833. {
  834. data->tNachLinks( 1 );
  835. rend = 1;
  836. }
  837. if( getTastenStand( 's' ) )
  838. {
  839. data->tNachOben( -1 );
  840. rend = 1;
  841. }
  842. if( getTastenStand( 'd' ) )
  843. {
  844. data->tNachLinks( -1 );
  845. rend = 1;
  846. }
  847. }
  848. bool ret = rend;
  849. rend = 0;
  850. return ret;
  851. }
  852. void Editor2D::render( Bild & zRObj )
  853. {
  854. if( !zRObj.setDrawOptions( pos, ram->getSize() ) )
  855. return;
  856. ram->render( zRObj );
  857. if( !zRObj.setDrawOptions( 1, 1, ram->getBreite() - 2, ram->getHeight() - 2 ) )
  858. {
  859. zRObj.releaseDrawOptions();
  860. return;
  861. }
  862. if( data->zTextur() )
  863. {
  864. Punkt tPos = data->getTPos();
  865. zRObj.alphaBildSkall( (int)( ( tPos.x - offs.x ) * größe ), (int)( ( tPos.y - offs.y ) * größe ),
  866. (int)( data->zTextur()->getBreite() * größe ), (int)( data->zTextur()->getHeight() * größe ), *data->zTextur() );
  867. }
  868. // Raster mahlen
  869. int xanz = (int)( ram->getBreite() / ( 50 * größe ) );
  870. int yanz = (int)( ram->getHeight() / ( 50 * größe ) );
  871. int xStart = ( 50 - abs( offs.x ) % 50 );
  872. if( offs.x < 0 )
  873. xStart = -offs.x % 50;
  874. if( offs.x == 0 )
  875. xStart = 0;
  876. int yStart = ( 50 - abs( offs.y ) % 50 );
  877. if( offs.y < 0 )
  878. yStart = -offs.y % 50;
  879. if( offs.y == 0 )
  880. yStart = 0;
  881. for( float x = xStart * größe, y = yStart * größe; !( x > ram->getBreite() && y > ram->getHeight() ); x += 50 * größe, y += 50 * größe )
  882. {
  883. zRObj.drawLinieH( 0, (int)y, ram->getBreite(), 0xFF505050 );
  884. zRObj.drawLinieV( (int)x, 0, ram->getHeight(), 0xFF505050 );
  885. }
  886. Text xPos = "";
  887. xPos = offs.x + (int)( xStart + 50 * ( xanz / 2 ) );
  888. tr->renderText( (int)( xStart * größe + 50 * größe * ( xanz / 2 ) ), 0, xPos, zRObj, 0xFF505050 );
  889. xPos = offs.y + (int)( yStart + 50 * ( yanz / 2 ) );
  890. tr->renderText( 0, (int)( yStart * größe + 50 * größe * ( yanz / 2 ) ), xPos, zRObj, 0xFF505050 );
  891. // Model mahlen
  892. int pAnz = data->getPolygonAnzahl();
  893. for( int i = 0; i < pAnz; i++ )
  894. {
  895. PolygonData *p = data->zPolygon( i );
  896. if( !p->istSichtbar() )
  897. continue;
  898. if( data->getSelectedPolygon() == i && mausIn )
  899. {
  900. int vAnz = p->getVertexAnzahl();
  901. VertexData tmp = VertexData( addV, Punkt() );
  902. VertexData *l = p->zVertex( vAnz - 1 );
  903. for( int j = -1; j < vAnz && vAnz > 0; j++ )
  904. {
  905. VertexData *v = j < 0 ? &tmp : p->zVertex( j );
  906. if( l &&v )
  907. {
  908. if( l->istSichtbar() && v->istSichtbar() )
  909. zRObj.drawLinie( ( ( l->getPos() - offs ) * größe ), ( ( v->getPos() - offs ) * größe ), 0xFFA0A0A0 );
  910. else
  911. zRObj.drawLinie( ( ( l->getPos() - offs ) * größe ), ( ( v->getPos() - offs ) * größe ), 0xFF606060 );
  912. }
  913. if( !l->istSichtbar() )
  914. {
  915. l = v;
  916. continue;
  917. }
  918. if( j == 0 )
  919. zRObj.fillRegion( (int)( ( l->getPos().x - offs.x ) *größe ) - 5, (int)( ( l->getPos().y - offs.y ) *größe ) - 5, 10, 10, 0xFF50FF50 );
  920. else
  921. {
  922. if( !l->istAusgewählt() )
  923. zRObj.fillRegion( (int)( ( l->getPos().x - offs.x ) * größe ) - 5, (int)( ( l->getPos().y - offs.y ) * größe ) - 5, 10, 10, 0xFF5050FF );
  924. else
  925. zRObj.fillRegion( (int)( ( l->getPos().x - offs.x ) * größe ) - 5, (int)( ( l->getPos().y - offs.y ) * größe ) - 5, 10, 10, 0xFFFF5050 );
  926. }
  927. l = v;
  928. }
  929. }
  930. else
  931. {
  932. int vAnz = p->getVertexAnzahl();
  933. VertexData *l = p->zVertex( vAnz - 1 );
  934. for( int j = 0; j < vAnz; j++ )
  935. {
  936. VertexData *v = p->zVertex( j );
  937. if( l && v )
  938. {
  939. if( l->istSichtbar() && v->istSichtbar() )
  940. zRObj.drawLinie( ( ( l->getPos() - offs ) * größe ), ( ( v->getPos() - offs ) * größe ), 0xFFA0A0A0 );
  941. else
  942. zRObj.drawLinie( ( ( l->getPos() - offs ) * größe ), ( ( v->getPos() - offs ) * größe ), 0xFF606060 );
  943. }
  944. if( l )
  945. {
  946. if( !l->istSichtbar() )
  947. {
  948. l = v;
  949. continue;
  950. }
  951. if( !l->istAusgewählt() )
  952. zRObj.fillRegion( (int)( ( l->getPos().x - offs.x ) * größe ) - 5, (int)( ( l->getPos().y - offs.y ) * größe ) - 5, 10, 10, 0xFF5050FF );
  953. else
  954. zRObj.fillRegion( (int)( ( l->getPos().x - offs.x ) * größe ) - 5, (int)( ( l->getPos().y - offs.y ) * größe ) - 5, 10, 10, 0xFFFF5050 );
  955. }
  956. l = v;
  957. }
  958. }
  959. }
  960. select->render( zRObj );
  961. zRObj.releaseDrawOptions();
  962. zRObj.releaseDrawOptions();
  963. }
  964. // Inhalt der GUI Klasse aus KEDModel2DEditor.h
  965. // Konstruktor
  966. GUI::GUI( Schrift * zSchrift )
  967. : Zeichnung()
  968. {
  969. speichern = initKnopf( 660, 500, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Speichern" );
  970. abbrechen = initKnopf( 770, 500, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Abbrehen" );
  971. textur = initKontrollKnopf( 10, 500, 100, 20, zSchrift, KontrollKnopf::Style::Normal, "Textur" );
  972. texturVerknüpfen = initKnopf( 120, 500, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Textur Speichern" );
  973. texturLaden = initKnopf( 230, 500, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Textur Laden" );
  974. data = new Data( 0 );
  975. editor = new Editor2D( zSchrift );
  976. editor->setDataZ( data->getThis() );
  977. liste = new EditorListe( zSchrift );
  978. liste->setDataZ( data->getThis() );
  979. importDialog = 0;
  980. aktion = 0;
  981. alpha = 0;
  982. sichtbar = 0;
  983. }
  984. // Destruktor
  985. GUI::~GUI()
  986. {
  987. editor->release();
  988. liste->release();
  989. speichern->release();
  990. abbrechen->release();
  991. data->release();
  992. textur->release();
  993. texturVerknüpfen->release();
  994. texturLaden->release();
  995. if( importDialog )
  996. importDialog->release();
  997. }
  998. // nicht constant
  999. void GUI::setSichtbar( bool s )
  1000. {
  1001. sichtbar = s;
  1002. }
  1003. void GUI::setModel( Model2DData * data )
  1004. {
  1005. if( this->data )
  1006. this->data->release();
  1007. this->data = new Data( data );
  1008. editor->setDataZ( this->data->getThis() );
  1009. liste->setDataZ( this->data->getThis() );
  1010. }
  1011. void GUI::doMausEreignis( MausEreignis & me )
  1012. {
  1013. if( !sichtbar )
  1014. return;
  1015. liste->doMausEreignis( me );
  1016. editor->doMausEreignis( me );
  1017. bool vera = me.verarbeitet;
  1018. speichern->doMausEreignis( me );
  1019. if( me.id == ME_RLinks && me.verarbeitet && !vera )
  1020. {
  1021. aktion = 1;
  1022. }
  1023. vera = me.verarbeitet;
  1024. abbrechen->doMausEreignis( me );
  1025. if( me.id == ME_RLinks && me.verarbeitet && !vera )
  1026. {
  1027. aktion = 2;
  1028. }
  1029. vera = me.verarbeitet;
  1030. textur->doMausEreignis( me );
  1031. data->setRTextur( textur->hatStyle( KontrollKnopf::Style::Selected ) );
  1032. vera = me.verarbeitet;
  1033. texturVerknüpfen->doMausEreignis( me );
  1034. if( !vera && me.verarbeitet &&me.id == ME_RLinks )
  1035. data->saveTextur();
  1036. vera = me.verarbeitet;
  1037. texturLaden->doMausEreignis( me );
  1038. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  1039. {
  1040. if( !importDialog )
  1041. {
  1042. importDialog = new DateiDialogTh();
  1043. importDialog->setOpen( 1 );
  1044. importDialog->setDateiTypAuswahl( 4 );
  1045. importDialog->addDateiTyp( "JPEG-Bild", "*.jpg;*.jpeg;*.jpe" );
  1046. importDialog->addDateiTyp( "GIF-Bild", "*.gif" );
  1047. importDialog->addDateiTyp( "PNG-Bild", "*.png" );
  1048. importDialog->addDateiTyp( "Alle Dateien", "*.*" );
  1049. importDialog->start();
  1050. }
  1051. }
  1052. }
  1053. void GUI::doTastaturEreignis( TastaturEreignis & te )
  1054. {
  1055. if( !sichtbar )
  1056. return;
  1057. liste->doTastaturEreignis( te );
  1058. editor->doTastaturEreignis( te );
  1059. }
  1060. bool GUI::tick( double zeit )
  1061. {
  1062. if( importDialog )
  1063. {
  1064. if( !importDialog->isRunning() )
  1065. {
  1066. Text *importPfad = importDialog->getPfad();
  1067. importDialog = importDialog->release();
  1068. if( sichtbar && importPfad )
  1069. {
  1070. importPfad->ersetzen( "\\", "/" );
  1071. Text *err = new Text();
  1072. Bild *b = ladeBild( importPfad->getText(), err );
  1073. if( !b )
  1074. nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), err, new Text( "Ok" ) );
  1075. else
  1076. data->setTextur( b );
  1077. err->release();
  1078. }
  1079. if( importPfad )
  1080. importPfad->release();
  1081. }
  1082. }
  1083. rend |= speichern->tick( zeit );
  1084. rend |= abbrechen->tick( zeit );
  1085. if( sichtbar && alpha != 255 )
  1086. {
  1087. if( alpha + zeit * 200 > 255 )
  1088. alpha = 255;
  1089. else
  1090. alpha += (unsigned char)( zeit * 200 );
  1091. rend = 1;
  1092. }
  1093. else if( !sichtbar && alpha )
  1094. {
  1095. if( alpha - zeit * 200 < 0 )
  1096. alpha = 0;
  1097. else
  1098. alpha -= (unsigned char)( zeit * 200 );
  1099. rend = 1;
  1100. }
  1101. if( sichtbar )
  1102. {
  1103. rend |= editor->tick( zeit );
  1104. rend |= liste->tick( zeit );
  1105. rend |= speichern->tick( zeit );
  1106. rend |= textur->tick( zeit );
  1107. rend |= texturVerknüpfen->tick( zeit );
  1108. rend |= texturLaden->tick( zeit );
  1109. }
  1110. bool ret = rend;
  1111. rend = 0;
  1112. return ret;
  1113. }
  1114. void GUI::render( Bild & zRObj )
  1115. {
  1116. zRObj.setAlpha( alpha );
  1117. editor->render( zRObj );
  1118. liste->render( zRObj );
  1119. speichern->render( zRObj );
  1120. abbrechen->render( zRObj );
  1121. textur->render( zRObj );
  1122. texturVerknüpfen->render( zRObj );
  1123. texturLaden->render( zRObj );
  1124. zRObj.releaseAlpha();
  1125. }
  1126. int GUI::getAktion()
  1127. {
  1128. int ret = aktion;
  1129. aktion = 0;
  1130. return ret;
  1131. }
  1132. // const
  1133. Model2DData *GUI::getM2Data() const
  1134. {
  1135. return data->getM2();
  1136. }