Zeichnung.cpp 22 KB

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