Zeichnung.cpp 24 KB

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