Zeichnung.cpp 24 KB

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