Zeichnung.cpp 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972
  1. #include "Zeichnung.h"
  2. #include "MausEreignis.h"
  3. #include "TastaturEreignis.h"
  4. #include "Globals.h"
  5. #include "ToolTip.h"
  6. #include "Scroll.h"
  7. #include "Text.h"
  8. #include "Rahmen.h"
  9. #include "AlphaFeld.h"
  10. #include "Bild.h"
  11. #ifdef WIN32
  12. #include <Windows.h>
  13. #endif
  14. using namespace Framework;
  15. // Inhalt der Zeichnung Klasse aus Zeichnung.h
  16. // Konstruktor
  17. Zeichnung::Zeichnung()
  18. : pos( 0, 0 ),
  19. gr( 0, 0 ),
  20. makParam( 0 ),
  21. takParam( 0 ),
  22. Mak( 0 ),
  23. Tak( 0 ),
  24. nmakParam( 0 ),
  25. ntakParam( 0 ),
  26. nMak( 0 ),
  27. nTak( 0 ),
  28. mausIn( 0 ),
  29. toolTip( 0 ),
  30. rend( 0 )
  31. {
  32. }
  33. // Destruktor
  34. Zeichnung::~Zeichnung()
  35. {
  36. if( toolTip )
  37. toolTip->release();
  38. }
  39. // nicht constant
  40. void Zeichnung::setRender()
  41. {
  42. rend = 1;
  43. }
  44. void Zeichnung::setToolTipText( const char *txt, Bildschirm *zScreen )
  45. {
  46. if( !txt )
  47. toolTip = (ToolTip*)toolTip->release();
  48. else
  49. {
  50. if( !toolTip )
  51. toolTip = new ToolTip( zScreen );
  52. toolTip->setText( txt );
  53. }
  54. }
  55. void Zeichnung::lockZeichnung()
  56. {
  57. cs.lock();
  58. }
  59. void Zeichnung::unlockZeichnung()
  60. {
  61. cs.unlock();
  62. }
  63. void Zeichnung::setMausEreignisParameter( void *p ) // setzt den Parameter vom Maus Ereignis
  64. {
  65. makParam = p;
  66. }
  67. void Zeichnung::setTastaturEreignisParameter( void *p ) // setzt den Parameter vom Tastatur Ereignis
  68. {
  69. takParam = p;
  70. }
  71. void Zeichnung::setMausEreignis( bool( *ak )( void *, void *, MausEreignis ) ) // setzt das Maus Ereignis
  72. {
  73. Mak = ak;
  74. }
  75. void Zeichnung::setTastaturEreignis( bool( *ak )( void *, void *, TastaturEreignis ) ) // setzt das TastaturEreignis
  76. {
  77. Tak = ak;
  78. }
  79. void Zeichnung::setNMausEreignisParameter( void *p ) // setzt den Parameter vom Maus Ereignis
  80. {
  81. nmakParam = p;
  82. }
  83. void Zeichnung::setNTastaturEreignisParameter( void *p ) // setzt den Parameter vom Tastatur Ereignis
  84. {
  85. ntakParam = p;
  86. }
  87. void Zeichnung::setNMausEreignis( bool( *ak )( void *, void *, MausEreignis ) ) // setzt das Maus Ereignis
  88. {
  89. nMak = ak;
  90. }
  91. void Zeichnung::setNTastaturEreignis( bool( *ak )( void *, void *, TastaturEreignis ) ) // setzt das TastaturEreignis
  92. {
  93. nTak = ak;
  94. }
  95. void Zeichnung::doMausEreignis( MausEreignis &me ) // ruft Mak auf
  96. {
  97. if( me.verarbeitet || ( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Leaves ) )
  98. {
  99. if( mausIn )
  100. {
  101. mausIn = 0;
  102. if( toolTip )
  103. toolTip->setMausIn( 0 );
  104. MausEreignis me2;
  105. me2.id = ME_Leaves;
  106. me2.mx = me.mx;
  107. me2.my = me.my;
  108. me2.verarbeitet = 0;
  109. doMausEreignis( me2 );
  110. }
  111. return;
  112. }
  113. if( !mausIn && me.id != ME_Leaves )
  114. {
  115. mausIn = 1;
  116. if( toolTip )
  117. toolTip->setMausIn( 1 );
  118. MausEreignis me2;
  119. me2.id = ME_Betritt;
  120. me2.mx = me.mx;
  121. me2.my = me.my;
  122. me2.verarbeitet = 0;
  123. doMausEreignis( me2 );
  124. }
  125. me.mx -= pos.x, me.my -= pos.y;
  126. if( Mak )
  127. me.verarbeitet |= Mak( makParam, this, me );
  128. if( nMak && me.verarbeitet )
  129. me.verarbeitet = nMak( nmakParam, this, me );
  130. me.mx += pos.x, me.my += pos.y;
  131. }
  132. void Zeichnung::doTastaturEreignis( TastaturEreignis &te ) // ruft Tak auf
  133. {
  134. if( te.verarbeitet )
  135. return;
  136. if( Tak )
  137. te.verarbeitet |= Tak( takParam, this, te );
  138. if( nTak && te.verarbeitet )
  139. te.verarbeitet = nTak( ntakParam, this, te );
  140. }
  141. void Zeichnung::setPosition( const Punkt &pos ) // setzt die position
  142. {
  143. lockZeichnung();
  144. if( this->pos != pos )
  145. rend = 1;
  146. this->pos = pos;
  147. unlockZeichnung();
  148. }
  149. void Zeichnung::setX( int xPos )
  150. {
  151. lockZeichnung();
  152. if( pos.x != xPos )
  153. {
  154. rend = 1;
  155. pos.x = xPos;
  156. }
  157. unlockZeichnung();
  158. }
  159. void Zeichnung::setY( int yPos )
  160. {
  161. lockZeichnung();
  162. if( pos.y != yPos )
  163. {
  164. rend = 1;
  165. pos.y = yPos;
  166. }
  167. unlockZeichnung();
  168. }
  169. void Zeichnung::setSize( const Punkt &gr ) // setzt die Größe
  170. {
  171. lockZeichnung();
  172. if( this->gr != gr )
  173. rend = 1;
  174. this->gr = gr;
  175. unlockZeichnung();
  176. }
  177. void Zeichnung::setPosition( int x, int y ) // setzt die position
  178. {
  179. setPosition( Punkt( x, y ) );
  180. }
  181. void Zeichnung::setSize( int x, int y ) // setzt die Größe
  182. {
  183. setSize( Punkt( x, y ) );
  184. }
  185. bool Zeichnung::tick( double tickval )
  186. {
  187. bool r = rend;
  188. rend = 0;
  189. return r;
  190. }
  191. void Zeichnung::setStyle( __int64 style ) // setzt den Style des Text Feldes
  192. {
  193. if( this->style != style )
  194. {
  195. this->style = style;
  196. rend = 1;
  197. }
  198. }
  199. void Zeichnung::setStyle( __int64 style, bool add_remove )
  200. {
  201. if( add_remove && ( this->style | style ) != this->style )
  202. {
  203. this->style |= style;
  204. rend = 1;
  205. }
  206. else if( !add_remove && ( this->style & ~style ) != this->style )
  207. {
  208. if( toolTip && ( style | Style::Sichtbar ) == style )
  209. toolTip->setMausIn( 0 );
  210. this->style &= ~style;
  211. rend = 1;
  212. }
  213. }
  214. void Zeichnung::addStyle( __int64 style )
  215. {
  216. if( ( this->style | style ) != this->style )
  217. {
  218. this->style |= style;
  219. rend = 1;
  220. }
  221. }
  222. void Zeichnung::removeStyle( __int64 style )
  223. {
  224. if( ( this->style & ~style ) != this->style )
  225. {
  226. if( toolTip && ( style | Style::Sichtbar ) == style )
  227. toolTip->setMausIn( 0 );
  228. this->style &= ~style;
  229. rend = 1;
  230. }
  231. }
  232. void Zeichnung::render( Bild &zRObj )
  233. {
  234. if( toolTip && ( style | Style::Sichtbar ) == style )
  235. toolTip->setZeichnen();
  236. }
  237. // constant
  238. bool Zeichnung::hatMausEreignis() const // prüft, ob Mak gesetzt ist
  239. {
  240. return Mak != 0;
  241. }
  242. bool Zeichnung::hatTastaturEreignis() const // prüft, ob Tak gesetzt ist
  243. {
  244. return Tak != 0;
  245. }
  246. const Punkt &Zeichnung::getPosition() const // gibt die Position zurück
  247. {
  248. return pos;
  249. }
  250. const Punkt &Zeichnung::getSize() const // gibt die Größe zurück
  251. {
  252. return gr;
  253. }
  254. int Zeichnung::getBreite() const // gibt die Breite zurück
  255. {
  256. return gr.x;
  257. }
  258. int Zeichnung::getHeight() const // gibt die Höhe zurück
  259. {
  260. return gr.y;
  261. }
  262. int Zeichnung::getX() const // gibt X zurück
  263. {
  264. return pos.x;
  265. }
  266. int Zeichnung::getY() const // gibt Y zurück
  267. {
  268. return pos.y;
  269. }
  270. ToolTip *Zeichnung::getToolTip() const // gibt den ToolTip Text
  271. {
  272. return (ToolTip*)toolTip->getThis();
  273. }
  274. ToolTip *Zeichnung::zToolTip() const
  275. {
  276. return toolTip;
  277. }
  278. bool Zeichnung::hatStyle( __int64 style ) const // prüft, ob style vorhanden
  279. {
  280. return ( this->style | style ) == this->style;
  281. }
  282. bool Zeichnung::hatStyleNicht( __int64 style ) const // prüft, ob style nicht vorhanden
  283. {
  284. return ( this->style | style ) != this->style;
  285. }
  286. Zeichnung *Zeichnung::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
  287. {
  288. Zeichnung *obj = new Zeichnung();
  289. obj->setPosition( pos );
  290. obj->setSize( gr );
  291. obj->setMausEreignisParameter( makParam );
  292. obj->setTastaturEreignisParameter( takParam );
  293. obj->setMausEreignis( Mak );
  294. obj->setTastaturEreignis( Tak );
  295. if( toolTip )
  296. obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
  297. return obj;
  298. }
  299. // Inhalt der ZeichnungArray Klasse aus Zeichnung.h
  300. // Konstruktor
  301. ZeichnungArray::ZeichnungArray()
  302. : This( 0 ),
  303. next( 0 )
  304. {}
  305. // Destruktor
  306. ZeichnungArray::~ZeichnungArray()
  307. {
  308. delete next;
  309. }
  310. // nicht const
  311. bool ZeichnungArray::addZeichnung( Zeichnung *obj ) // Fügt ein Zeichnung hinzu
  312. {
  313. if( obj == This )
  314. return 0;
  315. if( !This )
  316. {
  317. This = obj;
  318. return 1;
  319. }
  320. if( !next )
  321. next = new ZeichnungArray();
  322. return next->addZeichnung( obj );
  323. }
  324. bool ZeichnungArray::removeZeichnung( Zeichnung *obj ) // Entfernt ein Zeichnung
  325. {
  326. if( obj == This )
  327. {
  328. if( index == 0 )
  329. {
  330. if( next )
  331. {
  332. This = next->getZeichnung();
  333. ZeichnungArray *tmp = next->getNext();
  334. next->setNext0();
  335. delete next;
  336. next = tmp;
  337. }
  338. else
  339. This = 0;
  340. return 0;
  341. }
  342. return 1;
  343. }
  344. if( !next )
  345. return 0;
  346. if( next->removeZeichnung( obj ) )
  347. {
  348. ZeichnungArray *tmp = next->getNext();
  349. next->setNext0();
  350. delete next;
  351. next = tmp;
  352. }
  353. return 0;
  354. }
  355. bool ZeichnungArray::removeZeichnung( int i ) // Entfernt das von diesem aus i-te Zeichnung
  356. {
  357. if( i == index )
  358. {
  359. if( index == 0 )
  360. {
  361. This = next->getZeichnung();
  362. ZeichnungArray *tmp = next->getNext();
  363. next->setNext0();
  364. delete next;
  365. next = tmp;
  366. return 0;
  367. }
  368. return 1;
  369. }
  370. if( !next )
  371. return 0;
  372. if( next->removeZeichnung( i ) )
  373. {
  374. ZeichnungArray *tmp = next->getNext();
  375. next->setNext0();
  376. delete next;
  377. next = tmp;
  378. }
  379. return 0;
  380. }
  381. void ZeichnungArray::setNext0() // Setzt das nächste Zeichnung zu 0
  382. {
  383. next = 0;
  384. }
  385. void ZeichnungArray::updateIndex( int i ) // aktualisiert die Index variable
  386. {
  387. index = i;
  388. if( next )
  389. next->updateIndex( i + 1 );
  390. }
  391. // constant
  392. ZeichnungArray *ZeichnungArray::getNext() const // gibt das nächste Zeichnung zurück
  393. {
  394. return next;
  395. }
  396. Zeichnung *ZeichnungArray::getZeichnung( int i ) const // gibt das von diesem aus i-te Zeichnung zurück
  397. {
  398. if( i == index )
  399. return This;
  400. if( !next )
  401. return 0;
  402. return next->getZeichnung( i );
  403. }
  404. Zeichnung *ZeichnungArray::getZeichnung() const // gibt das von diesem aus i-te Zeichnung zurück
  405. {
  406. return This;
  407. }
  408. int ZeichnungArray::getIndex() const // Gibt den Index zurück
  409. {
  410. return index;
  411. }
  412. void ZeichnungArray::sendMausAll( MausEreignis &me ) const // sendet me an alle volgenden Zeichnunge
  413. {
  414. if( next )
  415. next->sendMausAll( me );
  416. if( This )
  417. This->doMausEreignis( me );
  418. }
  419. void ZeichnungArray::sendTastaturAll( TastaturEreignis &te ) const // sendet te an alle volgenden Zeichnunge
  420. {
  421. if( next )
  422. next->sendTastaturAll( te );
  423. if( This )
  424. This->doTastaturEreignis( te );
  425. }
  426. void ZeichnungArray::render( Bild &zRObj )
  427. {
  428. if( This )
  429. This->render( zRObj );
  430. if( next )
  431. next->render( zRObj );
  432. }
  433. bool ZeichnungArray::tick( double tickval )
  434. {
  435. return ( This && This->tick( tickval ) ) | ( next && next->tick( tickval ) );
  436. }
  437. // Inhalt der ZeichnungHintergrund Klasse aus Zeichnung.h
  438. // Konstruktor
  439. ZeichnungHintergrund::ZeichnungHintergrund()
  440. : Zeichnung()
  441. {
  442. hintergrundFarbe = 0xFF000000;
  443. rahmen = 0;
  444. hintergrundBild = 0;
  445. hintergrundFeld = 0;
  446. horizontalScrollBar = 0;
  447. vertikalScrollBar = 0;
  448. innenPosition.x = 0;
  449. innenPosition.y = 0;
  450. innenSize.x = 0;
  451. innenSize.y = 0;
  452. }
  453. // Destruktor
  454. ZeichnungHintergrund::~ZeichnungHintergrund()
  455. {
  456. if( rahmen )
  457. rahmen->release();
  458. if( hintergrundBild )
  459. hintergrundBild->release();
  460. if( hintergrundFeld )
  461. hintergrundFeld->release();
  462. if( horizontalScrollBar )
  463. horizontalScrollBar->release();
  464. if( vertikalScrollBar )
  465. vertikalScrollBar->release();
  466. }
  467. void ZeichnungHintergrund::setHintergrundBild( Bild *bild ) // setzt das Hintergrund Bild
  468. {
  469. if( !hintergrundBild )
  470. hintergrundBild = new Bild();
  471. hintergrundBild->neuBild( bild->getBreite(), bild->getHeight(), 0 );
  472. int *buff1 = hintergrundBild->getBuffer();
  473. int *buff2 = bild->getBuffer();
  474. for( int i = 0; i < bild->getBreite() * bild->getHeight(); ++i )
  475. buff1[ i ] = buff2[ i ];
  476. bild->release();
  477. rend = 1;
  478. }
  479. void ZeichnungHintergrund::setHintergrundBildZ( Bild *bild ) // setzt einen Zeiger zum Hintergrund Bild
  480. {
  481. if( hintergrundBild != bild )
  482. {
  483. if( hintergrundBild )
  484. hintergrundBild->release();
  485. hintergrundBild = bild;
  486. rend = 1;
  487. }
  488. }
  489. void ZeichnungHintergrund::setHintergrundFarbe( int fc ) // setzt die Hintergrundfarbe
  490. {
  491. if( hintergrundFarbe != fc )
  492. {
  493. hintergrundFarbe = fc;
  494. rend = 1;
  495. }
  496. }
  497. void ZeichnungHintergrund::setAlphaFeldZ( AlphaFeld *buff ) // setzt einen Zeiger zum Hintergrund Buffer
  498. {
  499. if( hintergrundFeld != buff )
  500. {
  501. if( hintergrundFeld )
  502. hintergrundFeld->release();
  503. hintergrundFeld = buff;
  504. rend = 1;
  505. }
  506. }
  507. void ZeichnungHintergrund::setAlphaFeldStrength( int st ) // setzt die Stärke des Hintergrund Buffers
  508. {
  509. if( !hintergrundFeld )
  510. {
  511. hintergrundFeld = new AlphaFeld();
  512. rend = 1;
  513. }
  514. if( hintergrundFeld->getStrength() != st )
  515. {
  516. hintergrundFeld->setStrength( st );
  517. rend = 1;
  518. }
  519. }
  520. void ZeichnungHintergrund::setAlphaFeldFarbe( int fc ) // setzt die Farbe des Hintergrund Buffers
  521. {
  522. if( !hintergrundFeld )
  523. {
  524. hintergrundFeld = new AlphaFeld();
  525. rend = 1;
  526. }
  527. if( hintergrundFeld->getFarbe() != fc )
  528. {
  529. hintergrundFeld->setFarbe( fc );
  530. rend = 1;
  531. }
  532. }
  533. void ZeichnungHintergrund::setLinienRahmenZ( LRahmen *ram ) // setzt einen Zeiger zum Rahmen
  534. {
  535. if( rahmen != ram )
  536. {
  537. if( rahmen )
  538. rahmen->release();
  539. rahmen = ram;
  540. rend = 1;
  541. }
  542. }
  543. void ZeichnungHintergrund::setLinienRahmenBreite( int br ) // setzt die Breite des Rahmens
  544. {
  545. if( !rahmen )
  546. {
  547. rahmen = new LRahmen();
  548. rend = 1;
  549. }
  550. if( rahmen->getRBreite() != br )
  551. {
  552. rahmen->setRamenBreite( br );
  553. rend = 1;
  554. }
  555. }
  556. void ZeichnungHintergrund::setLinienRahmenFarbe( int fc ) // setzt die Farbe des Rahmens
  557. {
  558. if( !rahmen )
  559. {
  560. rahmen = new LRahmen();
  561. rend = 1;
  562. }
  563. if( rahmen->getFarbe() != fc )
  564. {
  565. rahmen->setFarbe( fc );
  566. rend = 1;
  567. }
  568. }
  569. void ZeichnungHintergrund::setVertikalKlickScroll( int ks ) // setzt die vertikale Scroll geschwindigkeit
  570. {
  571. if( !vertikalScrollBar )
  572. {
  573. vertikalScrollBar = new VScrollBar();
  574. rend = 1;
  575. }
  576. if( vertikalScrollBar->getKlickScroll() != ks )
  577. {
  578. vertikalScrollBar->setKlickScroll( ks );
  579. rend = 1;
  580. }
  581. }
  582. void ZeichnungHintergrund::setVertikalScrollPos( int pos ) // setzt die vertikale Scroll Position
  583. {
  584. if( !vertikalScrollBar )
  585. {
  586. vertikalScrollBar = new VScrollBar();
  587. rend = 1;
  588. }
  589. if( vertikalScrollBar && vertikalScrollBar->getScroll() != pos )
  590. {
  591. vertikalScrollBar->scroll( pos );
  592. rend = 1;
  593. }
  594. }
  595. void ZeichnungHintergrund::setVertikalScrollFarbe( int f, int bgF ) // setzt die scroll Farbe
  596. {
  597. if( !vertikalScrollBar )
  598. {
  599. vertikalScrollBar = new VScrollBar();
  600. rend = 1;
  601. }
  602. if( vertikalScrollBar && ( vertikalScrollBar->getFarbe() != f || vertikalScrollBar->getBgFarbe() != bgF ) )
  603. {
  604. vertikalScrollBar->setFarbe( f );
  605. vertikalScrollBar->setBgFarbe( bgF, bgF != 0 );
  606. rend = 1;
  607. }
  608. }
  609. void ZeichnungHintergrund::setHorizontalKlickScroll( int ks ) // setzt die horizontale Scroll geschwindigkeit
  610. {
  611. if( !horizontalScrollBar )
  612. {
  613. horizontalScrollBar = new HScrollBar();
  614. rend = 1;
  615. }
  616. if( horizontalScrollBar && horizontalScrollBar->getKlickScroll() != ks )
  617. {
  618. horizontalScrollBar->setKlickScroll( ks );
  619. rend = 1;
  620. }
  621. }
  622. void ZeichnungHintergrund::setHorizontalScrollPos( int pos ) // setzt die horizontale Scroll Position
  623. {
  624. if( !horizontalScrollBar )
  625. {
  626. horizontalScrollBar = new HScrollBar();
  627. rend = 1;
  628. }
  629. if( horizontalScrollBar && horizontalScrollBar->getScroll() != pos )
  630. {
  631. horizontalScrollBar->scroll( pos );
  632. rend = 1;
  633. }
  634. }
  635. void ZeichnungHintergrund::setHorizontalScrollFarbe( int f, int bgF ) // setzt die scroll Farbe
  636. {
  637. if( !horizontalScrollBar )
  638. {
  639. horizontalScrollBar = new HScrollBar();
  640. rend = 1;
  641. }
  642. if( horizontalScrollBar && ( horizontalScrollBar->getFarbe() != f || horizontalScrollBar->getBgFarbe() != bgF ) )
  643. {
  644. horizontalScrollBar->setFarbe( f );
  645. horizontalScrollBar->setBgFarbe( bgF, bgF != 0 );
  646. rend = 1;
  647. }
  648. }
  649. bool ZeichnungHintergrund::tick( double tickVal )
  650. {
  651. if( vertikalScrollBar && hatStyle( Style::VScroll ) )
  652. rend |= vertikalScrollBar->getRend();
  653. if( horizontalScrollBar && hatStyle( Style::HScroll ) )
  654. rend |= horizontalScrollBar->getRend();
  655. return Zeichnung::tick( tickVal );
  656. }
  657. void ZeichnungHintergrund::render( Bild &rObj )
  658. {
  659. innenPosition.x = pos.x;
  660. innenPosition.y = pos.y;
  661. innenSize.x = gr.x;
  662. innenSize.y = gr.y;
  663. if( hatStyleNicht( Style::Sichtbar ) )
  664. return;
  665. lockZeichnung();
  666. if( !rObj.setDrawOptions( pos.x, pos.y, gr.x, gr.y ) )
  667. {
  668. unlockZeichnung();
  669. return;
  670. }
  671. Zeichnung::render( rObj );
  672. int rbr = 0;
  673. if( hatStyle( Style::Rahmen ) && rahmen )
  674. {
  675. rahmen->setSize( gr );
  676. rahmen->render( rObj );
  677. rbr = rahmen->getRBreite();
  678. }
  679. innenPosition.x += rbr;
  680. innenPosition.y += rbr;
  681. innenSize.x -= rbr * 2;
  682. innenSize.y -= rbr * 2;
  683. if( !rObj.setDrawOptions( rbr, rbr, gr.x - rbr * 2, gr.y - rbr * 2 ) )
  684. {
  685. rObj.releaseDrawOptions();
  686. unlockZeichnung();
  687. return;
  688. }
  689. bool vs = vertikalScrollBar && hatStyle( Style::VScroll );
  690. bool hs = horizontalScrollBar && hatStyle( Style::HScroll );
  691. if( vs )
  692. {
  693. vertikalScrollBar->render( gr.x - rbr * 2 - 15, 0, 15, gr.y - rbr * 2, rObj );
  694. innenSize.x -= 15;
  695. if( hs )
  696. {
  697. horizontalScrollBar->render( 0, gr.y - rbr * 2 - 15, gr.x - rbr * 2 - 15, 15, rObj );
  698. innenSize.y -= 15;
  699. if( !rObj.setDrawOptions( 0, 0, gr.x - rbr * 2 - 15, gr.y - rbr * 2 - 15 ) )
  700. {
  701. rObj.releaseDrawOptions();
  702. rObj.releaseDrawOptions();
  703. unlockZeichnung();
  704. return;
  705. }
  706. horizontalScrollBar->update( horizontalScrollBar->getScrollData()->max, innenSize.x );
  707. }
  708. else
  709. {
  710. if( !rObj.setDrawOptions( 0, 0, gr.x - rbr * 2 - 15, gr.y - rbr * 2 ) )
  711. {
  712. rObj.releaseDrawOptions();
  713. rObj.releaseDrawOptions();
  714. unlockZeichnung();
  715. return;
  716. }
  717. }
  718. vertikalScrollBar->update( vertikalScrollBar->getScrollData()->max, innenSize.y );
  719. }
  720. else if( hs )
  721. {
  722. horizontalScrollBar->render( rbr, gr.y - rbr * 2 - 15, gr.x - rbr * 2, 15, rObj );
  723. innenSize.y -= 15;
  724. if( !rObj.setDrawOptions( 0, 0, gr.x - rbr * 2, gr.y - rbr * 2 - 15 ) )
  725. {
  726. rObj.releaseDrawOptions();
  727. rObj.releaseDrawOptions();
  728. unlockZeichnung();
  729. return;
  730. }
  731. }
  732. if( hatStyle( Style::Hintergrund ) )
  733. {
  734. if( hatStyle( Style::HAlpha ) )
  735. rObj.alphaRegion( 0, 0, gr.x - rbr * 2, gr.y - rbr * 2, hintergrundFarbe );
  736. else
  737. rObj.fillRegion( 0, 0, gr.x - rbr * 2, gr.y - rbr * 2, hintergrundFarbe );
  738. if( hatStyle( Style::HBild ) && hintergrundBild )
  739. {
  740. if( hatStyle( Style::HAlpha ) )
  741. rObj.alphaBildSkall( 0, 0, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild );
  742. else
  743. rObj.drawBildSkall( 0, 0, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild );
  744. }
  745. }
  746. if( hatStyle( Style::Buffered ) && hintergrundFeld )
  747. {
  748. hintergrundFeld->setSize( gr.x - rbr * 2, gr.y - rbr * 2 );
  749. hintergrundFeld->render( rObj );
  750. }
  751. if( vs || hs )
  752. rObj.releaseDrawOptions();
  753. rObj.releaseDrawOptions();
  754. rObj.releaseDrawOptions();
  755. unlockZeichnung();
  756. }
  757. Bild *ZeichnungHintergrund::getHintergrundBild() const // gibt getThis vom Hintergrund Bild zurück
  758. {
  759. if( !hintergrundBild )
  760. return 0;
  761. return hintergrundBild->getThis();
  762. }
  763. Bild *ZeichnungHintergrund::zHintergrundBild() const // gibt das Hintergrund Bild zurück
  764. {
  765. return hintergrundBild;
  766. }
  767. int ZeichnungHintergrund::getHintergrundFarbe() const // giebt getThis der Hintergrundfarbe zurück
  768. {
  769. return hintergrundFarbe;
  770. }
  771. AlphaFeld *ZeichnungHintergrund::getAlphaFeld() const // gibt getThir vom Hintergrund Buffer zurück
  772. {
  773. if( !hintergrundFeld )
  774. return 0;
  775. return hintergrundFeld->getThis();
  776. }
  777. AlphaFeld *ZeichnungHintergrund::zAlphaFeld() const // gibt den Hintergrund Buffer zurück
  778. {
  779. return hintergrundFeld;
  780. }
  781. int ZeichnungHintergrund::getAlphaFeldStrength() const // gibt die Stärke des Hintergrund Buffers zurück
  782. {
  783. if( !hintergrundFeld )
  784. return 0;
  785. return hintergrundFeld->getStrength();
  786. }
  787. int ZeichnungHintergrund::getAlphaFeldFarbe() const // gibt getThis von der Farbe des Hintergrund Buffers zurück
  788. {
  789. return hintergrundFeld->getFarbe();
  790. }
  791. LRahmen *ZeichnungHintergrund::getLinienRahmen() const // gibt getThis des Rahmens zurück
  792. {
  793. if( !rahmen )
  794. return 0;
  795. return rahmen->getThis();
  796. }
  797. LRahmen *ZeichnungHintergrund::zLinienRahmen() const // gibt den Rahmen zurück
  798. {
  799. return rahmen;
  800. }
  801. int ZeichnungHintergrund::getLinienRahmenBreite() const // gibt die Breite des Rahmens zurück
  802. {
  803. if( !rahmen || hatStyleNicht( Style::Rahmen ) )
  804. return 0;
  805. return rahmen->getRBreite();
  806. }
  807. int ZeichnungHintergrund::getLinienRahmenFarbe() const // gibt getThis der Farbe des Rahmens zurück
  808. {
  809. return rahmen->getFarbe();
  810. }
  811. int ZeichnungHintergrund::getVertikalKlickScroll() const
  812. {
  813. return vertikalScrollBar ? vertikalScrollBar->getKlickScroll() : 0;
  814. }
  815. int ZeichnungHintergrund::getVertikalScrollPos() const
  816. {
  817. return vertikalScrollBar ? vertikalScrollBar->getScroll() : 0;
  818. }
  819. int ZeichnungHintergrund::getVertikalScrollFarbe() const
  820. {
  821. return vertikalScrollBar ? vertikalScrollBar->getFarbe() : 0;
  822. }
  823. int ZeichnungHintergrund::getVertikalScrollHintergrund() const
  824. {
  825. return vertikalScrollBar ? vertikalScrollBar->getBgFarbe() : 0;
  826. }
  827. int ZeichnungHintergrund::getHorizontalKlickScroll() const
  828. {
  829. return horizontalScrollBar ? horizontalScrollBar->getKlickScroll() : 0;
  830. }
  831. int ZeichnungHintergrund::getHorizontalScrollPos() const
  832. {
  833. return horizontalScrollBar ? horizontalScrollBar->getScroll() : 0;
  834. }
  835. int ZeichnungHintergrund::getHorizontalScrollFarbe() const
  836. {
  837. return horizontalScrollBar ? horizontalScrollBar->getFarbe() : 0;
  838. }
  839. int ZeichnungHintergrund::getHorizontalScrollHintergrund() const
  840. {
  841. return horizontalScrollBar ? horizontalScrollBar->getBgFarbe() : 0;
  842. }
  843. Zeichnung *ZeichnungHintergrund::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
  844. {
  845. ZeichnungHintergrund *obj = new ZeichnungHintergrund();
  846. obj->setPosition( pos );
  847. obj->setSize( gr );
  848. obj->setMausEreignisParameter( makParam );
  849. obj->setTastaturEreignisParameter( takParam );
  850. obj->setMausEreignis( Mak );
  851. obj->setTastaturEreignis( Tak );
  852. if( toolTip )
  853. obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
  854. obj->setStyle( style );
  855. obj->setHintergrundFarbe( hintergrundFarbe );
  856. if( hintergrundFeld )
  857. obj->setAlphaFeldZ( (AlphaFeld*)hintergrundFeld->dublizieren() );
  858. if( rahmen )
  859. obj->setLinienRahmenZ( (LRahmen*)rahmen->dublizieren() );
  860. if( hintergrundBild )
  861. obj->setHintergrundBild( hintergrundBild->getThis() );
  862. if( vertikalScrollBar )
  863. {
  864. obj->setVertikalKlickScroll( vertikalScrollBar->getKlickScroll() );
  865. obj->setVertikalScrollPos( vertikalScrollBar->getScroll() );
  866. obj->setVertikalScrollFarbe( vertikalScrollBar->getFarbe(), vertikalScrollBar->getBgFarbe() );
  867. }
  868. if( horizontalScrollBar )
  869. {
  870. obj->setHorizontalKlickScroll( horizontalScrollBar->getKlickScroll() );
  871. obj->setHorizontalScrollPos( horizontalScrollBar->getScroll() );
  872. obj->setHorizontalScrollFarbe( horizontalScrollBar->getFarbe(), horizontalScrollBar->getBgFarbe() );
  873. }
  874. return obj;
  875. }