UIMLView.cpp 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029
  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 "Schrift.h"
  8. #include "Scroll.h"
  9. #include "Tabelle.h"
  10. #include "TextFeld.h"
  11. #include "XML.h"
  12. using namespace Framework;
  13. UIMLElement::UIMLElement()
  14. : ReferenceCounter()
  15. {}
  16. UIMLElement::~UIMLElement() {}
  17. //! wendet die layout parameter zu einer Zeichnung an
  18. void UIMLElement::layout(XML::Element& element,
  19. Zeichnung& z,
  20. int pWidth,
  21. int pHeight,
  22. UIMLContainer& generalLayouter)
  23. {
  24. int width = z.getBreite();
  25. int height = z.getHeight();
  26. if (element.hasAttribute("width"))
  27. {
  28. Text w = element.getAttributeValue("width");
  29. if (!w.istGleich("auto"))
  30. {
  31. width = (int)w;
  32. if (w.getText()[w.getLength() - 1] == '%')
  33. width = (int)((pWidth / 100.0) * width);
  34. }
  35. }
  36. if (element.hasAttribute("height"))
  37. {
  38. Text h = element.getAttributeValue("height");
  39. if (!h.istGleich("auto"))
  40. {
  41. height = (int)h;
  42. if (h.getText()[h.getLength() - 1] == '%')
  43. height = (int)((pHeight / 100.0) * height);
  44. }
  45. }
  46. z.setSize(width, height);
  47. if (element.hasAttribute("align-left"))
  48. {
  49. Text la = element.getAttributeValue("align-left");
  50. int x = 0;
  51. if (la.istGleich("start"))
  52. x = 0;
  53. else if (la.istGleich("end"))
  54. x = pWidth;
  55. else if (la.istGleich("center"))
  56. x = pWidth / 2 - width / 2;
  57. else
  58. {
  59. XML::Editor ed
  60. = element.zParent()->selectChildsByAttribute("id", la);
  61. generalLayouter.layout(*ed.begin().val(),
  62. *generalLayouter.zZeichnungById(la),
  63. pWidth,
  64. pHeight,
  65. generalLayouter);
  66. Zeichnung* laz = generalLayouter.zZeichnungById(la);
  67. if (laz) x = laz->getX() + laz->getBreite();
  68. }
  69. if (element.hasAttribute("margin-left"))
  70. {
  71. Text mt = element.getAttributeValue("margin-left");
  72. int m = (int)mt;
  73. if (mt.getText()[mt.getLength() - 1] == '%')
  74. m = (int)((pWidth / 100.0) * m);
  75. x += m;
  76. }
  77. z.setX(x);
  78. }
  79. else if (element.hasAttribute("align-right"))
  80. {
  81. Text ra = element.getAttributeValue("align-right");
  82. int x = 0;
  83. if (ra.istGleich("start"))
  84. x = -z.getBreite();
  85. else if (ra.istGleich("end"))
  86. x = pWidth - z.getBreite();
  87. else if (ra.istGleich("center"))
  88. x = pWidth / 2 - width / 2;
  89. else
  90. {
  91. XML::Editor ed
  92. = element.zParent()->selectChildsByAttribute("id", ra);
  93. generalLayouter.layout(*ed.begin().val(),
  94. *generalLayouter.zZeichnungById(ra),
  95. pWidth,
  96. pHeight,
  97. generalLayouter);
  98. Zeichnung* raz = generalLayouter.zZeichnungById(ra);
  99. if (raz) x = raz->getX() - z.getBreite();
  100. }
  101. if (element.hasAttribute("margin-right"))
  102. {
  103. Text mt = element.getAttributeValue("margin-right");
  104. int m = (int)mt;
  105. if (mt.getText()[mt.getLength() - 1] == '%')
  106. m = (int)((pWidth / 100.0) * m);
  107. x -= m;
  108. }
  109. z.setX(x);
  110. }
  111. if (element.hasAttribute("align-top"))
  112. {
  113. Text ta = element.getAttributeValue("align-top");
  114. int y = 0;
  115. if (ta.istGleich("start"))
  116. y = 0;
  117. else if (ta.istGleich("end"))
  118. y = pHeight;
  119. else if (ta.istGleich("center"))
  120. y = pHeight / 2 - height / 2;
  121. else
  122. {
  123. XML::Editor ed
  124. = element.zParent()->selectChildsByAttribute("id", ta);
  125. generalLayouter.layout(*ed.begin().val(),
  126. *generalLayouter.zZeichnungById(ta),
  127. pWidth,
  128. pHeight,
  129. generalLayouter);
  130. Zeichnung* taz = generalLayouter.zZeichnungById(ta);
  131. if (taz) y = taz->getY() + taz->getHeight();
  132. }
  133. if (element.hasAttribute("margin-top"))
  134. {
  135. Text mt = element.getAttributeValue("margin-top");
  136. int m = (int)mt;
  137. if (mt.getText()[mt.getLength() - 1] == '%')
  138. m = (int)((pHeight / 100.0) * m);
  139. y += m;
  140. }
  141. z.setY(y);
  142. }
  143. else if (element.hasAttribute("align-bottom"))
  144. {
  145. Text ba = element.getAttributeValue("align-bottom");
  146. int y = 0;
  147. if (ba.istGleich("start"))
  148. y = -z.getHeight();
  149. else if (ba.istGleich("end"))
  150. y = pHeight - z.getHeight();
  151. else if (ba.istGleich("center"))
  152. y = pHeight / 2 - height / 2;
  153. else
  154. {
  155. XML::Editor ed
  156. = element.zParent()->selectChildsByAttribute("id", ba);
  157. generalLayouter.layout(*ed.begin().val(),
  158. *generalLayouter.zZeichnungById(ba),
  159. pWidth,
  160. pHeight,
  161. generalLayouter);
  162. Zeichnung* baz = generalLayouter.zZeichnungById(ba);
  163. if (baz) y = baz->getY() - z.getHeight();
  164. }
  165. if (element.hasAttribute("margin-bottom"))
  166. {
  167. Text mt = element.getAttributeValue("margin-bottom");
  168. int m = (int)mt;
  169. if (mt.getText()[mt.getLength() - 1] == '%')
  170. m = (int)((pHeight / 100.0) * m);
  171. y -= m;
  172. }
  173. z.setY(y);
  174. }
  175. int x = z.getX();
  176. int y = z.getY();
  177. if (element.hasAttribute("x"))
  178. {
  179. Text xt = element.getAttributeValue("x");
  180. x = (int)xt;
  181. if (xt.getText()[xt.getLength() - 1] == '%')
  182. x = (int)((pWidth / 100.0) * x);
  183. }
  184. if (element.hasAttribute("y"))
  185. {
  186. Text yt = element.getAttributeValue("y");
  187. y = (int)yt;
  188. if (yt.getText()[yt.getLength() - 1] == '%')
  189. y = (int)((pHeight / 100.0) * y);
  190. }
  191. z.setPosition(x, y);
  192. pWidth = z.getInnenBreite();
  193. pHeight = z.getInnenHeight();
  194. // recursive layout
  195. for (auto i = element.getChilds(); i; i++)
  196. {
  197. Zeichnung* z = 0;
  198. if (i->hasAttribute("id"))
  199. {
  200. z = generalLayouter.zZeichnungById(i->getAttributeValue("id"));
  201. }
  202. if (z)
  203. {
  204. generalLayouter.layout(*i.val(),
  205. *generalLayouter.zZeichnungById(i->getAttributeValue("id")),
  206. pWidth,
  207. pHeight,
  208. generalLayouter);
  209. }
  210. }
  211. }
  212. UIMLContainer::UIMLContainer()
  213. : UIMLElement()
  214. {}
  215. UIMLContainer::~UIMLContainer() {}
  216. UIMLTextField::UIMLTextField()
  217. : UIMLElement()
  218. {}
  219. bool UIMLTextField::isApplicableFor(XML::Element& element)
  220. {
  221. return element.getName().istGleich("textfield");
  222. }
  223. Zeichnung* UIMLTextField::parseElement(
  224. XML::Element& element, UIMLContainer& generalFactory)
  225. {
  226. TextFeld* t = generalFactory.getFactory().createTextFeld(
  227. generalFactory.getFactory().initParam);
  228. t->addStyle(TextFeld::Style::TextFeld);
  229. return t;
  230. }
  231. void UIMLTextField::layout(XML::Element& element,
  232. Zeichnung& z,
  233. int pWidth,
  234. int pHeight,
  235. UIMLContainer& generalLayouter)
  236. {
  237. z.setStyle(TextFeld::Style::HCenter,
  238. element.hasAttribute("text-align-horizontal")
  239. && element.getAttributeValue("text-align-horizontal")
  240. .istGleich("center"));
  241. z.setStyle(TextFeld::Style::VCenter,
  242. element.hasAttribute("text-align-vertical")
  243. && element.getAttributeValue("text-align-vertical")
  244. .istGleich("center"));
  245. if (element.hasAttribute("font-size"))
  246. ((TextFeld*)&z)
  247. ->setSchriftSize(
  248. (unsigned char)(int)element.getAttributeValue("font-size"));
  249. z.setStyle(TextFeld::Style::Editierbar,
  250. !element.hasAttribute("disabled")
  251. || (element.getAttributeValue("disabled").getLength() != 0
  252. && !element.getAttributeValue("disabled").istGleich("true")));
  253. ((TextFeld*)&z)->setText(element.getText());
  254. if (element.hasAttribute("width"))
  255. {
  256. Text w = element.getAttributeValue("width");
  257. if (w.istGleich("auto"))
  258. {
  259. z.setWidth(((TextFeld*)&z)->getNeededWidth());
  260. }
  261. }
  262. if (element.hasAttribute("height"))
  263. {
  264. Text h = element.getAttributeValue("height");
  265. if (h.istGleich("auto"))
  266. {
  267. z.setHeight(((TextFeld*)&z)->getNeededHeight());
  268. }
  269. }
  270. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  271. }
  272. UIMLButton::UIMLButton()
  273. : UIMLElement()
  274. {}
  275. bool UIMLButton::isApplicableFor(XML::Element& element)
  276. {
  277. return element.getName().istGleich("button");
  278. }
  279. Zeichnung* UIMLButton::parseElement(
  280. XML::Element& element, UIMLContainer& generalFactory)
  281. {
  282. Knopf* k = generalFactory.getFactory().createKnopf(
  283. generalFactory.getFactory().initParam);
  284. return k;
  285. }
  286. void UIMLButton::layout(XML::Element& element,
  287. Zeichnung& z,
  288. int pWidth,
  289. int pHeight,
  290. UIMLContainer& generalLayouter)
  291. {
  292. if (element.hasAttribute("font-size"))
  293. ((Knopf*)&z)
  294. ->setSchriftSize(
  295. (unsigned char)(int)element.getAttributeValue("font-size"));
  296. ((Knopf*)&z)->setText(element.getText());
  297. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  298. }
  299. UIMLCheck::UIMLCheck()
  300. : UIMLElement()
  301. {}
  302. bool UIMLCheck::isApplicableFor(XML::Element& element)
  303. {
  304. return element.getName().istGleich("check");
  305. }
  306. Zeichnung* UIMLCheck::parseElement(
  307. XML::Element& element, UIMLContainer& generalFactory)
  308. {
  309. KontrollKnopf* k = generalFactory.getFactory().createKontrollKnopf(
  310. generalFactory.getFactory().initParam);
  311. return k;
  312. }
  313. void UIMLCheck::layout(XML::Element& element,
  314. Zeichnung& z,
  315. int pWidth,
  316. int pHeight,
  317. UIMLContainer& generalLayouter)
  318. {
  319. ((KontrollKnopf*)&z)->setText(element.getText());
  320. ((KontrollKnopf*)&z)->setSText(element.getText());
  321. z.setStyle(
  322. KontrollKnopf::Style::Selected, element.hasAttribute("selected"));
  323. if (element.hasAttribute("font-size"))
  324. ((KontrollKnopf*)&z)
  325. ->setSSize(
  326. (unsigned char)(int)element.getAttributeValue("font-size"));
  327. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  328. }
  329. UIMLText::UIMLText()
  330. : UIMLElement()
  331. {}
  332. bool UIMLText::isApplicableFor(XML::Element& element)
  333. {
  334. return element.getName().istGleich("text");
  335. }
  336. Zeichnung* UIMLText::parseElement(
  337. XML::Element& element, UIMLContainer& generalFactory)
  338. {
  339. TextFeld* t = generalFactory.getFactory().createTextFeld(
  340. generalFactory.getFactory().initParam);
  341. t->addStyle(TextFeld::Style::Text);
  342. return t;
  343. }
  344. void UIMLText::layout(XML::Element& element,
  345. Zeichnung& z,
  346. int pWidth,
  347. int pHeight,
  348. UIMLContainer& generalLayouter)
  349. {
  350. z.setStyle(TextFeld::Style::HCenter,
  351. element.hasAttribute("text-align-horizontal")
  352. && element.getAttributeValue("text-align-horizontal")
  353. .istGleich("center"));
  354. z.setStyle(TextFeld::Style::VCenter,
  355. element.hasAttribute("text-align-vertical")
  356. && element.getAttributeValue("text-align-vertical")
  357. .istGleich("center"));
  358. if (element.hasAttribute("font-size"))
  359. ((TextFeld*)&z)
  360. ->setSchriftSize(
  361. (unsigned char)(int)element.getAttributeValue("font-size"));
  362. z.setStyle(TextFeld::Style::Editierbar,
  363. !element.hasAttribute("disabled")
  364. || (element.getAttributeValue("disabled").getLength() != 0
  365. && !element.getAttributeValue("disabled").istGleich("true")));
  366. ((TextFeld*)&z)->setText(element.getText());
  367. if (element.hasAttribute("width"))
  368. {
  369. Text w = element.getAttributeValue("width");
  370. if (w.istGleich("auto"))
  371. {
  372. z.setWidth(((TextFeld*)&z)->getNeededWidth());
  373. }
  374. }
  375. if (element.hasAttribute("height"))
  376. {
  377. Text h = element.getAttributeValue("height");
  378. if (h.istGleich("auto"))
  379. {
  380. z.setHeight(((TextFeld*)&z)->getNeededHeight());
  381. }
  382. }
  383. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  384. }
  385. UIMLTextArea::UIMLTextArea()
  386. : UIMLElement()
  387. {}
  388. bool UIMLTextArea::isApplicableFor(XML::Element& element)
  389. {
  390. return element.getName().istGleich("textarea");
  391. }
  392. Zeichnung* UIMLTextArea::parseElement(
  393. XML::Element& element, UIMLContainer& generalFactory)
  394. {
  395. TextFeld* t = generalFactory.getFactory().createTextFeld(
  396. generalFactory.getFactory().initParam);
  397. t->addStyle(TextFeld::Style::TextGebiet);
  398. return t;
  399. }
  400. void UIMLTextArea::layout(XML::Element& element,
  401. Zeichnung& z,
  402. int pWidth,
  403. int pHeight,
  404. UIMLContainer& generalLayouter)
  405. {
  406. z.setStyle(TextFeld::Style::HCenter,
  407. element.hasAttribute("text-align-horizontal")
  408. && element.getAttributeValue("text-align-horizontal")
  409. .istGleich("center"));
  410. z.setStyle(TextFeld::Style::VCenter,
  411. element.hasAttribute("text-align-vertical")
  412. && element.getAttributeValue("text-align-vertical")
  413. .istGleich("center"));
  414. if (element.hasAttribute("font-size"))
  415. ((TextFeld*)&z)
  416. ->setSchriftSize(
  417. (unsigned char)(int)element.getAttributeValue("font-size"));
  418. z.setStyle(TextFeld::Style::Editierbar,
  419. !element.hasAttribute("disabled")
  420. || (element.getAttributeValue("disabled").getLength() != 0
  421. && !element.getAttributeValue("disabled").istGleich("true")));
  422. ((TextFeld*)&z)->setText(element.getText());
  423. ((TextFeld*)&z)
  424. ->zTextRenderer()
  425. ->textFormatieren(((TextFeld*)&z)->zText(), z.getInnenBreite());
  426. if (element.hasAttribute("width"))
  427. {
  428. Text w = element.getAttributeValue("width");
  429. if (w.istGleich("auto"))
  430. {
  431. z.setWidth(((TextFeld*)&z)->getNeededWidth());
  432. }
  433. }
  434. if (element.hasAttribute("height"))
  435. {
  436. Text h = element.getAttributeValue("height");
  437. if (h.istGleich("auto"))
  438. {
  439. z.setHeight(((TextFeld*)&z)->getNeededHeight());
  440. }
  441. }
  442. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  443. }
  444. UIMLTable::UIMLTable()
  445. : UIMLElement()
  446. {}
  447. bool UIMLTable::isApplicableFor(XML::Element& element)
  448. {
  449. return element.getName().istGleich("table");
  450. }
  451. Zeichnung* UIMLTable::parseElement(
  452. XML::Element& element, UIMLContainer& generalFactory)
  453. {
  454. ObjTabelle* t = generalFactory.getFactory().createObjTabelle(
  455. generalFactory.getFactory().initParam);
  456. int index = 0;
  457. for (auto i = element.getChilds(); i; i++)
  458. {
  459. Text id;
  460. if (i->hasAttribute("id"))
  461. id = i->getAttributeValue("id");
  462. else
  463. {
  464. id = Text("_") += index++;
  465. i->setAttribute("id", id);
  466. }
  467. if (i->getName().istGleich("tr"))
  468. {
  469. t->addZeile(id);
  470. Text line = id;
  471. int c = 1;
  472. for (auto j = i->getChilds(); j; j++)
  473. {
  474. Zeichnung* z
  475. = generalFactory.parseElement(*i.val(), generalFactory);
  476. if (t->getSpaltenAnzahl() < c) t->addSpalte(Text(c - 1));
  477. if (z) t->setZeichnungZ(Text(c - 1), line, z);
  478. c++;
  479. }
  480. }
  481. }
  482. return t;
  483. }
  484. void UIMLTable::layout(XML::Element& element,
  485. Zeichnung& z,
  486. int pWidth,
  487. int pHeight,
  488. UIMLContainer& generalLayouter)
  489. {
  490. z.setStyle(ObjTabelle::Style::HScroll,
  491. element.hasAttribute("scroll")
  492. && element.getAttributeValue("scroll").istGleich("horizontal"));
  493. z.setStyle(ObjTabelle::Style::VScroll,
  494. element.hasAttribute("scroll")
  495. && element.getAttributeValue("scroll").istGleich("vertical"));
  496. z.setStyle(ObjTabelle::Style::scroll,
  497. element.hasAttribute("scroll")
  498. && element.getAttributeValue("scroll").istGleich("both"));
  499. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  500. ObjTabelle* objT = (ObjTabelle*)&z;
  501. if (objT->getZeilenAnzahl() > 0)
  502. {
  503. if (element.hasAttribute("line-height"))
  504. {
  505. int height = (int)element.getAttributeValue("line-height");
  506. for (int i = 0; i < objT->getZeilenAnzahl(); i++)
  507. objT->setZeilenHeight(i, height);
  508. }
  509. for (int i = 0; i < objT->getSpaltenAnzahl(); i++)
  510. {
  511. if (objT->zZeichnung(i, 0))
  512. objT->setSpaltenBreite(i, objT->zZeichnung(i, 0)->getBreite());
  513. }
  514. }
  515. }
  516. UIMLFrame::UIMLFrame()
  517. : UIMLElement()
  518. {}
  519. bool UIMLFrame::isApplicableFor(XML::Element& element)
  520. {
  521. return element.getName().istGleich("frame");
  522. }
  523. Zeichnung* UIMLFrame::parseElement(
  524. XML::Element& element, UIMLContainer& generalFactory)
  525. {
  526. Fenster* f = generalFactory.getFactory().createFenster(
  527. generalFactory.getFactory().initParam);
  528. for (auto i = element.getChilds(); i; i++)
  529. {
  530. Zeichnung* z = generalFactory.parseElement(*i.val(), generalFactory);
  531. if (z) f->addMember(z);
  532. }
  533. return f;
  534. }
  535. void UIMLFrame::layout(XML::Element& element,
  536. Zeichnung& z,
  537. int pWidth,
  538. int pHeight,
  539. UIMLContainer& generalLayouter)
  540. {
  541. if (element.hasAttribute("title"))
  542. ((Fenster*)&z)->setTitel(element.getAttributeValue("title"));
  543. if (element.hasAttribute("title-height"))
  544. ((Fenster*)&z)
  545. ->zTTextFeld()
  546. ->setSize(((Fenster*)&z)->zTTextFeld()->getBreite(),
  547. (int)element.getAttributeValue("title-height"));
  548. UIMLElement::layout(element, z, pWidth, pHeight, generalLayouter);
  549. }
  550. // Erstellt eine UIML View
  551. UIMLView::UIMLView()
  552. : ZeichnungHintergrund()
  553. {
  554. style = Style::MEIgnoreInside | Style::MEIgnoreParentInside
  555. | Style::MEIgnoreSichtbar | Style::MEIgnoreVerarbeitet;
  556. members = new Trie<Zeichnung>();
  557. dom = 0;
  558. nextId = 0;
  559. memset(&init, 0, sizeof(UIInit));
  560. addKnownElement(new UIMLTextField());
  561. addKnownElement(new UIMLButton());
  562. addKnownElement(new UIMLCheck());
  563. addKnownElement(new UIMLText());
  564. addKnownElement(new UIMLTextArea());
  565. addKnownElement(new UIMLTable());
  566. addKnownElement(new UIMLFrame());
  567. }
  568. // Erstellt eine UIML View zu einem UIML Text
  569. // uiml: Ein xml element gemät des ksg uiml standarts
  570. UIMLView::UIMLView(XML::Element* uiml, UIInit& init)
  571. : UIMLView()
  572. {
  573. this->init = init;
  574. setUIML(uiml);
  575. }
  576. // Erstellt eine UIML View zu einem UIML Text
  577. // uiml: Ein xml text gemät des ksg uiml standarts
  578. UIMLView::UIMLView(Text uiml, UIInit& init)
  579. : UIMLView()
  580. {
  581. this->init = init;
  582. setUIML(uiml);
  583. }
  584. UIMLView::~UIMLView()
  585. {
  586. if (dom) dom->release();
  587. members->release();
  588. }
  589. // Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch aufgerufen.
  590. // me: Das Ereignis
  591. void UIMLView::doMausEreignis(MausEreignis& me, bool userRet)
  592. {
  593. if (dom)
  594. {
  595. bool verarbeitet = me.verarbeitet;
  596. me.verarbeitet |= hatStyleNicht(Style::Sichtbar);
  597. bool insideParent = me.insideParent;
  598. if (!hatStyle(Style::Sichtbar) || !me.insideParent || me.verarbeitet
  599. || me.mx < 0 || me.my < 0 || me.mx >= gr.x || me.my >= gr.y
  600. || !userRet)
  601. me.insideParent = 0;
  602. int rbr = 0;
  603. if (hatStyle(Style::Rahmen) && rahmen) rbr = rahmen->getRBreite();
  604. me.mx -= rbr;
  605. me.my -= rbr;
  606. if (hatStyle(Style::VScroll) && vertikalScrollBar)
  607. me.my += vertikalScrollBar->getScroll();
  608. if (hatStyle(Style::HScroll) && horizontalScrollBar)
  609. me.mx += horizontalScrollBar->getScroll();
  610. if (dom)
  611. {
  612. for (auto i = dom->getChilds(); i; i++)
  613. { // TODO render elements backwards
  614. Zeichnung* z = members->z(i->getAttributeValue("id"),
  615. i->getAttributeValue("id").getLength());
  616. if (z) z->doPublicMausEreignis(me);
  617. }
  618. }
  619. me.mx += rbr;
  620. me.my += rbr;
  621. if (hatStyle(Style::VScroll) && vertikalScrollBar)
  622. me.my -= vertikalScrollBar->getScroll();
  623. if (hatStyle(Style::HScroll) && horizontalScrollBar)
  624. me.mx -= horizontalScrollBar->getScroll();
  625. if (!hatStyle(Style::Sichtbar) || !me.insideParent || me.verarbeitet
  626. || me.mx < 0 || me.my < 0 || me.mx >= gr.x || me.my >= gr.y
  627. || !userRet)
  628. me.insideParent = insideParent;
  629. else
  630. me.verarbeitet = 1;
  631. if (hatStyleNicht(Style::Sichtbar)) me.verarbeitet = verarbeitet;
  632. }
  633. }
  634. //! entfernt alle bekannten elemente, die im uiml verwendet werden können
  635. void UIMLView::removeAllKnownElements()
  636. {
  637. knownElements.leeren();
  638. }
  639. //! fügt ein neues bekanntes element hinzu, dass danach im uiml verwendet werden
  640. //! kann.
  641. void UIMLView::addKnownElement(UIMLElement* element)
  642. {
  643. knownElements.add(element);
  644. }
  645. //! prüft, ob ein xml Element ein bekanntes uiml Element ist;
  646. bool UIMLView::isKnownElement(XML::Element* zElement)
  647. {
  648. for (UIMLElement* element : knownElements)
  649. {
  650. if (element->isApplicableFor(*zElement)) return 1;
  651. }
  652. return 0;
  653. }
  654. // setzt den inhalt der view
  655. // uiml: Ein xml element gemät des ksg uiml standarts
  656. void UIMLView::setUIML(XML::Element* uiml)
  657. {
  658. if (dom) dom->release();
  659. dom = uiml;
  660. members->leeren();
  661. nextId = 0;
  662. if (dom)
  663. {
  664. for (auto i = dom->getChilds(); i; i++)
  665. {
  666. Zeichnung* z = parseElement(*i.val(), *this);
  667. if (z) z->release();
  668. }
  669. }
  670. }
  671. // setzt den inhalt der view
  672. // uiml: Ein xml text gemät des ksg uiml standarts
  673. void UIMLView::setUIML(Text uiml)
  674. {
  675. setUIML(new XML::Element(uiml));
  676. }
  677. // Gibt eine zeichnung zurück, welche in uiml eine bestimmte id hat
  678. // id: die id der Zeichnung
  679. Zeichnung* UIMLView::zZeichnungById(const char* id)
  680. {
  681. return members->z(id, textLength(id));
  682. }
  683. // Gibt eine zeichnung zurück, welche in uiml eine bestimmte id hat
  684. // id: die id der Zeichnung
  685. Zeichnung* UIMLView::getZeichnungById(const char* id)
  686. {
  687. return members->get(id, textLength(id));
  688. }
  689. // aktualisiert größe und position aller Zeichnungen gemäß den spezifikationen
  690. // in UIML
  691. void UIMLView::layout()
  692. {
  693. if (dom)
  694. {
  695. for (auto i = dom->getChilds(); i; i++)
  696. {
  697. Text id = i->getAttributeValue("id");
  698. Zeichnung* z = zZeichnungById(id);
  699. if (z)
  700. {
  701. layout(*i.val(),
  702. *z,
  703. this->getInnenBreite(),
  704. this->getInnenHeight(),
  705. *this);
  706. }
  707. }
  708. }
  709. }
  710. // fügt ein element hinzu
  711. // uiml: Ein xml text gemät des KSG UIML standarts, welcher das neue Objekt
  712. // darstellt
  713. Text UIMLView::addMember(Text uiml)
  714. {
  715. XML::Element* e = new XML::Element(uiml);
  716. Zeichnung* z = parseElement(*e, *this);
  717. if (z)
  718. {
  719. dom->addChildAtFront(e);
  720. z->release();
  721. }
  722. return e->getAttributeValue("id");
  723. }
  724. // fügt ein element zu einem Elternelement hinzu (funktioniert momentan nur mit
  725. // frame Objekten)
  726. // uiml: Ein xml text gemät des KSG UIML standarts, welcher das neue Objekt
  727. // darstellt
  728. Text UIMLView::addMember(Text uiml, Text parentId)
  729. {
  730. XML::Element* e = new XML::Element(uiml);
  731. XML::Editor ed = dom->selectChildren();
  732. while (ed.begin())
  733. {
  734. XML::Editor ed2 = ed.whereAttributeEquals("id", parentId);
  735. if (ed2.begin())
  736. {
  737. if (ed2.begin()->getName().istGleich("frame"))
  738. {
  739. Zeichnung* z = parseElement(*e, *this);
  740. if (z)
  741. {
  742. dynamic_cast<Fenster*>(
  743. members->z(parentId, parentId.getLength()))
  744. ->addMember(z);
  745. ed2.begin()->addChild(e);
  746. }
  747. return e->getAttributeValue("id");
  748. }
  749. }
  750. ed = ed.selectChildren();
  751. }
  752. e->release();
  753. return "";
  754. }
  755. // entfernt ein element
  756. // id: id des Elements
  757. void UIMLView::removeMember(Text id)
  758. {
  759. XML::Editor e = dom->selectChildsByAttribute("id", id);
  760. e.remove();
  761. members->remove(id, id.getLength());
  762. }
  763. // Verarbeitet ein Tastatur Ereignis. Wird vom Framework automatisch aufgerufen
  764. // te: Das Ereignis
  765. void UIMLView::doTastaturEreignis(TastaturEreignis& te)
  766. {
  767. bool verarbeitet = te.verarbeitet;
  768. ZeichnungHintergrund::doTastaturEreignis(te);
  769. te.verarbeitet = verarbeitet;
  770. if (dom)
  771. {
  772. for (auto i = dom->getChilds(); i; i++)
  773. { // TODO render elements backwards
  774. Zeichnung* z = members->z(i->getAttributeValue("id"),
  775. i->getAttributeValue("id").getLength());
  776. if (z) z->doTastaturEreignis(te);
  777. }
  778. }
  779. }
  780. // Updated den Zeichenhintergrund
  781. // tickVal: Die vergangene Zeit in Sekunden, die seit dem Letzten Aufruf dieser
  782. // Funktion verstrichen ist return: 1, wenn das Bild neu gezeichnet werden
  783. // muss. 0 sonnst
  784. bool UIMLView::tick(double tickVal)
  785. {
  786. if (dom)
  787. {
  788. for (auto i = dom->getChilds(); i; i++)
  789. { // TODO render elements backwards
  790. Zeichnung* z = members->z(i->getAttributeValue("id"),
  791. i->getAttributeValue("id").getLength());
  792. if (z) rend |= z->tick(tickVal);
  793. }
  794. }
  795. return ZeichnungHintergrund::tick(tickVal);
  796. }
  797. // Zeichnet den Hintergrund eines Zeichnunges nach rObj
  798. void UIMLView::render(Bild& rObj)
  799. {
  800. if (hatStyle(Zeichnung::Style::Sichtbar))
  801. {
  802. ZeichnungHintergrund::render(rObj);
  803. if (dom)
  804. {
  805. if (!rObj.setDrawOptions(pos.x + getRahmenBreite(),
  806. pos.y + getRahmenBreite(),
  807. gr.x + getRahmenBreite() * 2,
  808. gr.y + getRahmenBreite() * 2))
  809. return;
  810. bool vSc = hatStyle(Style::VScroll) && vertikalScrollBar;
  811. bool hSc = hatStyle(Style::HScroll) && horizontalScrollBar;
  812. rObj.addScrollOffset(hSc ? horizontalScrollBar->getScroll() : 0,
  813. vSc ? vertikalScrollBar->getScroll() : 0);
  814. for (int i = dom->getChildCount() - 1; i >= 0; i--)
  815. { // TODO render elements backwards
  816. XML::Element* e = dom->zChild(i);
  817. Zeichnung* z = members->z(e->getAttributeValue("id"),
  818. e->getAttributeValue("id").getLength());
  819. if (z) z->render(rObj);
  820. }
  821. rObj.releaseDrawOptions();
  822. }
  823. }
  824. }
  825. // Gibt den Dom Tree ohne erhöhten reference counter zurück
  826. // Änderungen am Dom Tree sollten vermieden werden (nur änderungen von
  827. // attributen einzelner elemente sind erlaubt)
  828. XML::Element* UIMLView::zDom() const
  829. {
  830. return dom;
  831. }
  832. // Gibt den Dom Tree zurück
  833. // Änderungen am Dom Tree sollten vermieden werden (nur änderungen von
  834. // attributen einzelner elemente sind erlaubt)
  835. XML::Element* UIMLView::getDom() const
  836. {
  837. return dom ? dynamic_cast<XML::Element*>(dom->getThis()) : 0;
  838. }
  839. bool UIMLView::isApplicableFor(XML::Element& element)
  840. {
  841. for (UIMLElement* e : knownElements)
  842. {
  843. if (e->isApplicableFor(element)) return 1;
  844. }
  845. return 0;
  846. }
  847. Zeichnung* UIMLView::parseElement(
  848. XML::Element& element, UIMLContainer& generalFactory)
  849. {
  850. Text id;
  851. if (element.hasAttribute("id"))
  852. id = element.getAttributeValue("id");
  853. else
  854. {
  855. id = Text("_") += nextId++;
  856. element.setAttribute("id", id);
  857. }
  858. Zeichnung* z = members->z(id, id.getLength());
  859. if (!z)
  860. {
  861. // precompute attributes
  862. if (element.hasAttribute("margin"))
  863. {
  864. Text m = element.getAttributeValue("margin");
  865. if (!element.hasAttribute("margin-left"))
  866. element.setAttribute("margin-left", m);
  867. if (!element.hasAttribute("margin-top"))
  868. element.setAttribute("margin-top", m);
  869. if (!element.hasAttribute("margin-right"))
  870. element.setAttribute("margin-right", m);
  871. if (!element.hasAttribute("margin-bottom"))
  872. element.setAttribute("margin-bottom", m);
  873. }
  874. if (element.hasAttribute("class"))
  875. {
  876. Text c = element.getAttributeValue("class");
  877. while (1)
  878. {
  879. Text* t;
  880. if (c.hat(","))
  881. t = c.getTeilText(0, c.positionVon(','));
  882. else
  883. t = new Text(c);
  884. XML::Editor ce
  885. = dom->selectChildsByName("class").whereAttributeEquals(
  886. "id", *t);
  887. for (auto i = ce.begin(); i; i++)
  888. {
  889. for (auto j = i->getAttributeNames(),
  890. k = i->getAttributeValues();
  891. j && k;
  892. j++, k++)
  893. {
  894. if (!element.hasAttribute(j->getText()))
  895. element.setAttribute(j->getText(), i->getText());
  896. }
  897. }
  898. t->release();
  899. if (c.hat(","))
  900. c.remove(0, c.positionVon(',' + 1));
  901. else
  902. break;
  903. }
  904. }
  905. if (element.hasAttribute("text-align"))
  906. {
  907. if (!element.hasAttribute("text-align-horizontal"))
  908. element.setAttribute("text-align-horizontal",
  909. element.getAttributeValue("text-align"));
  910. if (!element.hasAttribute("text-align-vertical"))
  911. element.setAttribute("text-align-vertical",
  912. element.getAttributeValue("text-align"));
  913. }
  914. // create objects
  915. for (UIMLElement* e : knownElements)
  916. {
  917. if (e->isApplicableFor(element))
  918. {
  919. z = e->parseElement(element, *this);
  920. break;
  921. }
  922. }
  923. if (z)
  924. members->set(
  925. id, id.getLength(), dynamic_cast<Zeichnung*>(z->getThis()));
  926. }
  927. else
  928. z->getThis();
  929. return z;
  930. }
  931. void UIMLView::layout(XML::Element& element,
  932. Zeichnung& z,
  933. int pWidth,
  934. int pHeight,
  935. UIMLContainer& generalLayouter)
  936. {
  937. for (UIMLElement* e : knownElements)
  938. {
  939. if (e->isApplicableFor(element))
  940. {
  941. e->layout(element, z, pWidth, pHeight, *this);
  942. break;
  943. }
  944. }
  945. }
  946. const UIInit& UIMLView::getFactory()
  947. {
  948. return init;
  949. }
  950. //! calculates the needed size for all content elements to be visible
  951. Punkt UIMLView::calculateContentSize()
  952. {
  953. Punkt maxP(0, 0);
  954. for (int i = dom->getChildCount() - 1; i >= 0; i--)
  955. { // TODO render elements backwards
  956. XML::Element* e = dom->zChild(i);
  957. Zeichnung* z = members->z(
  958. e->getAttributeValue("id"), e->getAttributeValue("id").getLength());
  959. if (z)
  960. {
  961. maxP.x = MAX(maxP.x, z->getPosition().x + z->getBreite());
  962. maxP.y = MAX(maxP.y, z->getPosition().y + z->getHeight());
  963. }
  964. }
  965. maxP.x += 2 * getRahmenBreite();
  966. maxP.y += 2 * getRahmenBreite();
  967. return maxP;
  968. }