Zeichnung.cpp 26 KB

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