UIMLView.cpp 50 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616
  1. #include "UIMLView.h"
  2. #include "Bild.h"
  3. #include "Bildschirm.h"
  4. #include "Fenster.h"
  5. #include "Knopf.h"
  6. #include "Rahmen.h"
  7. #include "RCPointer.h"
  8. #include "Schrift.h"
  9. #include "Scroll.h"
  10. #include "Tabelle.h"
  11. #include "TextFeld.h"
  12. #include "XML.h"
  13. using namespace Framework;
  14. UIMLElement::UIMLElement()
  15. : ReferenceCounter()
  16. {}
  17. UIMLElement::~UIMLElement() {}
  18. //! wendet die layout parameter zu einer Zeichnung an
  19. void UIMLElement::layout(XML::Element& element,
  20. Zeichnung& z,
  21. int pWidth,
  22. int pHeight,
  23. UIMLContainer& generalLayouter)
  24. {
  25. int width = z.getBreite();
  26. int height = z.getHeight();
  27. if (element.hasAttribute("style"))
  28. {
  29. z.setStyle((__int64)element.getAttributeValue("style"));
  30. }
  31. if (element.hasAttribute("width"))
  32. {
  33. Text w = element.getAttributeValue("width");
  34. if (!w.istGleich("auto"))
  35. {
  36. width = calculateSize(w, pWidth);
  37. }
  38. }
  39. if (element.hasAttribute("height"))
  40. {
  41. Text h = element.getAttributeValue("height");
  42. if (!h.istGleich("auto"))
  43. {
  44. height = calculateSize(h, pHeight);
  45. }
  46. }
  47. z.setSize(width, height);
  48. if (element.hasAttribute("align-x"))
  49. {
  50. Text la = element.getAttributeValue("align-x");
  51. int x = 0;
  52. if (la.istGleich("start"))
  53. x = 0;
  54. else if (la.istGleich("end"))
  55. x = pWidth;
  56. else if (la.istGleich("center"))
  57. x = pWidth / 2 - width / 2;
  58. else
  59. {
  60. XML::Editor ed
  61. = element.zParent()->selectChildsByAttribute("id", la);
  62. generalLayouter.layout(*ed.begin().val(),
  63. *generalLayouter.zZeichnungById(la),
  64. pWidth,
  65. pHeight,
  66. generalLayouter);
  67. Zeichnung* laz = generalLayouter.zZeichnungById(la);
  68. if (laz) x = laz->getX();
  69. }
  70. if (element.hasAttribute("margin-x"))
  71. {
  72. Text mt = element.getAttributeValue("margin-x");
  73. x += calculateSize(mt, pWidth);
  74. }
  75. z.setX(x);
  76. }
  77. else if (element.hasAttribute("align-left"))
  78. {
  79. Text la = element.getAttributeValue("align-left");
  80. int x = 0;
  81. if (la.istGleich("start"))
  82. x = 0;
  83. else if (la.istGleich("end"))
  84. x = pWidth;
  85. else if (la.istGleich("center"))
  86. x = pWidth / 2 - width / 2;
  87. else
  88. {
  89. XML::Editor ed
  90. = element.zParent()->selectChildsByAttribute("id", la);
  91. generalLayouter.layout(*ed.begin().val(),
  92. *generalLayouter.zZeichnungById(la),
  93. pWidth,
  94. pHeight,
  95. generalLayouter);
  96. Zeichnung* laz = generalLayouter.zZeichnungById(la);
  97. if (laz) x = laz->getX() + laz->getBreite();
  98. }
  99. if (element.hasAttribute("margin-left"))
  100. {
  101. Text mt = element.getAttributeValue("margin-left");
  102. x += calculateSize(mt, pWidth);
  103. }
  104. z.setX(x);
  105. }
  106. else if (element.hasAttribute("align-right"))
  107. {
  108. Text ra = element.getAttributeValue("align-right");
  109. int x = 0;
  110. if (ra.istGleich("start"))
  111. x = -z.getBreite();
  112. else if (ra.istGleich("end"))
  113. x = pWidth - z.getBreite();
  114. else if (ra.istGleich("center"))
  115. x = pWidth / 2 - width / 2;
  116. else
  117. {
  118. XML::Editor ed
  119. = element.zParent()->selectChildsByAttribute("id", ra);
  120. generalLayouter.layout(*ed.begin().val(),
  121. *generalLayouter.zZeichnungById(ra),
  122. pWidth,
  123. pHeight,
  124. generalLayouter);
  125. Zeichnung* raz = generalLayouter.zZeichnungById(ra);
  126. if (raz) x = raz->getX() - z.getBreite();
  127. }
  128. if (element.hasAttribute("margin-right"))
  129. {
  130. Text mt = element.getAttributeValue("margin-right");
  131. x -= calculateSize(mt, pWidth);
  132. }
  133. z.setX(x);
  134. }
  135. if (element.hasAttribute("align-y"))
  136. {
  137. Text ta = element.getAttributeValue("align-y");
  138. int y = 0;
  139. if (ta.istGleich("start"))
  140. y = 0;
  141. else if (ta.istGleich("end"))
  142. y = pHeight;
  143. else if (ta.istGleich("center"))
  144. y = pHeight / 2 - height / 2;
  145. else
  146. {
  147. XML::Editor ed
  148. = element.zParent()->selectChildsByAttribute("id", ta);
  149. generalLayouter.layout(*ed.begin().val(),
  150. *generalLayouter.zZeichnungById(ta),
  151. pWidth,
  152. pHeight,
  153. generalLayouter);
  154. Zeichnung* taz = generalLayouter.zZeichnungById(ta);
  155. if (taz) y = taz->getY();
  156. }
  157. if (element.hasAttribute("margin-y"))
  158. {
  159. Text mt = element.getAttributeValue("margin-y");
  160. y += calculateSize(mt, pHeight);
  161. }
  162. z.setY(y);
  163. }
  164. else if (element.hasAttribute("align-top"))
  165. {
  166. Text ta = element.getAttributeValue("align-top");
  167. int y = 0;
  168. if (ta.istGleich("start"))
  169. y = 0;
  170. else if (ta.istGleich("end"))
  171. y = pHeight;
  172. else if (ta.istGleich("center"))
  173. y = pHeight / 2 - height / 2;
  174. else
  175. {
  176. XML::Editor ed
  177. = element.zParent()->selectChildsByAttribute("id", ta);
  178. generalLayouter.layout(*ed.begin().val(),
  179. *generalLayouter.zZeichnungById(ta),
  180. pWidth,
  181. pHeight,
  182. generalLayouter);
  183. Zeichnung* taz = generalLayouter.zZeichnungById(ta);
  184. if (taz) y = taz->getY() + taz->getHeight();
  185. }
  186. if (element.hasAttribute("margin-top"))
  187. {
  188. Text mt = element.getAttributeValue("margin-top");
  189. y += calculateSize(mt, pHeight);
  190. }
  191. z.setY(y);
  192. }
  193. else if (element.hasAttribute("align-bottom"))
  194. {
  195. Text ba = element.getAttributeValue("align-bottom");
  196. int y = 0;
  197. if (ba.istGleich("start"))
  198. y = -z.getHeight();
  199. else if (ba.istGleich("end"))
  200. y = pHeight - z.getHeight();
  201. else if (ba.istGleich("center"))
  202. y = pHeight / 2 - height / 2;
  203. else
  204. {
  205. XML::Editor ed
  206. = element.zParent()->selectChildsByAttribute("id", ba);
  207. generalLayouter.layout(*ed.begin().val(),
  208. *generalLayouter.zZeichnungById(ba),
  209. pWidth,
  210. pHeight,
  211. generalLayouter);
  212. Zeichnung* baz = generalLayouter.zZeichnungById(ba);
  213. if (baz) y = baz->getY() - z.getHeight();
  214. }
  215. if (element.hasAttribute("margin-bottom"))
  216. {
  217. Text mt = element.getAttributeValue("margin-bottom");
  218. y -= calculateSize(mt, pHeight);
  219. }
  220. z.setY(y);
  221. }
  222. int x = z.getX();
  223. int y = z.getY();
  224. if (element.hasAttribute("x"))
  225. {
  226. Text xt = element.getAttributeValue("x");
  227. x = calculateSize(xt, pWidth);
  228. }
  229. if (element.hasAttribute("y"))
  230. {
  231. Text yt = element.getAttributeValue("y");
  232. y = calculateSize(yt, pHeight);
  233. }
  234. z.setPosition(x, y);
  235. ZeichnungHintergrund* zh = dynamic_cast<ZeichnungHintergrund*>(&z);
  236. if (zh)
  237. {
  238. if (element.hasAttribute("border"))
  239. {
  240. int br = (int)element.getAttributeValue("border");
  241. zh->setStyle(ZeichnungHintergrund::Style::Rahmen, br > 0);
  242. zh->setRahmenBreite((int)element.getAttributeValue("border"));
  243. }
  244. if (element.hasAttribute("border-color"))
  245. {
  246. zh->setRahmenFarbe((int)element.getAttributeValue("border-color"));
  247. }
  248. }
  249. // recursive layout
  250. pWidth = z.getInnenBreite();
  251. pHeight = z.getInnenHeight();
  252. for (auto i = element.getChilds(); i; i++)
  253. {
  254. Zeichnung* z = 0;
  255. if (i->hasAttribute("id"))
  256. {
  257. z = generalLayouter.zZeichnungById(i->getAttributeValue("id"));
  258. }
  259. if (z)
  260. {
  261. generalLayouter.layout(
  262. *i.val(), *z, pWidth, pHeight, generalLayouter);
  263. }
  264. }
  265. }
  266. int Framework::UIMLElement::calculateSize(Text attributeValue, int parentSize)
  267. {
  268. attributeValue.removeWhitespaceAfter(0);
  269. attributeValue.removeWhitespaceBefore(attributeValue.getLength());
  270. if (attributeValue.hat('('))
  271. {
  272. int start = -1;
  273. int len = attributeValue.getLength();
  274. for (int i = 0; i < len; i++)
  275. {
  276. if (attributeValue.getText()[i] == '(') start = i;
  277. if (attributeValue.getText()[i] == ')')
  278. {
  279. if (start < 0) return 0;
  280. Text* part = attributeValue.getTeilText(start + 1, i);
  281. int value = calculateSize(*part, parentSize);
  282. part->release();
  283. attributeValue.remove(start, i + 1);
  284. attributeValue.insert(start, Text(value));
  285. return calculateSize(attributeValue, parentSize);
  286. }
  287. }
  288. return 0;
  289. }
  290. else if (attributeValue.hat('*') || attributeValue.hat('/'))
  291. {
  292. int posD = attributeValue.positionVon('/');
  293. int posM = attributeValue.positionVon('*');
  294. if ((posD >= 0 && posD < posM) || posM < 0)
  295. {
  296. Text* firstPart = attributeValue.getTeilText(0, posD);
  297. Text* secondPart = attributeValue.getTeilText(posD + 1);
  298. int first = calculateSize(*firstPart, parentSize);
  299. int second = calculateSize(*secondPart, parentSize);
  300. firstPart->release();
  301. secondPart->release();
  302. return first / second;
  303. }
  304. else
  305. {
  306. Text* firstPart = attributeValue.getTeilText(0, posM);
  307. Text* secondPart = attributeValue.getTeilText(posM + 1);
  308. int first = calculateSize(*firstPart, parentSize);
  309. int second = calculateSize(*secondPart, parentSize);
  310. firstPart->release();
  311. secondPart->release();
  312. return first * second;
  313. }
  314. }
  315. else if (attributeValue.hat('+') || attributeValue.hat('-'))
  316. {
  317. int posP = attributeValue.positionVon('+');
  318. int posN = attributeValue.positionVon('-');
  319. if ((posP >= 0 && posP < posN) || posN < 0)
  320. {
  321. Text* firstPart = attributeValue.getTeilText(0, posP);
  322. Text* secondPart = attributeValue.getTeilText(posP + 1);
  323. int first = calculateSize(*firstPart, parentSize);
  324. int second = calculateSize(*secondPart, parentSize);
  325. firstPart->release();
  326. secondPart->release();
  327. return first + second;
  328. }
  329. else
  330. {
  331. Text* firstPart = attributeValue.getTeilText(0, posN);
  332. Text* secondPart = attributeValue.getTeilText(posN + 1);
  333. int first = calculateSize(*firstPart, parentSize);
  334. int second = calculateSize(*secondPart, parentSize);
  335. firstPart->release();
  336. secondPart->release();
  337. return first - second;
  338. }
  339. }
  340. else if (attributeValue.hatAt(attributeValue.getLength() - 1, "%"))
  341. {
  342. return (int)((int)attributeValue * (parentSize / 100.0));
  343. }
  344. else
  345. {
  346. return (int)attributeValue;
  347. }
  348. }
  349. UIMLContainer::UIMLContainer()
  350. : UIMLElement()
  351. {}
  352. UIMLContainer::~UIMLContainer() {}
  353. UIMLTextField::UIMLTextField()
  354. : UIMLElement()
  355. {}
  356. bool UIMLTextField::isApplicableFor(XML::Element& element)
  357. {
  358. return element.getName().istGleich("textfield");
  359. }
  360. Zeichnung* UIMLTextField::parseElement(
  361. XML::Element& element, UIMLContainer& generalFactory)
  362. {
  363. TextFeld* t = generalFactory.getFactory().createTextFeld(
  364. generalFactory.getFactory().initParam);
  365. updateElement(element, *t, generalFactory);
  366. return t;
  367. }
  368. bool Framework::UIMLTextField::updateElement(
  369. XML::Element& element, Zeichnung& z, UIMLContainer& generalFactory)
  370. {
  371. TextFeld* t = dynamic_cast<TextFeld*>(&z);
  372. if (!t) return false;
  373. if (!element.hasAttribute("style"))
  374. {
  375. TextFeld* tmp = generalFactory.getFactory().createTextFeld(
  376. generalFactory.getFactory().initParam);
  377. tmp->addStyle(TextFeld::Style::TextFeld);
  378. t->setStyle(tmp->getStyles());
  379. tmp->release();
  380. }
  381. return true;
  382. }
  383. void UIMLTextField::layout(XML::Element& element,
  384. Zeichnung& z,
  385. int pWidth,
  386. int pHeight,
  387. UIMLContainer& generalLayouter)
  388. {
  389. TextFeld* tf = dynamic_cast<TextFeld*>(&z);
  390. if (element.hasAttribute("font-size"))
  391. {
  392. tf->setSchriftSize(
  393. (unsigned char)(int)element.getAttributeValue("font-size"));
  394. }
  395. ((TextFeld*)&z)->setText(element.getText());
  396. if (element.hasAttribute("width"))
  397. {
  398. Text w = element.getAttributeValue("width");
  399. if (w.istGleich("auto"))
  400. {
  401. z.setWidth(((TextFeld*)&z)->getNeededWidth());
  402. }
  403. }
  404. if (element.hasAttribute("height"))
  405. {
  406. Text h = element.getAttributeValue("height");
  407. if (h.istGleich("auto"))
  408. {
  409. z.setHeight(((TextFeld*)&z)->getNeededHeight());
  410. }
  411. }
  412. if (element.hasAttribute("text-color"))
  413. {
  414. tf->setSchriftFarbe((int)element.getAttributeValue("text-color"));
  415. }
  416. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  417. if (element.hasAttribute("text-align-horizontal"))
  418. z.setStyle(TextFeld::Style::HCenter,
  419. element.getAttributeValue("text-align-horizontal")
  420. .istGleich("center"));
  421. if (element.hasAttribute("text-align-vertical"))
  422. z.setStyle(TextFeld::Style::VCenter,
  423. element.getAttributeValue("text-align-vertical")
  424. .istGleich("center"));
  425. if (element.hasAttribute("disabled"))
  426. z.removeStyle(TextFeld::Style::Editierbar);
  427. if (element.getAttributeValue("vScroll").istGleich("auto"))
  428. {
  429. tf->setStyle(TextFeld::Style::VScroll,
  430. tf->getNeededHeight() > tf->getInnenHeight());
  431. tf->setVertikalKlickScroll(tf->getSchriftSize());
  432. tf->updateVScroll();
  433. }
  434. if (element.getAttributeValue("hScroll").istGleich("auto"))
  435. {
  436. tf->setStyle(TextFeld::Style::HScroll,
  437. tf->getNeededWidth() > tf->getInnenBreite());
  438. tf->setHorizontalKlickScroll(tf->getSchriftSize());
  439. tf->updateHScroll();
  440. }
  441. }
  442. UIMLButton::UIMLButton()
  443. : UIMLElement()
  444. {}
  445. bool UIMLButton::isApplicableFor(XML::Element& element)
  446. {
  447. return element.getName().istGleich("button");
  448. }
  449. Zeichnung* UIMLButton::parseElement(
  450. XML::Element& element, UIMLContainer& generalFactory)
  451. {
  452. Knopf* k = generalFactory.getFactory().createKnopf(
  453. generalFactory.getFactory().initParam);
  454. updateElement(element, *k, generalFactory);
  455. return k;
  456. }
  457. bool Framework::UIMLButton::updateElement(
  458. XML::Element& element, Zeichnung& z, UIMLContainer& generalFactory)
  459. {
  460. Knopf* k = dynamic_cast<Knopf*>(&z);
  461. if (!k) return false;
  462. if (!element.hasAttribute("style"))
  463. {
  464. Knopf* tmp = generalFactory.getFactory().createKnopf(
  465. generalFactory.getFactory().initParam);
  466. k->setStyle(tmp->getStyles());
  467. tmp->release();
  468. }
  469. return true;
  470. }
  471. void UIMLButton::layout(XML::Element& element,
  472. Zeichnung& z,
  473. int pWidth,
  474. int pHeight,
  475. UIMLContainer& generalLayouter)
  476. {
  477. if (element.hasAttribute("font-size"))
  478. ((Knopf*)&z)
  479. ->setSchriftSize(
  480. (unsigned char)(int)element.getAttributeValue("font-size"));
  481. ((Knopf*)&z)->setText(element.getText());
  482. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  483. }
  484. UIMLCheck::UIMLCheck()
  485. : UIMLElement()
  486. {}
  487. bool UIMLCheck::isApplicableFor(XML::Element& element)
  488. {
  489. return element.getName().istGleich("check");
  490. }
  491. Zeichnung* UIMLCheck::parseElement(
  492. XML::Element& element, UIMLContainer& generalFactory)
  493. {
  494. KontrollKnopf* k = generalFactory.getFactory().createKontrollKnopf(
  495. generalFactory.getFactory().initParam);
  496. updateElement(element, *k, generalFactory);
  497. return k;
  498. }
  499. bool Framework::UIMLCheck::updateElement(
  500. XML::Element& element, Zeichnung& z, UIMLContainer& generalFactory)
  501. {
  502. KontrollKnopf* k = dynamic_cast<KontrollKnopf*>(&z);
  503. if (!k) return false;
  504. if (!element.hasAttribute("style"))
  505. {
  506. KontrollKnopf* tmp = generalFactory.getFactory().createKontrollKnopf(
  507. generalFactory.getFactory().initParam);
  508. k->setStyle(tmp->getStyles());
  509. tmp->release();
  510. }
  511. return true;
  512. }
  513. void UIMLCheck::layout(XML::Element& element,
  514. Zeichnung& z,
  515. int pWidth,
  516. int pHeight,
  517. UIMLContainer& generalLayouter)
  518. {
  519. ((KontrollKnopf*)&z)->setText(element.getText());
  520. ((KontrollKnopf*)&z)->setSText(element.getText());
  521. z.setStyle(
  522. KontrollKnopf::Style::Selected, element.hasAttribute("selected"));
  523. if (element.hasAttribute("font-size"))
  524. ((KontrollKnopf*)&z)
  525. ->setSSize(
  526. (unsigned char)(int)element.getAttributeValue("font-size"));
  527. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  528. }
  529. UIMLText::UIMLText()
  530. : UIMLElement()
  531. {}
  532. bool UIMLText::isApplicableFor(XML::Element& element)
  533. {
  534. return element.getName().istGleich("text");
  535. }
  536. Zeichnung* UIMLText::parseElement(
  537. XML::Element& element, UIMLContainer& generalFactory)
  538. {
  539. TextFeld* t = generalFactory.getFactory().createTextFeld(
  540. generalFactory.getFactory().initParam);
  541. updateElement(element, *t, generalFactory);
  542. return t;
  543. }
  544. bool Framework::UIMLText::updateElement(
  545. XML::Element& element, Zeichnung& z, UIMLContainer& generalFactory)
  546. {
  547. TextFeld* t = dynamic_cast<TextFeld*>(&z);
  548. if (!t) return false;
  549. if (!element.hasAttribute("style"))
  550. {
  551. TextFeld* tmp = generalFactory.getFactory().createTextFeld(
  552. generalFactory.getFactory().initParam);
  553. tmp->addStyle(TextFeld::Style::Text);
  554. t->setStyle(tmp->getStyles());
  555. tmp->release();
  556. }
  557. return true;
  558. }
  559. void UIMLText::layout(XML::Element& element,
  560. Zeichnung& z,
  561. int pWidth,
  562. int pHeight,
  563. UIMLContainer& generalLayouter)
  564. {
  565. TextFeld* tf = dynamic_cast<TextFeld*>(&z);
  566. if (element.hasAttribute("font-size"))
  567. {
  568. tf->setSchriftSize(
  569. (unsigned char)(int)element.getAttributeValue("font-size"));
  570. }
  571. tf->setText(element.getText());
  572. if (element.hasAttribute("width"))
  573. {
  574. Text w = element.getAttributeValue("width");
  575. if (w.istGleich("auto"))
  576. {
  577. z.setWidth(tf->getNeededWidth());
  578. }
  579. }
  580. if (element.hasAttribute("height"))
  581. {
  582. Text h = element.getAttributeValue("height");
  583. if (h.istGleich("auto"))
  584. {
  585. z.setHeight(tf->getNeededHeight());
  586. }
  587. }
  588. if (element.hasAttribute("text-color"))
  589. {
  590. tf->setSchriftFarbe((int)element.getAttributeValue("text-color"));
  591. }
  592. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  593. if (element.hasAttribute("text-align-horizontal"))
  594. z.setStyle(TextFeld::Style::HCenter,
  595. element.getAttributeValue("text-align-horizontal")
  596. .istGleich("center"));
  597. if (element.hasAttribute("text-align-vertical"))
  598. z.setStyle(TextFeld::Style::VCenter,
  599. element.getAttributeValue("text-align-vertical")
  600. .istGleich("center"));
  601. if (element.hasAttribute("disabled"))
  602. z.removeStyle(TextFeld::Style::Editierbar);
  603. if (element.getAttributeValue("vScroll").istGleich("auto"))
  604. {
  605. tf->setStyle(TextFeld::Style::VScroll,
  606. tf->getNeededHeight() > tf->getInnenHeight());
  607. tf->setVertikalKlickScroll(tf->getSchriftSize());
  608. tf->updateVScroll();
  609. }
  610. if (element.getAttributeValue("hScroll").istGleich("auto"))
  611. {
  612. tf->setStyle(TextFeld::Style::HScroll,
  613. tf->getNeededWidth() > tf->getInnenBreite());
  614. tf->setHorizontalKlickScroll(tf->getSchriftSize());
  615. tf->updateHScroll();
  616. }
  617. }
  618. UIMLTextArea::UIMLTextArea()
  619. : UIMLElement()
  620. {}
  621. bool UIMLTextArea::isApplicableFor(XML::Element& element)
  622. {
  623. return element.getName().istGleich("textarea");
  624. }
  625. Zeichnung* UIMLTextArea::parseElement(
  626. XML::Element& element, UIMLContainer& generalFactory)
  627. {
  628. TextFeld* t = generalFactory.getFactory().createTextFeld(
  629. generalFactory.getFactory().initParam);
  630. updateElement(element, *t, generalFactory);
  631. return t;
  632. }
  633. bool Framework::UIMLTextArea::updateElement(
  634. XML::Element& element, Zeichnung& z, UIMLContainer& generalFactory)
  635. {
  636. TextFeld* t = dynamic_cast<TextFeld*>(&z);
  637. if (!t) return false;
  638. if (!element.hasAttribute("style"))
  639. {
  640. TextFeld* tmp = generalFactory.getFactory().createTextFeld(
  641. generalFactory.getFactory().initParam);
  642. tmp->addStyle(TextFeld::Style::TextGebiet);
  643. t->setStyle(tmp->getStyles());
  644. tmp->release();
  645. }
  646. return true;
  647. }
  648. void UIMLTextArea::layout(XML::Element& element,
  649. Zeichnung& z,
  650. int pWidth,
  651. int pHeight,
  652. UIMLContainer& generalLayouter)
  653. {
  654. TextFeld* tf = dynamic_cast<TextFeld*>(&z);
  655. if (element.hasAttribute("font-size"))
  656. {
  657. tf->setSchriftSize(
  658. (unsigned char)(int)element.getAttributeValue("font-size"));
  659. }
  660. if (element.hasAttribute("disabled"))
  661. z.removeStyle(TextFeld::Style::Editierbar);
  662. tf->setText(element.getText());
  663. tf->zTextRenderer()->textFormatieren(tf->zText(), z.getInnenBreite());
  664. if (element.hasAttribute("width"))
  665. {
  666. Text w = element.getAttributeValue("width");
  667. if (w.istGleich("auto"))
  668. {
  669. z.setWidth(((TextFeld*)&z)->getNeededWidth());
  670. }
  671. }
  672. if (element.hasAttribute("height"))
  673. {
  674. Text h = element.getAttributeValue("height");
  675. if (h.istGleich("auto"))
  676. {
  677. z.setHeight(((TextFeld*)&z)->getNeededHeight());
  678. }
  679. }
  680. if (element.hasAttribute("text-color"))
  681. {
  682. tf->setSchriftFarbe((int)element.getAttributeValue("text-color"));
  683. }
  684. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  685. if (element.hasAttribute("text-align-horizontal"))
  686. z.setStyle(TextFeld::Style::HCenter,
  687. element.getAttributeValue("text-align-horizontal")
  688. .istGleich("center"));
  689. if (element.hasAttribute("text-align-vertical"))
  690. z.setStyle(TextFeld::Style::VCenter,
  691. element.getAttributeValue("text-align-vertical")
  692. .istGleich("center"));
  693. if (element.hasAttribute("font-size"))
  694. if (element.getAttributeValue("vScroll").istGleich("auto"))
  695. {
  696. tf->setStyle(TextFeld::Style::VScroll,
  697. tf->getNeededHeight() > tf->getInnenHeight());
  698. tf->setVertikalKlickScroll(tf->getSchriftSize());
  699. tf->updateVScroll();
  700. }
  701. if (element.getAttributeValue("hScroll").istGleich("auto"))
  702. {
  703. tf->setStyle(TextFeld::Style::HScroll,
  704. tf->getNeededWidth() > tf->getInnenBreite());
  705. tf->setHorizontalKlickScroll(tf->getSchriftSize());
  706. tf->updateHScroll();
  707. }
  708. }
  709. UIMLTable::UIMLTable()
  710. : UIMLElement()
  711. {}
  712. bool UIMLTable::isApplicableFor(XML::Element& element)
  713. {
  714. return element.getName().istGleich("table");
  715. }
  716. Zeichnung* UIMLTable::parseElement(
  717. XML::Element& element, UIMLContainer& generalFactory)
  718. {
  719. ObjTabelle* t = generalFactory.getFactory().createObjTabelle(
  720. generalFactory.getFactory().initParam);
  721. updateElement(element, *t, generalFactory);
  722. return t;
  723. }
  724. DLLEXPORT bool Framework::UIMLTable::updateElement(
  725. XML::Element& element, Zeichnung& z, UIMLContainer& generalFactory)
  726. {
  727. ObjTabelle* t = dynamic_cast<ObjTabelle*>(&z);
  728. if (!t) return false;
  729. int index = 0;
  730. int linePos = 0;
  731. int numCols = 0;
  732. for (auto i = element.getChilds(); i; i++)
  733. {
  734. Text id;
  735. if (i->hasAttribute("id"))
  736. id = i->getAttributeValue("id");
  737. else
  738. {
  739. id = Text("_") += index++;
  740. i->setAttribute("id", id);
  741. }
  742. if (i->getName().istGleich("tr"))
  743. {
  744. if (t->getZeilenNummer(id) == -1) t->addZeile(id);
  745. t->setZeilePosition(id, linePos);
  746. int c = 1;
  747. for (auto j = i->getChilds(); j; j++)
  748. {
  749. if (t->getSpaltenAnzahl() < c) t->addSpalte(Text(c - 1));
  750. if (numCols < c) numCols = c;
  751. Zeichnung* z = t->zZeichnung(Text(c - 1), id);
  752. if (!z
  753. || !generalFactory.updateElement(
  754. element, *z, generalFactory))
  755. {
  756. z = generalFactory.parseElement(*i.val(), generalFactory);
  757. if (z) t->setZeichnungZ(Text(c - 1), id, z);
  758. }
  759. c++;
  760. }
  761. }
  762. linePos++;
  763. }
  764. for (int i = 0; i < t->getZeilenAnzahl(); i++)
  765. { // remove all lines that are not in the xml
  766. if (!element.selectChildsByName("tr")
  767. .whereAttributeEquals("id", *t->zZeilenName(i))
  768. .exists())
  769. {
  770. t->removeZeile(i);
  771. i--;
  772. }
  773. }
  774. for (int i = numCols; i < t->getSpaltenAnzahl(); i++)
  775. { // remove all columns that are not in the xml
  776. t->removeSpalte(i);
  777. i--;
  778. }
  779. if (!element.hasAttribute("style"))
  780. {
  781. ObjTabelle* tmp = generalFactory.getFactory().createObjTabelle(
  782. generalFactory.getFactory().initParam);
  783. t->setStyle(tmp->getStyles());
  784. tmp->release();
  785. }
  786. return true;
  787. }
  788. void UIMLTable::layout(XML::Element& element,
  789. Zeichnung& z,
  790. int pWidth,
  791. int pHeight,
  792. UIMLContainer& generalLayouter)
  793. {
  794. if (element.hasAttribute("scroll"))
  795. {
  796. z.setStyle(ObjTabelle::Style::HScroll,
  797. element.getAttributeValue("scroll").istGleich("horizontal"));
  798. z.setStyle(ObjTabelle::Style::VScroll,
  799. element.getAttributeValue("scroll").istGleich("vertical"));
  800. z.setStyle(ObjTabelle::Style::scroll,
  801. element.getAttributeValue("scroll").istGleich("both"));
  802. }
  803. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  804. ObjTabelle* objT = (ObjTabelle*)&z;
  805. if (objT->getZeilenAnzahl() > 0)
  806. {
  807. if (element.hasAttribute("line-height"))
  808. {
  809. int height = (int)element.getAttributeValue("line-height");
  810. for (int i = 0; i < objT->getZeilenAnzahl(); i++)
  811. objT->setZeilenHeight(i, height);
  812. }
  813. for (int i = 0; i < objT->getSpaltenAnzahl(); i++)
  814. {
  815. if (objT->zZeichnung(i, 0))
  816. objT->setSpaltenBreite(i, objT->zZeichnung(i, 0)->getBreite());
  817. }
  818. }
  819. }
  820. UIMLFrame::UIMLFrame()
  821. : UIMLElement()
  822. {}
  823. bool UIMLFrame::isApplicableFor(XML::Element& element)
  824. {
  825. return element.getName().istGleich("frame");
  826. }
  827. Zeichnung* UIMLFrame::parseElement(
  828. XML::Element& element, UIMLContainer& generalFactory)
  829. {
  830. Fenster* f = generalFactory.getFactory().createFenster(
  831. generalFactory.getFactory().initParam);
  832. updateElement(element, *f, generalFactory);
  833. return f;
  834. }
  835. bool Framework::UIMLFrame::updateElement(
  836. XML::Element& element, Zeichnung& z, UIMLContainer& generalFactory)
  837. {
  838. Fenster* f = dynamic_cast<Fenster*>(&z);
  839. if (!f) return false;
  840. for (auto member = f->getMembers().begin(); member; )
  841. { // remove all members that are not in the xml
  842. Framework::Text id = generalFactory.getZeichnungId(*member.val());
  843. if (id.getLength() == 0){
  844. member.remove();
  845. f->setRender();
  846. }
  847. else
  848. {
  849. member++;
  850. }
  851. }
  852. int index = 0;
  853. for (auto i = element.getChilds(); i; i++)
  854. {
  855. Text id = i->getAttributeValue("id");
  856. Zeichnung* z = generalFactory.zZeichnungById(id);
  857. if (!id.getLength() || !z || f->getMembers().indexOf(z) < 0
  858. || !generalFactory.updateElement(*i.val(), *z, generalFactory))
  859. {
  860. if (f->getMembers().indexOf(z) >= 0)
  861. {
  862. f->removeMember(z);
  863. }
  864. if (z) generalFactory.removeZeichnung(*z);
  865. z = generalFactory.parseElement(*i.val(), generalFactory);
  866. if (z) f->addMember(z);
  867. }
  868. if (z) f->setMemberIndex(z, index++);
  869. }
  870. if (!element.hasAttribute("style"))
  871. {
  872. Fenster* tmp = generalFactory.getFactory().createFenster(
  873. generalFactory.getFactory().initParam);
  874. f->setStyle(tmp->getStyles());
  875. tmp->release();
  876. }
  877. return true;
  878. }
  879. void UIMLFrame::layout(XML::Element& element,
  880. Zeichnung& z,
  881. int pWidth,
  882. int pHeight,
  883. UIMLContainer& generalLayouter)
  884. {
  885. Fenster* f = dynamic_cast<Fenster*>(&z);
  886. if (element.hasAttribute("title"))
  887. f->setTitel(element.getAttributeValue("title"));
  888. if (element.hasAttribute("title-height"))
  889. {
  890. f->zTTextFeld()->setSize(f->zTTextFeld()->getBreite(),
  891. (int)element.getAttributeValue("title-height"));
  892. }
  893. if (element.hasAttribute("title-font-size"))
  894. {
  895. f->zTTextFeld()->setSchriftSize(
  896. (unsigned char)(int)element.getAttributeValue("title-font-size"));
  897. }
  898. if (element.hasAttribute("title-text-color"))
  899. {
  900. f->zTTextFeld()->setSchriftFarbe(
  901. (int)element.getAttributeValue("title-text-color"));
  902. }
  903. if (element.hasAttribute("width"))
  904. {
  905. Text w = element.getAttributeValue("width");
  906. if (w.istGleich("auto"))
  907. {
  908. z.setWidth(f->getNeededChildWidth());
  909. }
  910. }
  911. if (element.hasAttribute("height"))
  912. {
  913. Text h = element.getAttributeValue("height");
  914. if (h.istGleich("auto"))
  915. {
  916. z.setHeight(f->getNeededChildHeight());
  917. }
  918. }
  919. if (element.hasAttribute("display"))
  920. {
  921. UIMLElement::layout(element,
  922. z,
  923. pWidth,
  924. pHeight,
  925. generalLayouter); // calculate all sizes
  926. if (element.getAttributeValue("display").istGleich("column"))
  927. {
  928. int gap = calculateSize(element.getAttributeValue("gap"), pHeight);
  929. int y = 0;
  930. for (Zeichnung* z : f->getMembers())
  931. {
  932. Text id = generalLayouter.getZeichnungId(*z);
  933. auto child = element.selectChildsByAttribute("id", id);
  934. if (child.exists())
  935. {
  936. if (!child.whereAttributeExists("align-left").exists()
  937. && !child.whereAttributeExists("align-right").exists()
  938. && !child.whereAttributeExists("align-top").exists()
  939. && !child.whereAttributeExists("align-bottom").exists())
  940. {
  941. z->setY(y);
  942. y += z->getHeight() + gap;
  943. }
  944. }
  945. }
  946. }
  947. else if (element.getAttributeValue("display").istGleich("row"))
  948. {
  949. int gap = calculateSize(element.getAttributeValue("gap"), pWidth);
  950. int x = 0;
  951. for (Zeichnung* z : f->getMembers())
  952. {
  953. Text id = generalLayouter.getZeichnungId(*z);
  954. auto child = element.selectChildsByAttribute("id", id);
  955. if (child.exists())
  956. {
  957. if (!child.whereAttributeExists("align-left").exists()
  958. && !child.whereAttributeExists("align-right").exists()
  959. && !child.whereAttributeExists("align-top").exists()
  960. && !child.whereAttributeExists("align-bottom").exists())
  961. {
  962. z->setX(x);
  963. x += z->getBreite() + gap;
  964. }
  965. }
  966. }
  967. }
  968. }
  969. UIMLElement::layout(element,
  970. z,
  971. pWidth,
  972. pHeight,
  973. generalLayouter); // calculate all remaining positions
  974. if (element.getAttributeValue("vScroll").istGleich("auto"))
  975. {
  976. f->setStyle(Fenster::Style::VScroll,
  977. f->getNeededChildHeight() > f->getInnenHeight());
  978. f->setVSBScroll(10);
  979. f->updateVScroll();
  980. }
  981. if (element.getAttributeValue("hScroll").istGleich("auto"))
  982. {
  983. f->setStyle(Fenster::Style::HScroll,
  984. f->getNeededChildWidth() > f->getInnenBreite());
  985. f->setHSBScroll(10);
  986. f->updateHScroll();
  987. }
  988. }
  989. // Erstellt eine UIML View
  990. UIMLView::UIMLView()
  991. : ZeichnungHintergrund()
  992. {
  993. style = Style::MEIgnoreInside | Style::MEIgnoreParentInside
  994. | Style::MEIgnoreSichtbar | Style::MEIgnoreVerarbeitet;
  995. members = new RCTrie<Zeichnung>();
  996. dom = 0;
  997. nextId = 0;
  998. memset(&init, 0, sizeof(UIInit));
  999. addKnownElement(new UIMLTextField());
  1000. addKnownElement(new UIMLButton());
  1001. addKnownElement(new UIMLCheck());
  1002. addKnownElement(new UIMLText());
  1003. addKnownElement(new UIMLTextArea());
  1004. addKnownElement(new UIMLTable());
  1005. addKnownElement(new UIMLFrame());
  1006. }
  1007. // Erstellt eine UIML View zu einem UIML Text
  1008. // uiml: Ein xml element gemät des ksg uiml standarts
  1009. UIMLView::UIMLView(XML::Element* uiml, UIInit& init)
  1010. : UIMLView()
  1011. {
  1012. this->init = init;
  1013. setUIML(uiml);
  1014. }
  1015. // Erstellt eine UIML View zu einem UIML Text
  1016. // uiml: Ein xml text gemät des ksg uiml standarts
  1017. UIMLView::UIMLView(Text uiml, UIInit& init)
  1018. : UIMLView()
  1019. {
  1020. this->init = init;
  1021. setUIML(uiml);
  1022. }
  1023. UIMLView::~UIMLView()
  1024. {
  1025. if (dom) dom->release();
  1026. members->release();
  1027. }
  1028. // Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch aufgerufen.
  1029. // me: Das Ereignis
  1030. void UIMLView::doMausEreignis(MausEreignis& me, bool userRet)
  1031. {
  1032. if (dom)
  1033. {
  1034. bool verarbeitet = me.verarbeitet;
  1035. me.verarbeitet |= hatStyleNicht(Style::Sichtbar);
  1036. bool insideParent = me.insideParent;
  1037. if (!hatStyle(Style::Sichtbar) || !me.insideParent || me.verarbeitet
  1038. || me.mx < 0 || me.my < 0 || me.mx >= gr.x || me.my >= gr.y
  1039. || !userRet)
  1040. me.insideParent = 0;
  1041. int rbr = 0;
  1042. if (hatStyle(Style::Rahmen) && rahmen) rbr = rahmen->getRBreite();
  1043. me.mx -= rbr;
  1044. me.my -= rbr;
  1045. if (hatStyle(Style::VScroll) && vertikalScrollBar)
  1046. me.my += vertikalScrollBar->getScroll();
  1047. if (hatStyle(Style::HScroll) && horizontalScrollBar)
  1048. me.mx += horizontalScrollBar->getScroll();
  1049. if (dom)
  1050. {
  1051. for (auto i = dom->getChilds(); i; i++)
  1052. { // TODO render elements backwards
  1053. Zeichnung* z = members->z(i->getAttributeValue("id"),
  1054. i->getAttributeValue("id").getLength());
  1055. if (z) z->doPublicMausEreignis(me);
  1056. }
  1057. }
  1058. me.mx += rbr;
  1059. me.my += rbr;
  1060. if (hatStyle(Style::VScroll) && vertikalScrollBar)
  1061. me.my -= vertikalScrollBar->getScroll();
  1062. if (hatStyle(Style::HScroll) && horizontalScrollBar)
  1063. me.mx -= horizontalScrollBar->getScroll();
  1064. if (!hatStyle(Style::Sichtbar) || !me.insideParent || me.verarbeitet
  1065. || me.mx < 0 || me.my < 0 || me.mx >= gr.x || me.my >= gr.y
  1066. || !userRet)
  1067. me.insideParent = insideParent;
  1068. else
  1069. me.verarbeitet = 1;
  1070. if (hatStyleNicht(Style::Sichtbar)) me.verarbeitet = verarbeitet;
  1071. }
  1072. }
  1073. void Framework::UIMLView::setOnMemberMouseEvent(std::function<bool(
  1074. XML::Element& element, Zeichnung& member, MausEreignis me)>
  1075. onEventAction)
  1076. {
  1077. onMemberMouseEvent = onEventAction;
  1078. }
  1079. void Framework::UIMLView::setOnMemberKeyboardEvent(std::function<bool(
  1080. XML::Element& element, Zeichnung& member, TastaturEreignis te)>
  1081. onEventAction)
  1082. {
  1083. onMemberKeyboardEvent = onEventAction;
  1084. }
  1085. //! entfernt alle bekannten elemente, die im uiml verwendet werden können
  1086. void UIMLView::removeAllKnownElements()
  1087. {
  1088. knownElements.leeren();
  1089. }
  1090. //! fügt ein neues bekanntes element hinzu, dass danach im uiml verwendet werden
  1091. //! kann.
  1092. void UIMLView::addKnownElement(UIMLElement* element)
  1093. {
  1094. knownElements.add(element);
  1095. }
  1096. //! prüft, ob ein xml Element ein bekanntes uiml Element ist;
  1097. bool UIMLView::isKnownElement(XML::Element* zElement)
  1098. {
  1099. for (UIMLElement* element : knownElements)
  1100. {
  1101. if (element->isApplicableFor(*zElement)) return 1;
  1102. }
  1103. return 0;
  1104. }
  1105. // setzt den inhalt der view
  1106. // uiml: Ein xml element gemät des ksg uiml standarts
  1107. void UIMLView::setUIML(XML::Element* uiml)
  1108. {
  1109. if (dom)
  1110. { // update dom and members
  1111. auto newChilds = uiml->selectChildren().selectAllElements();
  1112. // remove old members
  1113. for (XML::Element *i : dom->selectChildren().selectAllElements().whereAttributeExists("id"))
  1114. {
  1115. Framework::Text id = i->getAttributeValue("id");
  1116. if (!newChilds.whereAttributeEquals("id", id).exists())
  1117. {
  1118. Zeichnung* z = members->z(id, id.getLength());
  1119. if (z) removeZeichnung(*z);
  1120. }
  1121. }
  1122. dom = uiml;
  1123. update();
  1124. }
  1125. else
  1126. { // initialize dom and members
  1127. dom = uiml;
  1128. for (auto i = dom->getChilds(); i; i++)
  1129. {
  1130. Zeichnung* z = parseElement(*i.val(), *this);
  1131. if (z) z->release();
  1132. }
  1133. }
  1134. }
  1135. // setzt den inhalt der view
  1136. // uiml: Ein xml text gemät des ksg uiml standarts
  1137. void UIMLView::setUIML(Text uiml)
  1138. {
  1139. setUIML(new XML::Element(uiml));
  1140. }
  1141. // Gibt eine zeichnung zurück, welche in uiml eine bestimmte id hat
  1142. // id: die id der Zeichnung
  1143. Zeichnung* UIMLView::zZeichnungById(const char* id)
  1144. {
  1145. return members->z(id, textLength(id));
  1146. }
  1147. // Gibt eine zeichnung zurück, welche in uiml eine bestimmte id hat
  1148. // id: die id der Zeichnung
  1149. Zeichnung* UIMLView::getZeichnungById(const char* id)
  1150. {
  1151. return members->get(id, textLength(id));
  1152. }
  1153. void Framework::UIMLView::update()
  1154. {
  1155. for (auto i = dom->getChilds(); i; i++)
  1156. {
  1157. Text id = i->getAttributeValue("id");
  1158. Zeichnung* z = zZeichnungById(id);
  1159. if (!id.getLength() || !z || !updateElement(*i.val(), *z, *this))
  1160. {
  1161. z = parseElement(*i.val(), *this);
  1162. if (z) z->release();
  1163. }
  1164. }
  1165. }
  1166. // aktualisiert größe und position aller Zeichnungen gemäß den spezifikationen
  1167. // in UIML
  1168. void UIMLView::layout()
  1169. {
  1170. if (dom)
  1171. {
  1172. for (auto i = dom->getChilds(); i; i++)
  1173. {
  1174. Text id = i->getAttributeValue("id");
  1175. Zeichnung* z = zZeichnungById(id);
  1176. if (z)
  1177. {
  1178. layout(*i.val(),
  1179. *z,
  1180. this->getInnenBreite(),
  1181. this->getInnenHeight(),
  1182. *this);
  1183. }
  1184. }
  1185. }
  1186. }
  1187. // fügt ein element hinzu
  1188. // uiml: Ein xml text gemät des KSG UIML standarts, welcher das neue Objekt
  1189. // darstellt
  1190. Text UIMLView::addMember(Text uiml)
  1191. {
  1192. XML::Element* e = new XML::Element(uiml);
  1193. Zeichnung* z = parseElement(*e, *this);
  1194. if (z)
  1195. {
  1196. dom->addChildAtFront(e);
  1197. z->release();
  1198. }
  1199. return e->getAttributeValue("id");
  1200. }
  1201. // fügt ein element zu einem Elternelement hinzu (funktioniert momentan nur mit
  1202. // frame Objekten)
  1203. // uiml: Ein xml text gemät des KSG UIML standarts, welcher das neue Objekt
  1204. // darstellt
  1205. Text UIMLView::addMember(Text uiml, Text parentId)
  1206. {
  1207. XML::Element* e = new XML::Element(uiml);
  1208. XML::Editor ed = dom->selectChildren();
  1209. while (ed.begin())
  1210. {
  1211. XML::Editor ed2 = ed.whereAttributeEquals("id", parentId);
  1212. if (ed2.begin())
  1213. {
  1214. if (ed2.begin()->getName().istGleich("frame"))
  1215. {
  1216. Zeichnung* z = parseElement(*e, *this);
  1217. if (z)
  1218. {
  1219. dynamic_cast<Fenster*>(
  1220. members->z(parentId, parentId.getLength()))
  1221. ->addMember(z);
  1222. ed2.begin()->addChild(e);
  1223. }
  1224. return e->getAttributeValue("id");
  1225. }
  1226. }
  1227. ed = ed.selectChildren();
  1228. }
  1229. e->release();
  1230. return "";
  1231. }
  1232. // entfernt ein element
  1233. // id: id des Elements
  1234. void UIMLView::removeMember(Text id)
  1235. {
  1236. XML::Editor e = dom->selectChildsByAttribute("id", id);
  1237. e.remove();
  1238. members->remove(id, id.getLength());
  1239. }
  1240. // Verarbeitet ein Tastatur Ereignis. Wird vom Framework automatisch aufgerufen
  1241. // te: Das Ereignis
  1242. void UIMLView::doTastaturEreignis(TastaturEreignis& te)
  1243. {
  1244. bool verarbeitet = te.verarbeitet;
  1245. ZeichnungHintergrund::doTastaturEreignis(te);
  1246. te.verarbeitet = verarbeitet;
  1247. if (dom)
  1248. {
  1249. for (auto i = dom->getChilds(); i; i++)
  1250. { // TODO render elements backwards
  1251. Zeichnung* z = members->z(i->getAttributeValue("id"),
  1252. i->getAttributeValue("id").getLength());
  1253. if (z) z->doTastaturEreignis(te);
  1254. }
  1255. }
  1256. }
  1257. // Updated den Zeichenhintergrund
  1258. // tickVal: Die vergangene Zeit in Sekunden, die seit dem Letzten Aufruf dieser
  1259. // Funktion verstrichen ist return: 1, wenn das Bild neu gezeichnet werden
  1260. // muss. 0 sonnst
  1261. bool UIMLView::tick(double tickVal)
  1262. {
  1263. if (dom)
  1264. {
  1265. for (auto i = dom->getChilds(); i; i++)
  1266. { // TODO render elements backwards
  1267. Zeichnung* z = members->z(i->getAttributeValue("id"),
  1268. i->getAttributeValue("id").getLength());
  1269. if (z) rend |= z->tick(tickVal);
  1270. }
  1271. }
  1272. return ZeichnungHintergrund::tick(tickVal);
  1273. }
  1274. // Zeichnet den Hintergrund eines Zeichnunges nach rObj
  1275. void UIMLView::render(Bild& rObj)
  1276. {
  1277. if (hatStyle(Zeichnung::Style::Sichtbar))
  1278. {
  1279. ZeichnungHintergrund::render(rObj);
  1280. if (dom)
  1281. {
  1282. if (!rObj.setDrawOptions(pos.x + getRahmenBreite(),
  1283. pos.y + getRahmenBreite(),
  1284. gr.x + getRahmenBreite() * 2,
  1285. gr.y + getRahmenBreite() * 2))
  1286. return;
  1287. bool vSc = hatStyle(Style::VScroll) && vertikalScrollBar;
  1288. bool hSc = hatStyle(Style::HScroll) && horizontalScrollBar;
  1289. rObj.addScrollOffset(hSc ? horizontalScrollBar->getScroll() : 0,
  1290. vSc ? vertikalScrollBar->getScroll() : 0);
  1291. for (int i = dom->getChildCount() - 1; i >= 0; i--)
  1292. { // TODO render elements backwards
  1293. XML::Element* e = dom->zChild(i);
  1294. Zeichnung* z = members->z(e->getAttributeValue("id"),
  1295. e->getAttributeValue("id").getLength());
  1296. if (z) z->render(rObj);
  1297. }
  1298. rObj.releaseDrawOptions();
  1299. }
  1300. }
  1301. }
  1302. // Gibt den Dom Tree ohne erhöhten reference counter zurück
  1303. // Änderungen am Dom Tree sollten vermieden werden (nur änderungen von
  1304. // attributen einzelner elemente sind erlaubt)
  1305. XML::Element* UIMLView::zDom() const
  1306. {
  1307. return dom;
  1308. }
  1309. // Gibt den Dom Tree zurück
  1310. // Änderungen am Dom Tree sollten vermieden werden (nur änderungen von
  1311. // attributen einzelner elemente sind erlaubt)
  1312. XML::Element* UIMLView::getDom() const
  1313. {
  1314. return dom ? dynamic_cast<XML::Element*>(dom->getThis()) : 0;
  1315. }
  1316. bool UIMLView::isApplicableFor(XML::Element& element)
  1317. {
  1318. for (UIMLElement* e : knownElements)
  1319. {
  1320. if (e->isApplicableFor(element)) return 1;
  1321. }
  1322. return 0;
  1323. }
  1324. Zeichnung* UIMLView::parseElement(
  1325. XML::Element& element, UIMLContainer& generalFactory)
  1326. {
  1327. Text id;
  1328. if (element.hasAttribute("id"))
  1329. id = element.getAttributeValue("id");
  1330. else
  1331. {
  1332. id = Text("_") += nextId++;
  1333. element.setAttribute("id", id);
  1334. }
  1335. Zeichnung* z = members->z(id, id.getLength());
  1336. if (!z)
  1337. {
  1338. // precompute attributes
  1339. if (element.hasAttribute("margin"))
  1340. {
  1341. Text m = element.getAttributeValue("margin");
  1342. if (!element.hasAttribute("margin-left"))
  1343. element.setAttribute("margin-left", m);
  1344. if (!element.hasAttribute("margin-top"))
  1345. element.setAttribute("margin-top", m);
  1346. if (!element.hasAttribute("margin-right"))
  1347. element.setAttribute("margin-right", m);
  1348. if (!element.hasAttribute("margin-bottom"))
  1349. element.setAttribute("margin-bottom", m);
  1350. }
  1351. if (element.hasAttribute("class"))
  1352. {
  1353. Text c = element.getAttributeValue("class");
  1354. while (1)
  1355. {
  1356. Text* t;
  1357. if (c.hat(","))
  1358. t = c.getTeilText(0, c.positionVon(','));
  1359. else
  1360. t = new Text(c);
  1361. XML::Editor ce
  1362. = dom->selectChildsByName("class").whereAttributeEquals(
  1363. "id", *t);
  1364. for (auto i = ce.begin(); i; i++)
  1365. {
  1366. for (auto j = i->getAttributeNames(),
  1367. k = i->getAttributeValues();
  1368. j && k;
  1369. j++, k++)
  1370. {
  1371. if (!element.hasAttribute(j->getText()))
  1372. element.setAttribute(j->getText(), i->getText());
  1373. }
  1374. }
  1375. t->release();
  1376. if (c.hat(","))
  1377. c.remove(0, c.positionVon(',' + 1));
  1378. else
  1379. break;
  1380. }
  1381. }
  1382. if (element.hasAttribute("text-align"))
  1383. {
  1384. if (!element.hasAttribute("text-align-horizontal"))
  1385. element.setAttribute("text-align-horizontal",
  1386. element.getAttributeValue("text-align"));
  1387. if (!element.hasAttribute("text-align-vertical"))
  1388. element.setAttribute("text-align-vertical",
  1389. element.getAttributeValue("text-align"));
  1390. }
  1391. // create objects
  1392. for (UIMLElement* e : knownElements)
  1393. {
  1394. if (e->isApplicableFor(element))
  1395. {
  1396. z = e->parseElement(element, *this);
  1397. break;
  1398. }
  1399. }
  1400. if (z)
  1401. {
  1402. if (hatStyle(Style::GlobalMouseEvent))
  1403. {
  1404. z->addMausEreignis(
  1405. [this, z](void* p, void* o, MausEreignis me) {
  1406. return dom->selectChildren()
  1407. .selectAllElements()
  1408. .whereAttributeEquals("id", getZeichnungId(*z))
  1409. .getFirstElement()
  1410. .map<bool>([this, &me, z](
  1411. RCPointer<XML::Element> element) {
  1412. return onMemberMouseEvent
  1413. ? onMemberMouseEvent(*element, *z, me)
  1414. : 0;
  1415. })
  1416. .orElse(0);
  1417. });
  1418. }
  1419. if (hatStyle(Style::GlobalTastaturEvent))
  1420. {
  1421. z->addTastaturEreignis(
  1422. [this, z](void* p, void* o, TastaturEreignis te) {
  1423. return dom->selectChildren()
  1424. .selectAllElements()
  1425. .whereAttributeEquals("id", getZeichnungId(*z))
  1426. .getFirstElement()
  1427. .map<bool>([this, &te, z](
  1428. RCPointer<XML::Element> element) {
  1429. return onMemberKeyboardEvent
  1430. ? onMemberKeyboardEvent(
  1431. *element, *z, te)
  1432. : 0;
  1433. })
  1434. .orElse(0);
  1435. });
  1436. }
  1437. members->set(
  1438. id, id.getLength(), dynamic_cast<Zeichnung*>(z->getThis()));
  1439. idList.add(new Text(id));
  1440. memberList.add(z);
  1441. }
  1442. }
  1443. else
  1444. z->getThis();
  1445. return z;
  1446. }
  1447. bool Framework::UIMLView::updateElement(
  1448. XML::Element& element, Zeichnung& z, UIMLContainer& generalFactory)
  1449. {
  1450. bool result = 0;
  1451. for (UIMLElement* e : knownElements)
  1452. {
  1453. if (e->isApplicableFor(element))
  1454. {
  1455. result = e->updateElement(element, z, *this);
  1456. break;
  1457. }
  1458. }
  1459. if (!result)
  1460. {
  1461. for (XML::Element* element :
  1462. element.selectChildren().selectAllElements().whereAttributeExists(
  1463. "id"))
  1464. { // element could not be updated so all children will be removed
  1465. Framework::Text id = element->getAttributeValue("id");
  1466. Zeichnung* z = zZeichnungById(id);
  1467. if (z) removeZeichnung(*z);
  1468. }
  1469. removeZeichnung(z);
  1470. }
  1471. return result;
  1472. }
  1473. void UIMLView::layout(XML::Element& element,
  1474. Zeichnung& z,
  1475. int pWidth,
  1476. int pHeight,
  1477. UIMLContainer& generalLayouter)
  1478. {
  1479. for (UIMLElement* e : knownElements)
  1480. {
  1481. if (e->isApplicableFor(element))
  1482. {
  1483. e->layout(element, z, pWidth, pHeight, *this);
  1484. break;
  1485. }
  1486. }
  1487. }
  1488. Text Framework::UIMLView::getZeichnungId(Zeichnung& z)
  1489. {
  1490. int index = memberList.getWertIndex(&z);
  1491. if (index >= 0) return *idList.z(index);
  1492. return "";
  1493. }
  1494. void Framework::UIMLView::removeZeichnung(Zeichnung& z)
  1495. {
  1496. int index = memberList.getWertIndex(&z);
  1497. if (index >= 0)
  1498. {
  1499. Text id = *idList.z(index);
  1500. idList.remove(index);
  1501. memberList.remove(index);
  1502. members->remove(id, id.getLength());
  1503. }
  1504. }
  1505. bool Framework::UIMLView::registerZeichnung(const char* id, Zeichnung* z)
  1506. {
  1507. Zeichnung* existing = members->z(id, textLength(id));
  1508. if (existing)
  1509. {
  1510. z->release();
  1511. return 0;
  1512. }
  1513. members->set(id, textLength(id), z);
  1514. return 1;
  1515. }
  1516. const UIInit& UIMLView::getFactory()
  1517. {
  1518. return init;
  1519. }
  1520. //! calculates the needed size for all content elements to be visible
  1521. Punkt UIMLView::calculateContentSize()
  1522. {
  1523. Punkt maxP(0, 0);
  1524. for (int i = dom->getChildCount() - 1; i >= 0; i--)
  1525. { // TODO render elements backwards
  1526. XML::Element* e = dom->zChild(i);
  1527. Zeichnung* z = members->z(
  1528. e->getAttributeValue("id"), e->getAttributeValue("id").getLength());
  1529. if (z)
  1530. {
  1531. maxP.x = MAX(maxP.x, z->getPosition().x + z->getBreite());
  1532. maxP.y = MAX(maxP.y, z->getPosition().y + z->getHeight());
  1533. }
  1534. }
  1535. maxP.x += 2 * getRahmenBreite();
  1536. maxP.y += 2 * getRahmenBreite();
  1537. return maxP;
  1538. }