Knopf.cpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872
  1. #include "Knopf.h"
  2. #include "MausEreignis.h"
  3. #include "TastaturEreignis.h"
  4. #include "Bild.h"
  5. #include "AlphaFeld.h"
  6. #include "Text.h"
  7. #include "Schrift.h"
  8. #include "Rahmen.h"
  9. #include "Scroll.h"
  10. #include "Datei.h"
  11. #include "DateiSystem.h"
  12. #include "Globals.h"
  13. #include "ToolTip.h"
  14. using namespace Framework;
  15. // Inhalt der Knopf Klasse aus Knopf.h
  16. // Konstruktor
  17. Knopf::Knopf()
  18. : TextFeld(),
  19. klickFarbe( 0xFF000000 ),
  20. klickBild( 0 ),
  21. klickBuffer( 0 ),
  22. klickIndex( 0 ),
  23. ref( 1 )
  24. {
  25. style = Style::Erlaubt | Style::Buffered | Style::KlickBuffer | Style::Rahmen;
  26. this->setMausEreignis( _ret1ME );
  27. setSchriftFarbe( 0xFFFFFFFF );
  28. setSchriftGröße( 12 );
  29. setLinienRahmenBreite( 2 );
  30. setLinienRahmenFarbe( 0xFF00FF00 );
  31. setAlphaFeldFarbe( 0x5500FF00 );
  32. setAlphaFeldStärke( -5 );
  33. setKBFarbe( 0xFF000000 );
  34. setKBStärke( 20 );
  35. addStyle( TextFeld::Style::Center | TextFeld::Style::Mehrfarbig );
  36. }
  37. // Destruktor
  38. Knopf::~Knopf()
  39. {
  40. if( klickBuffer )
  41. klickBuffer->release();
  42. if( klickBild )
  43. klickBild->release();
  44. }
  45. // nicht constant
  46. void Knopf::setKlickFarbe( int fc ) // setzt die Klick Farbe
  47. {
  48. klickFarbe = fc;
  49. rend = 1;
  50. }
  51. void Knopf::setKlickBild( Bild *bild ) // setzt das Klick Bild
  52. {
  53. if( bild )
  54. {
  55. if( !klickBild )
  56. klickBild = new Bild();
  57. klickBild->neuBild( bild->getBreite(), bild->getHöhe(), 0 );
  58. int *buff1 = klickBild->getBuffer();
  59. int *buff2 = bild->getBuffer();
  60. for( int i = 0; i < bild->getBreite() * bild->getHöhe(); ++i )
  61. buff1[ i ] = buff2[ i ];
  62. bild->release();
  63. rend = 1;
  64. }
  65. }
  66. void Knopf::setKlickBildZ( Bild *bild ) // setzt einen Zeiger zum Klick Bild
  67. {
  68. if( klickBild )
  69. klickBild->release();
  70. klickBild = bild;
  71. rend = 1;
  72. }
  73. void Knopf::setKBZ( AlphaFeld *af )
  74. {
  75. if( klickBuffer )
  76. klickBuffer->release();
  77. klickBuffer = af;
  78. rend = 1;
  79. }
  80. void Knopf::setKBStärke( int st ) // setzt die Stärke des Klick Buffers
  81. {
  82. if( !klickBuffer )
  83. klickBuffer = new AlphaFeld();
  84. klickBuffer->setStärke( st );
  85. rend = 1;
  86. }
  87. void Knopf::setKBFarbe( int fc ) // setzt die Farbe des Klick Buffers
  88. {
  89. if( !klickBuffer )
  90. klickBuffer = new AlphaFeld();
  91. klickBuffer->setFarbe( fc );
  92. rend = 1;
  93. }
  94. void Knopf::doMausEreignis( MausEreignis &me ) // Maus Ereignis
  95. {
  96. bool nmakc = !me.verarbeitet;
  97. if( hatStyleNicht( Style::Erlaubt ) || hatStyleNicht( Style::Sichtbar ) )
  98. {
  99. mausIn = 0;
  100. if( toolTip )
  101. toolTip->setMausIn( 0 );
  102. return;
  103. }
  104. if( me.verarbeitet || !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) )
  105. {
  106. if( mausIn )
  107. {
  108. mausIn = 0;
  109. if( toolTip )
  110. toolTip->setMausIn( 0 );
  111. MausEreignis me2;
  112. me2.id = ME_Verlässt;
  113. me2.mx = me.mx;
  114. me2.my = me.my;
  115. me2.verarbeitet = 0;
  116. doMausEreignis( me2 );
  117. return;
  118. }
  119. }
  120. if( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Verlässt )
  121. {
  122. if( toolTip )
  123. toolTip->setMausIn( 0 );
  124. return;
  125. }
  126. if( !mausIn && me.id != ME_Verlässt && !me.verarbeitet )
  127. {
  128. mausIn = 1;
  129. if( toolTip )
  130. toolTip->setMausIn( 1 );
  131. MausEreignis me2;
  132. me2.id = ME_Betritt;
  133. me2.mx = me.mx;
  134. me2.my = me.my;
  135. me2.verarbeitet = 0;
  136. doMausEreignis( me2 );
  137. }
  138. ++ref;
  139. me.mx -= pos.x, me.my -= pos.y;
  140. if( Mak && ( me.verarbeitet || Mak( makParam, this, me ) ) )
  141. {
  142. if( me.id == ME_Betritt )
  143. {
  144. klickIndex = MausStand[ M_Links ];
  145. if( klickIndex )
  146. rend = 1;
  147. }
  148. if( me.id == ME_RLinks || me.id == ME_Verlässt )
  149. {
  150. if( klickIndex )
  151. rend = 1;
  152. klickIndex = 0;
  153. }
  154. if( !me.verarbeitet )
  155. {
  156. if( me.id == ME_PLinks )
  157. {
  158. klickIndex = 1;
  159. rend = 1;
  160. }
  161. me.verarbeitet = 1;
  162. }
  163. }
  164. if( nmakc && me.verarbeitet && nMak )
  165. me.verarbeitet = nMak( nmakParam, this, me );
  166. me.mx += pos.x, me.my += pos.y;
  167. release();
  168. }
  169. void Knopf::render( Bild &zRObj ) // zeichenet nach zRObj
  170. {
  171. if( !hatStyle( Style::Sichtbar ) )
  172. return;
  173. addStyle( TextFeld::Style::Center );
  174. löscheStyle( Style::VScroll | Style::HScroll );
  175. bool rA = 0;
  176. if( !hatStyle( Style::Erlaubt ) )
  177. {
  178. zRObj.setAlpha( 0x20 );
  179. rA = 1;
  180. }
  181. __super::render( zRObj );
  182. if( !zRObj.setDrawOptions( innenPosition, innenGröße ) )
  183. {
  184. if( rA )
  185. zRObj.releaseAlpha();
  186. return;
  187. }
  188. if( hatStyle( Style::Sichtbar ) && klickIndex == 1 )
  189. {
  190. if( hatStyle( Style::KlickFarbe ) )
  191. {
  192. if( hatStyle( Style::KlickAlpha ) )
  193. zRObj.alphaRegion( 0, 0, innenGröße.x, innenGröße.y, klickFarbe );
  194. else
  195. zRObj.füllRegion( 0, 0, innenGröße.x, innenGröße.y, klickFarbe );
  196. }
  197. if( hatStyle( Style::KlickBild ) && klickBild )
  198. {
  199. if( hatStyle( Style::KlickAlpha ) )
  200. zRObj.alphaBild( 0, 0, innenGröße.x, innenGröße.y, *klickBild );
  201. else
  202. zRObj.drawBild( 0, 0, innenGröße.x, innenGröße.y, *klickBild );
  203. }
  204. if( hatStyle( Style::KlickBuffer ) && klickBuffer )
  205. {
  206. klickBuffer->setGröße( innenGröße.x, innenGröße.y );
  207. klickBuffer->render( zRObj );
  208. }
  209. }
  210. if( rA )
  211. zRObj.releaseAlpha();
  212. zRObj.releaseDrawOptions();
  213. }
  214. // constant
  215. int Knopf::getKlickFarbe() const // gibt getThis der Klick Farbe zurück
  216. {
  217. return klickFarbe;
  218. }
  219. Bild *Knopf::getKlickBild() const // gibt getThis des Klick Bildes zurück
  220. {
  221. if( !klickBild )
  222. return 0;
  223. return klickBild->getThis();
  224. }
  225. Bild *Knopf::zKlickBild() const // gibt einen Zeiger zum Klick Bild zurück
  226. {
  227. return klickBild;
  228. }
  229. AlphaFeld *Knopf::getKB() const // gibt getThis des Klick Buffers zurück
  230. {
  231. if( !klickBuffer )
  232. return 0;
  233. return klickBuffer->getThis();
  234. }
  235. AlphaFeld *Knopf::zKB() const // gibt den Klick Buffer zurück
  236. {
  237. return klickBuffer;
  238. }
  239. int Knopf::getKBFarbe() const // gibt getThis der Farbe des Klick Buffers zurück
  240. {
  241. if( !klickBuffer )
  242. return 0;
  243. return klickBuffer->getFarbe();
  244. }
  245. int Knopf::getKBStärke() const // gibt die Stärke des Klickbuffers zurück
  246. {
  247. if( !klickBuffer )
  248. return 0;
  249. return klickBuffer->getStärke();
  250. }
  251. Zeichnung *Knopf::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
  252. {
  253. Knopf *obj = new Knopf();
  254. obj->setPosition( pos );
  255. obj->setGröße( gr );
  256. obj->setMausEreignisParameter( makParam );
  257. obj->setTastaturEreignisParameter( takParam );
  258. obj->setMausEreignis( Mak );
  259. obj->setTastaturEreignis( Tak );
  260. if( toolTip )
  261. obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
  262. obj->setStyle( style );
  263. obj->setSchriftGröße( getSchriftGröße() );
  264. if( zSchrift() )
  265. obj->setSchriftZ( getSchrift() );
  266. if( zText() )
  267. obj->setText( zText()->getText() );
  268. obj->setHintergrundFarbe( hintergrundFarbe );
  269. obj->setSchriftFarbe( getSchriftFarbe() );
  270. if( hintergrundFeld )
  271. obj->setAlphaFeldZ( (AlphaFeld*)hintergrundFeld->dublizieren() );
  272. if( rahmen )
  273. obj->setLinienRahmenZ( (LRahmen*)rahmen->dublizieren() );
  274. if( hintergrundBild )
  275. obj->setHintergrundBild( hintergrundBild->getThis() );
  276. if( vertikalScrollBar )
  277. {
  278. obj->setVertikalKlickScroll( vertikalScrollBar->getKlickScroll() );
  279. obj->setVertikalScrollPos( vertikalScrollBar->getScroll() );
  280. obj->setVertikalScrollFarbe( vertikalScrollBar->getFarbe(), vertikalScrollBar->getBgFarbe() );
  281. }
  282. if( horizontalScrollBar )
  283. {
  284. obj->setHorizontalKlickScroll( horizontalScrollBar->getKlickScroll() );
  285. obj->setHorizontalScrollPos( horizontalScrollBar->getScroll() );
  286. obj->setHorizontalScrollFarbe( horizontalScrollBar->getFarbe(), horizontalScrollBar->getBgFarbe() );
  287. }
  288. obj->setSchowChar( getShowChar() );
  289. obj->setAuswahl( getFärbungPos(), getCursorPos() );
  290. obj->setKlickFarbe( klickFarbe );
  291. if( klickBild )
  292. obj->setKlickBild( klickBild->getThis() );
  293. if( klickBuffer )
  294. obj->setKBZ( (AlphaFeld*)klickBuffer->dublizieren() );
  295. return obj;
  296. }
  297. // Reference Counting
  298. Knopf *Knopf::getThis()
  299. {
  300. ++ref;
  301. return this;
  302. }
  303. Knopf *Knopf::release()
  304. {
  305. --ref;
  306. if( ref == 0 )
  307. delete this;
  308. return 0;
  309. }
  310. // Inhalt der KontrollKnopf Klasse aus Knopf.h
  311. // Konstruktor
  312. KontrollKnopf::KontrollKnopf()
  313. : ZeichnungHintergrund(),
  314. txt( 0 ),
  315. sTxt( 0 ),
  316. sBgF( 0 ),
  317. kBgF( 0 ),
  318. sBgB( 0 ),
  319. kBgB( 0 ),
  320. sAf( 0 ),
  321. kAf( 0 ),
  322. kasten( 0 ),
  323. sKasten( 0 ),
  324. schrift( 0 ),
  325. sF( 0xFFFFFFFF ),
  326. sGr( 12 ),
  327. ref( 1 )
  328. {
  329. style = Style::Erlaubt | Style::KlickBuffer;
  330. setKAFFarbe( 0x00007500 );
  331. setKAFStärke( -30 );
  332. }
  333. // Destruktor
  334. KontrollKnopf::~KontrollKnopf()
  335. {
  336. if( txt )
  337. txt->release();
  338. if( sTxt )
  339. sTxt->release();
  340. if( sBgB )
  341. sBgB->release();
  342. if( kBgB )
  343. kBgB->release();
  344. if( sAf )
  345. sAf->release();
  346. if( kAf )
  347. kAf->release();
  348. if( kasten )
  349. kasten->release();
  350. if( sKasten )
  351. sKasten->release();
  352. if( schrift )
  353. schrift->release();
  354. }
  355. // nicht constant
  356. void KontrollKnopf::setTextZ( Text *txt ) // setzt den Text
  357. {
  358. if( this->txt )
  359. this->txt->release();
  360. this->txt = txt;
  361. rend = 1;
  362. }
  363. void KontrollKnopf::setText( Text *txt )
  364. {
  365. if( !this->txt )
  366. this->txt = new Text();
  367. this->txt->setText( txt->getText() );
  368. txt->release();
  369. rend = 1;
  370. }
  371. void KontrollKnopf::setText( const char *txt )
  372. {
  373. if( !this->txt )
  374. this->txt = new Text();
  375. this->txt->setText( txt );
  376. rend = 1;
  377. }
  378. void KontrollKnopf::setSTextZ( Text *txt ) // setzt den Text bei Selectiert
  379. {
  380. if( sTxt )
  381. sTxt->release();
  382. sTxt = txt;
  383. rend = 1;
  384. }
  385. void KontrollKnopf::setSText( Text *txt )
  386. {
  387. if( !sTxt )
  388. sTxt = new Text();
  389. sTxt->setText( txt->getText() );
  390. txt->release();
  391. rend = 1;
  392. }
  393. void KontrollKnopf::setSText( const char *txt )
  394. {
  395. if( !sTxt )
  396. sTxt = new Text();
  397. sTxt->setText( txt );
  398. rend = 1;
  399. }
  400. void KontrollKnopf::setSchriftZ( Schrift *schrift ) // setzt die Schrift
  401. {
  402. if( this->schrift )
  403. this->schrift->release();
  404. this->schrift = schrift;
  405. rend = 1;
  406. }
  407. void KontrollKnopf::setSFarbe( int f ) // setzt die Schrift Farbe
  408. {
  409. sF = f;
  410. rend = 1;
  411. }
  412. void KontrollKnopf::setSGröße( int gr ) // setzt die Schrift Größe
  413. {
  414. sGr = gr;
  415. rend = 1;
  416. }
  417. void KontrollKnopf::setSBgFarbe( int f ) // setzt die Select Hintergrundfarbe
  418. {
  419. sBgF = f;
  420. rend = 1;
  421. }
  422. void KontrollKnopf::setKBgFarbe( int f ) // setzt die Klick Hintergrundfarbe
  423. {
  424. kBgF = f;
  425. rend = 1;
  426. }
  427. void KontrollKnopf::setSBgBildZ( Bild *b ) // setzt das Select Hintergrundbild
  428. {
  429. if( sBgB )
  430. sBgB->release();
  431. sBgB = b;
  432. rend = 1;
  433. }
  434. void KontrollKnopf::setSBgBild( Bild *b )
  435. {
  436. if( !sBgB )
  437. sBgB = new Bild();
  438. sBgB->neuBild( b->getBreite(), b->getHöhe(), 0 );
  439. sBgB->drawBild( 0, 0, b->getBreite(), b->getHöhe(), *b );
  440. b->release();
  441. rend = 1;
  442. }
  443. void KontrollKnopf::setKBgBildZ( Bild *b ) // setzt das Klick Hintergrundbild
  444. {
  445. if( kBgB )
  446. kBgB->release();
  447. kBgB = b;
  448. rend = 1;
  449. }
  450. void KontrollKnopf::setKBgBild( Bild *b )
  451. {
  452. if( !kBgB )
  453. kBgB = new Bild();
  454. kBgB->neuBild( b->getBreite(), b->getHöhe(), 0 );
  455. kBgB->drawBild( 0, 0, b->getBreite(), b->getHöhe(), *b );
  456. b->release();
  457. rend = 1;
  458. }
  459. void KontrollKnopf::setSAlphaFeldZ( AlphaFeld *af ) // setzt das Select Alpha Feld
  460. {
  461. if( sAf )
  462. sAf->release();
  463. sAf = af;
  464. rend = 1;
  465. }
  466. void KontrollKnopf::setSAFFarbe( int f ) // setzt die Select Alphafeld Farbe
  467. {
  468. if( !sAf )
  469. sAf = new AlphaFeld();
  470. sAf->setFarbe( f );
  471. rend = 1;
  472. }
  473. void KontrollKnopf::setSAFStärke( int st ) // setzt die Select AlphaFeld Stärke
  474. {
  475. if( !sAf )
  476. sAf = new AlphaFeld();
  477. sAf->setStärke( st );
  478. rend = 1;
  479. }
  480. void KontrollKnopf::setKAlphaFeldZ( AlphaFeld *af ) // setzt das Klick Alpha Feld
  481. {
  482. if( kAf )
  483. kAf->release();
  484. kAf = af;
  485. rend = 1;
  486. }
  487. void KontrollKnopf::setKAFFarbe( int f ) // setzt die Klick Alphafeld Farbe
  488. {
  489. if( !kAf )
  490. kAf = new AlphaFeld();
  491. kAf->setFarbe( f );
  492. rend = 1;
  493. }
  494. void KontrollKnopf::setKAFStärke( int st ) // setzt die Klick AlphaFeld Stärke
  495. {
  496. if( !kAf )
  497. kAf = new AlphaFeld();
  498. kAf->setStärke( st );
  499. rend = 1;
  500. }
  501. void KontrollKnopf::loadData( LTDBDatei *dat ) // läht die Systembilder
  502. {
  503. if( DateiExistiert( new Text( "data/normal.ltdb" ) ) && ( !dat || !dat->istOffen() ) )
  504. {
  505. LTDBDatei *dat = new LTDBDatei();
  506. dat->setDatei( new Text( "data/normal.ltdb" ) );
  507. dat->leseDaten( 0 );
  508. kasten = dat->laden( 0, new Text( "kasten.gif" ) );
  509. sKasten = dat->laden( 0, new Text( "skasten.gif" ) );
  510. dat->release();
  511. }
  512. else
  513. {
  514. kasten = dat->laden( 0, new Text( "kasten.gif" ) );
  515. sKasten = dat->laden( 0, new Text( "skasten.gif" ) );
  516. }
  517. rend = 1;
  518. }
  519. void KontrollKnopf::loadData( const char *ltdb ) // läht die Systembilder
  520. {
  521. if( DateiExistiert( new Text( ltdb ) ) )
  522. {
  523. LTDBDatei *dat = new LTDBDatei();
  524. dat->setDatei( new Text( ltdb ) );
  525. dat->leseDaten( 0 );
  526. kasten = dat->laden( 0, new Text( "kasten.gif" ) );
  527. sKasten = dat->laden( 0, new Text( "skasten.gif" ) );
  528. dat->release();
  529. rend = 1;
  530. }
  531. }
  532. void KontrollKnopf::doMausEreignis( MausEreignis &me ) // Nachrichten verarbeitung
  533. {
  534. bool nmakc = !me.verarbeitet;
  535. if( me.verarbeitet || !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) )
  536. {
  537. style &= ~Style::MausKlick;
  538. if( mausIn )
  539. {
  540. mausIn = 0;
  541. if( toolTip )
  542. toolTip->setMausIn( 0 );
  543. MausEreignis me2;
  544. me2.id = ME_Verlässt;
  545. me2.mx = me.mx;
  546. me2.my = me.my;
  547. me2.verarbeitet = 0;
  548. doMausEreignis( me2 );
  549. return;
  550. }
  551. }
  552. if( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Verlässt )
  553. {
  554. if( toolTip )
  555. toolTip->setMausIn( 0 );
  556. return;
  557. }
  558. if( !mausIn && me.id != ME_Verlässt )
  559. {
  560. mausIn = 1;
  561. if( toolTip )
  562. toolTip->setMausIn( 1 );
  563. MausEreignis me2;
  564. me2.id = ME_Betritt;
  565. me2.mx = me.mx;
  566. me2.my = me.my;
  567. me2.verarbeitet = 0;
  568. doMausEreignis( me2 );
  569. }
  570. if( hatStyleNicht( TextFeld::Style::Erlaubt ) || hatStyleNicht( TextFeld::Style::Sichtbar ) )
  571. {
  572. if( toolTip )
  573. toolTip->setMausIn( 0 );
  574. return;
  575. }
  576. me.mx -= pos.x;
  577. me.my -= pos.y;
  578. if( Mak && ( me.verarbeitet || Mak( makParam, this, me ) ) )
  579. {
  580. if( me.id == ME_Betritt && hatStyle( Style::MausKlick ) != MausStand[ M_Links ] )
  581. setStyle( Style::MausKlick, MausStand[ M_Links ] );
  582. if( !me.verarbeitet && me.id == ME_PLinks )
  583. addStyle( Style::MausKlick );
  584. if( me.id == ME_RLinks )
  585. {
  586. löscheStyle( Style::MausKlick );
  587. setStyle( Style::Selected, !hatStyle( Style::Selected ) );
  588. }
  589. me.verarbeitet = 1;
  590. }
  591. if( nmakc && me.verarbeitet && nMak )
  592. me.verarbeitet = nMak( nmakParam, this, me );
  593. me.mx += pos.x;
  594. me.my += pos.y;
  595. }
  596. void KontrollKnopf::render( Bild &zRObj ) // zeichnet nach zRObj
  597. {
  598. if( !hatStyle( Style::Sichtbar ) )
  599. return;
  600. löscheStyle( Style::VScroll | Style::HScroll );
  601. __super::render( zRObj );
  602. lockZeichnung();
  603. if( !zRObj.setDrawOptions( innenPosition, innenGröße ) )
  604. {
  605. unlockZeichnung();
  606. return;
  607. }
  608. if( hatStyle( Style::MausKlick ) )
  609. {
  610. if( hatStyle( Style::KlickFarbe ) )
  611. {
  612. if( hatStyle( Style::KlickAlpha ) )
  613. zRObj.alphaRegion( 0, 0, innenGröße.x, innenGröße.y, kBgF );
  614. else
  615. zRObj.füllRegion( 0, 0, innenGröße.x, innenGröße.y, kBgF );
  616. }
  617. if( hatStyle( Style::KlickBild ) && kBgB )
  618. {
  619. if( hatStyle( Style::KlickAlpha ) )
  620. zRObj.alphaBild( 0, 0, innenGröße.x, innenGröße.y, *kBgB );
  621. else
  622. zRObj.drawBild( 0, 0, innenGröße.x, innenGröße.y, *kBgB );
  623. }
  624. if( hatStyle( Style::KlickBuffer ) && kAf )
  625. {
  626. kAf->setGröße( innenGröße.x, innenGröße.y );
  627. kAf->render( zRObj );
  628. }
  629. int kbr = 0;
  630. if( hatStyle( Style::Selected ) && sKasten )
  631. {
  632. if( sTxt && schrift )
  633. zRObj.drawBild( 0, ( gr.y / 2 - sKasten->getHöhe() / 2 ) < 0 ? 0 : ( gr.y / 2 - sKasten->getHöhe() / 2 ), innenGröße.x, innenGröße.y, *sKasten );
  634. else
  635. zRObj.drawBild( gr.x / 2 - sKasten->getBreite() / 2, ( gr.y / 2 - sKasten->getHöhe() / 2 ) < 0 ? 0 : ( gr.y / 2 - sKasten->getHöhe() / 2 ), innenGröße.x, innenGröße.y, *sKasten );
  636. kbr = sKasten->getBreite();
  637. if( sTxt && schrift )
  638. {
  639. schrift->setSchriftGröße( sGr );
  640. schrift->setDrawPosition( kbr + 5, gr.y / 2 - schrift->getTextHöhe( sTxt ) / 2 );
  641. schrift->renderText( sTxt, zRObj, sF );
  642. }
  643. }
  644. else if( kasten )
  645. {
  646. if( txt && schrift )
  647. zRObj.drawBild( 0, ( gr.y / 2 - kasten->getHöhe() / 2 ) < 0 ? 0 : ( gr.y / 2 - kasten->getHöhe() / 2 ), innenGröße.x, innenGröße.y, *kasten );
  648. else
  649. zRObj.drawBild( gr.x / 2 - kasten->getBreite() / 2, ( gr.y / 2 - kasten->getHöhe() / 2 ) < 0 ? 0 : ( gr.y / 2 - kasten->getHöhe() / 2 ), innenGröße.x, innenGröße.y, *kasten );
  650. kbr = kasten->getBreite();
  651. if( txt && schrift )
  652. {
  653. schrift->setSchriftGröße( sGr );
  654. schrift->setDrawPosition( kbr + 5, gr.y / 2 - schrift->getTextHöhe( txt ) / 2 );
  655. schrift->renderText( txt, zRObj, sF );
  656. }
  657. }
  658. }
  659. else if( hatStyle( Style::Selected ) )
  660. {
  661. if( hatStyle( Style::SelectFarbe ) )
  662. {
  663. if( hatStyle( Style::SelectAlpha ) )
  664. zRObj.alphaRegion( 0, 0, innenGröße.x, innenGröße.y, sBgF );
  665. else
  666. zRObj.füllRegion( 0, 0, innenGröße.x, innenGröße.y, sBgF );
  667. }
  668. if( hatStyle( Style::SelectBild ) && sBgB )
  669. {
  670. if( hatStyle( Style::SelectAlpha ) )
  671. zRObj.alphaBild( 0, 0, innenGröße.x, innenGröße.y, *sBgB );
  672. else
  673. zRObj.drawBild( 0, 0, innenGröße.x, innenGröße.y, *sBgB );
  674. }
  675. if( hatStyle( Style::SelectBuffer ) && sAf )
  676. {
  677. sAf->setGröße( innenGröße.x, innenGröße.y );
  678. sAf->render( zRObj );
  679. }
  680. int kbr = 0;
  681. if( sKasten )
  682. {
  683. if( sTxt && schrift )
  684. zRObj.drawBild( 0, ( gr.y / 2 - sKasten->getHöhe() / 2 ) < 0 ? 0 : ( gr.y / 2 - sKasten->getHöhe() / 2 ), innenGröße.x, innenGröße.y, *sKasten );
  685. else
  686. zRObj.drawBild( gr.x / 2 - sKasten->getBreite() / 2, ( gr.y / 2 - sKasten->getHöhe() / 2 ) < 0 ? 0 : ( gr.y / 2 - sKasten->getHöhe() / 2 ), innenGröße.x, innenGröße.y, *sKasten );
  687. kbr = sKasten->getBreite();
  688. }
  689. if( sTxt && schrift )
  690. {
  691. schrift->setSchriftGröße( sGr );
  692. schrift->setDrawPosition( kbr + 5, gr.y / 2 - schrift->getTextHöhe( sTxt ) / 2 );
  693. schrift->renderText( sTxt, zRObj, sF );
  694. }
  695. }
  696. else
  697. {
  698. int kbr = 0;
  699. if( kasten )
  700. {
  701. if( txt && schrift )
  702. zRObj.drawBild( 0, ( gr.y / 2 - kasten->getHöhe() / 2 ) < 0 ? 0 : ( gr.y / 2 - kasten->getHöhe() / 2 ), innenGröße.x, innenGröße.y, *kasten );
  703. else
  704. zRObj.drawBild( gr.x / 2 - kasten->getBreite() / 2, ( gr.y / 2 - kasten->getHöhe() / 2 ) < 0 ? 0 : ( gr.y / 2 - kasten->getHöhe() / 2 ), innenGröße.x, innenGröße.y, *kasten );
  705. kbr = kasten->getBreite();
  706. }
  707. if( txt && schrift )
  708. {
  709. schrift->setSchriftGröße( sGr );
  710. schrift->setDrawPosition( kbr + 5, gr.y / 2 - schrift->getTextHöhe( txt ) / 2 );
  711. schrift->renderText( txt, zRObj, sF );
  712. }
  713. }
  714. zRObj.releaseDrawOptions();
  715. unlockZeichnung();
  716. }
  717. // constant
  718. Text *KontrollKnopf::getText() const // gibt den Text zurück
  719. {
  720. return txt ? txt->getThis() : 0;
  721. }
  722. Text *KontrollKnopf::zText() const
  723. {
  724. return txt;
  725. }
  726. Text *KontrollKnopf::getSText() const // gibt den Select Text zurück
  727. {
  728. return sTxt ? sTxt->getThis() : 0;
  729. }
  730. Text *KontrollKnopf::zSText() const
  731. {
  732. return sTxt;
  733. }
  734. Schrift *KontrollKnopf::getSchrift() const // gibt die Schrift zurück
  735. {
  736. return schrift ? schrift->getThis() : 0;
  737. }
  738. Schrift *KontrollKnopf::zSchrift() const
  739. {
  740. return schrift;
  741. }
  742. int KontrollKnopf::getSFarbe() const // gibt die Schrift Farbe zurück
  743. {
  744. return sF;
  745. }
  746. int KontrollKnopf::getSGröße() const // gibt die Schrift Größe zurück
  747. {
  748. return sGr;
  749. }
  750. int KontrollKnopf::getSBgFarbe() const// gibt die Select Hintergrundfarbe zurück
  751. {
  752. return sBgF;
  753. }
  754. int KontrollKnopf::getKBgFarbe() const // gibt die Klick Hintergrundfarbe zurück
  755. {
  756. return kBgF;
  757. }
  758. Bild *KontrollKnopf::getSBgBild() const // gibt das Select Hintergrundbild zurück
  759. {
  760. return sBgB ? sBgB->getThis() : 0;
  761. }
  762. Bild *KontrollKnopf::zSBgBild() const
  763. {
  764. return sBgB;
  765. }
  766. Bild *KontrollKnopf::getKBgBild() const // gibt das Klick Hintergrundbild zurück
  767. {
  768. return kBgB ? kBgB->getThis() : 0;
  769. }
  770. Bild *KontrollKnopf::zKBgBild() const
  771. {
  772. return kBgB;
  773. }
  774. AlphaFeld *KontrollKnopf::getSAlphaFeld() const // gibt das Select AlphaFeld zurück
  775. {
  776. return sAf ? sAf->getThis() : 0;
  777. }
  778. AlphaFeld *KontrollKnopf::zSAlphaFeld() const
  779. {
  780. return sAf;
  781. }
  782. AlphaFeld *KontrollKnopf::getKAlphaFeld() const // gibt das Klick AlphaFeld zurück
  783. {
  784. if( !kAf )
  785. return 0;
  786. return kAf->release();
  787. }
  788. AlphaFeld *KontrollKnopf::zKAlphaFeld() const
  789. {
  790. return kAf;
  791. }
  792. // Reference Counting
  793. KontrollKnopf *KontrollKnopf::getThis()
  794. {
  795. ++ref;
  796. return this;
  797. }
  798. KontrollKnopf *KontrollKnopf::release()
  799. {
  800. --ref;
  801. if( !ref )
  802. delete this;
  803. return 0;
  804. }