Tabelle.cpp 47 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656
  1. #include "Tabelle.h"
  2. #include "AlphaFeld.h"
  3. #include "Bild.h"
  4. #include "MausEreignis.h"
  5. #include "Rahmen.h"
  6. #include "Scroll.h"
  7. #include "TastaturEreignis.h"
  8. #include "Text.h"
  9. #include "ToolTip.h"
  10. using namespace Framework;
  11. // Inhalt der ObjTabelle Klasse aus Tabelle.h
  12. // Konstruktor
  13. ObjTabelle::ObjTabelle()
  14. : ZeichnungHintergrund(),
  15. members(new RCArray<RCArray<Zeichnung>>()),
  16. spaltenNamen(new RCArray<Text>()),
  17. zeilenNamen(new RCArray<Text>()),
  18. spaltenBreite(new Array<int>()),
  19. zeilenHeight(new Array<int>()),
  20. minSpaltenBreite(new Array<int>()),
  21. maxSpaltenBreite(new Array<int>()),
  22. minZeilenHeight(new Array<int>()),
  23. maxZeilenHeight(new Array<int>()),
  24. spaltenAnzahl(0),
  25. zeilenAnzahl(0),
  26. klickSpalte(-1),
  27. klickZeile(-1),
  28. mSpalte(-1),
  29. mZeile(-1),
  30. mx(0),
  31. my(0),
  32. selected(-1, -1),
  33. rasterFarbe(0xFF000000),
  34. rasterBreite(1),
  35. aRam(0),
  36. aAf(0),
  37. msaRam(new RCArray<RCArray<Rahmen>>()),
  38. msaAf(new RCArray<RCArray<AlphaFeld>>()),
  39. styles(new RCArray<Array<__int64>>())
  40. {
  41. style = Style::MEIgnoreInside | Style::MEIgnoreParentInside
  42. | Style::MEIgnoreSichtbar | Style::MEIgnoreVerarbeitet;
  43. }
  44. // Destruktor
  45. ObjTabelle::~ObjTabelle()
  46. {
  47. if (members) members->release();
  48. if (spaltenNamen) spaltenNamen->release();
  49. if (zeilenNamen) zeilenNamen->release();
  50. if (spaltenBreite) spaltenBreite->release();
  51. if (zeilenHeight) zeilenHeight->release();
  52. if (minSpaltenBreite) minSpaltenBreite->release();
  53. if (maxSpaltenBreite) maxSpaltenBreite->release();
  54. if (minZeilenHeight) minZeilenHeight->release();
  55. if (maxZeilenHeight) maxZeilenHeight->release();
  56. if (aRam) aRam->release();
  57. if (aAf) aAf->release();
  58. if (msaRam) msaRam->release();
  59. if (msaAf) msaAf->release();
  60. if (styles) styles->release();
  61. }
  62. void ObjTabelle::doMausEreignis(
  63. MausEreignis& me, bool userRet) // verarbeitet Nachrichten
  64. {
  65. if (!hatStyle(Style::Sichtbar) || !me.insideParent || me.verarbeitet
  66. || me.mx < 0 || me.my < 0 || me.mx >= gr.x || me.my >= gr.y || !userRet)
  67. {
  68. if (me.id == ME_PLinks)
  69. {
  70. klickSpalte = -1;
  71. klickZeile = -1;
  72. }
  73. bool verarbeitet = me.verarbeitet;
  74. me.verarbeitet |= hatStyleNicht(Style::Sichtbar);
  75. bool insideParent = me.insideParent;
  76. me.insideParent = 0;
  77. int rbr = 0;
  78. if (hatStyle(Style::Rahmen) && rahmen) rbr = rahmen->getRBreite();
  79. me.mx -= rbr;
  80. me.my -= rbr;
  81. if (hatStyle(Style::VScroll) && vertikalScrollBar)
  82. me.my += vertikalScrollBar->getScroll();
  83. if (hatStyle(Style::HScroll) && horizontalScrollBar)
  84. me.mx += horizontalScrollBar->getScroll();
  85. if (me.id != ME_Betritt && me.id != ME_Leaves)
  86. {
  87. for (int i = 0; i < zeilenAnzahl; ++i)
  88. {
  89. for (int j = 0; j < spaltenAnzahl; ++j)
  90. {
  91. Zeichnung* obj = zZeichnung(j, i);
  92. if (obj) obj->doPublicMausEreignis(me);
  93. }
  94. }
  95. }
  96. me.mx += rbr;
  97. me.my += rbr;
  98. if (hatStyle(Style::VScroll) && vertikalScrollBar)
  99. me.my -= vertikalScrollBar->getScroll();
  100. if (hatStyle(Style::HScroll) && horizontalScrollBar)
  101. me.mx -= horizontalScrollBar->getScroll();
  102. me.insideParent = insideParent;
  103. if (hatStyleNicht(Style::Sichtbar)) me.verarbeitet = verarbeitet;
  104. return;
  105. }
  106. int tmx = me.mx;
  107. int tmy = me.my;
  108. bool aufScroll = 0;
  109. if (vertikalScrollBar && hatStyle(Style::VScroll)
  110. && me.mx > pos.x + gr.x - 15)
  111. aufScroll = 1;
  112. if (horizontalScrollBar && hatStyle(Style::HScroll)
  113. && me.my > pos.y + gr.y - 15)
  114. aufScroll = 1;
  115. me.mx -= ((horizontalScrollBar && hatStyle(Style::HScroll))
  116. ? horizontalScrollBar->getScroll()
  117. : 0);
  118. me.my -= ((vertikalScrollBar && hatStyle(Style::VScroll))
  119. ? vertikalScrollBar->getScroll()
  120. : 0);
  121. lockZeichnung();
  122. if (!me.verarbeitet && !aufScroll)
  123. {
  124. double ox
  125. = getMausSpalte(me.mx
  126. + ((horizontalScrollBar && hatStyle(Style::HScroll))
  127. ? horizontalScrollBar->getScroll()
  128. : 0));
  129. double oy
  130. = getMausZeile(me.my
  131. + ((vertikalScrollBar && hatStyle(Style::VScroll))
  132. ? vertikalScrollBar->getScroll()
  133. : 0));
  134. if (me.id == ME_RLinks)
  135. {
  136. klickSpalte = -1;
  137. klickZeile = -1;
  138. mSpalte = -1, mZeile = -1;
  139. }
  140. if ((hatStyle(Style::SpaltenBreiteChangeable)
  141. || hatStyle(Style::ZeilenHeightChangeable))
  142. && klickSpalte < 0 && klickZeile < 0)
  143. {
  144. if (hatStyle(Style::SpaltenBreiteChangeable))
  145. {
  146. if (me.id == ME_PLinks && ox != (int)ox)
  147. {
  148. mSpalte = ox;
  149. mx = me.mx;
  150. rend = 1;
  151. }
  152. if (mSpalte > -1)
  153. {
  154. int br = getSpaltenBreite((int)mSpalte) + (me.mx - mx);
  155. if (hatStyle(Style::SpaltenBreiteMax)
  156. && br > getMaxSpaltenBreite((int)mSpalte))
  157. br = getMaxSpaltenBreite((int)mSpalte);
  158. if (hatStyle(Style::SpaltenBreiteMin)
  159. && br < getMinSpaltenBreite((int)mSpalte))
  160. br = getMinSpaltenBreite((int)mSpalte);
  161. setSpaltenBreite((int)mSpalte, br);
  162. mx = me.mx;
  163. rend = 1;
  164. }
  165. }
  166. if (hatStyle(Style::ZeilenHeightChangeable))
  167. {
  168. if (me.id == ME_PLinks && oy != (int)oy)
  169. {
  170. mZeile = oy;
  171. my = me.my;
  172. rend = 1;
  173. }
  174. if (mZeile > -1)
  175. {
  176. int hi = getZeilenHeight((int)mZeile) + (me.my - my);
  177. if (hatStyle(Style::ZeilenHeightMax)
  178. && hi > getMaxZeilenHeight((int)mZeile))
  179. hi = getMaxZeilenHeight((int)mZeile);
  180. if (hatStyle(Style::ZeilenHeightMin)
  181. && hi < getMinZeilenHeight((int)mZeile))
  182. hi = getMinZeilenHeight((int)mZeile);
  183. setZeilenHeight((int)mZeile, hi);
  184. my = me.my;
  185. rend = 1;
  186. }
  187. }
  188. }
  189. if (hatStyle(Style::SpaltenBeweglich) && ox == (int)ox && mSpalte == -1
  190. && mZeile == -1)
  191. {
  192. if (klickSpalte >= 0 && klickSpalte < spaltenAnzahl
  193. && klickSpalte != ox && !oy && ox >= 0)
  194. {
  195. setSpaltePosition(klickSpalte, (int)ox);
  196. klickSpalte = (int)ox;
  197. rend = 1;
  198. }
  199. if (me.id == ME_PLinks)
  200. {
  201. if (!oy && klickSpalte < 0)
  202. {
  203. klickSpalte = (int)ox;
  204. rend = 1;
  205. }
  206. }
  207. }
  208. if (hatStyle(Style::ZeilenBeweglich) && oy == (int)oy && mSpalte == -1
  209. && mZeile == -1)
  210. {
  211. if (klickZeile >= 0 && klickZeile < zeilenAnzahl && klickZeile != oy
  212. && !ox && oy >= 0)
  213. {
  214. setZeilePosition(klickZeile, (int)oy);
  215. klickZeile = (int)oy;
  216. rend = 1;
  217. }
  218. if (me.id == ME_PLinks)
  219. {
  220. if (!ox && klickZeile < 0)
  221. {
  222. klickZeile = (int)oy;
  223. rend = 1;
  224. }
  225. }
  226. }
  227. }
  228. me.mx += (horizontalScrollBar && hatStyle(Style::HScroll))
  229. ? horizontalScrollBar->getScroll()
  230. : 0;
  231. me.my += (vertikalScrollBar && hatStyle(Style::VScroll))
  232. ? vertikalScrollBar->getScroll()
  233. : 0;
  234. bool vs = hatStyle(Style::VScroll) && vertikalScrollBar;
  235. bool hs = hatStyle(Style::HScroll) && horizontalScrollBar;
  236. int rbr = rahmen ? rahmen->getRBreite() : 0;
  237. if (vs)
  238. {
  239. if (hs)
  240. horizontalScrollBar->doMausMessage(
  241. rbr, gr.y - 15 - rbr, gr.x - 15 - rbr * 2, 15, me);
  242. vertikalScrollBar->doMausMessage(
  243. gr.x - 15 - rbr, rbr, 15, gr.y - rbr * 2, me);
  244. }
  245. else if (hs)
  246. horizontalScrollBar->doMausMessage(
  247. rbr, gr.y - 15 - rbr, gr.x - rbr * 2, 15, me);
  248. if (aufScroll) me.verarbeitet = 1;
  249. if (me.id != ME_Betritt && me.id != ME_Leaves)
  250. {
  251. for (int i = 0; i < zeilenAnzahl; ++i)
  252. {
  253. for (int j = 0; j < spaltenAnzahl; ++j)
  254. {
  255. bool b = me.verarbeitet;
  256. Zeichnung* obj = zZeichnung(j, i);
  257. if (obj) obj->doPublicMausEreignis(me);
  258. if (!b && me.verarbeitet && me.id == ME_PLinks)
  259. selected = Punkt(j, i);
  260. }
  261. }
  262. }
  263. unlockZeichnung();
  264. me.verarbeitet = 1;
  265. me.mx = tmx;
  266. me.my = tmy;
  267. }
  268. // nicht constant
  269. void ObjTabelle::addSpalte(const char* name) // Spalte hinzufügen
  270. {
  271. addSpalte(spaltenAnzahl, name);
  272. }
  273. void ObjTabelle::addSpalte(Text* name)
  274. {
  275. addSpalte(spaltenAnzahl, name);
  276. }
  277. void ObjTabelle::addSpalte(
  278. int sNum, const char* name) // Spalte bei sNum einfügen
  279. {
  280. if (sNum > spaltenAnzahl) return;
  281. lockZeichnung();
  282. members->add(new RCArray<Zeichnung>(), sNum);
  283. spaltenNamen->add(new Text(name), sNum);
  284. spaltenBreite->add(100, sNum);
  285. minSpaltenBreite->add(0, sNum);
  286. maxSpaltenBreite->add(300, sNum);
  287. msaRam->add(new RCArray<Rahmen>(), sNum);
  288. msaAf->add(new RCArray<AlphaFeld>(), sNum);
  289. styles->add(new Array<__int64>(), sNum);
  290. ++spaltenAnzahl;
  291. rend = 1;
  292. unlockZeichnung();
  293. }
  294. void ObjTabelle::addSpalte(int sNum, Text* name)
  295. {
  296. addSpalte(sNum, name->getText());
  297. name->release();
  298. }
  299. void ObjTabelle::addZeile(const char* name) // Zeile Hinzufügen
  300. {
  301. addZeile(zeilenAnzahl, name);
  302. }
  303. void ObjTabelle::addZeile(Text* name)
  304. {
  305. addZeile(zeilenAnzahl, name);
  306. }
  307. void ObjTabelle::addZeile(int zNum, const char* name) // Zeile bei zNum einfügen
  308. {
  309. if (zNum > zeilenAnzahl) return;
  310. lockZeichnung();
  311. zeilenNamen->add(new Text(name), zNum);
  312. zeilenHeight->add(20, zNum);
  313. minZeilenHeight->add(0, zNum);
  314. maxZeilenHeight->add(100, zNum);
  315. for (int i = 0; i < spaltenAnzahl; ++i)
  316. {
  317. if (members->z(i)) members->z(i)->add(0, zNum);
  318. if (msaRam->z(i)) msaRam->z(i)->add(0, zNum);
  319. if (msaAf->z(i)) msaAf->z(i)->add(0, zNum);
  320. if (styles->z(i)) styles->z(i)->add(0, zNum);
  321. }
  322. ++zeilenAnzahl;
  323. rend = 1;
  324. unlockZeichnung();
  325. }
  326. void ObjTabelle::addZeile(int zNum, Text* name)
  327. {
  328. addZeile(zNum, name->getText());
  329. name->release();
  330. }
  331. void ObjTabelle::removeSpalte(int sNum) // Spalte löschen
  332. {
  333. if (sNum >= spaltenAnzahl) return;
  334. lockZeichnung();
  335. members->remove(sNum);
  336. spaltenNamen->remove(sNum);
  337. spaltenBreite->remove(sNum);
  338. minSpaltenBreite->remove(sNum);
  339. maxSpaltenBreite->remove(sNum);
  340. if (msaRam->z(sNum)) msaRam->z(sNum)->release();
  341. msaRam->remove(sNum);
  342. if (msaAf->z(sNum)) msaAf->z(sNum)->release();
  343. msaAf->remove(sNum);
  344. styles->remove(sNum);
  345. --spaltenAnzahl;
  346. rend = 1;
  347. unlockZeichnung();
  348. }
  349. void ObjTabelle::removeSpalte(const char* name)
  350. {
  351. removeSpalte(getSpaltenNummer(name));
  352. }
  353. void ObjTabelle::removeSpalte(Text* name)
  354. {
  355. removeSpalte(getSpaltenNummer(name));
  356. }
  357. void ObjTabelle::removeZeile(int zNum) // Zeile löschen
  358. {
  359. if (zNum >= zeilenAnzahl) return;
  360. lockZeichnung();
  361. zeilenNamen->remove(zNum);
  362. zeilenHeight->remove(zNum);
  363. minZeilenHeight->remove(zNum);
  364. maxZeilenHeight->remove(zNum);
  365. for (int i = 0; i < spaltenAnzahl; ++i)
  366. {
  367. if (members->z(i)) members->z(i)->remove(zNum);
  368. if (msaRam->z(i)) msaRam->z(i)->remove(zNum);
  369. if (msaAf->z(i)) msaAf->z(i)->remove(zNum);
  370. if (styles->z(i)) styles->z(i)->remove(zNum);
  371. }
  372. --zeilenAnzahl;
  373. rend = 1;
  374. unlockZeichnung();
  375. }
  376. void ObjTabelle::removeZeile(const char* name)
  377. {
  378. removeZeile(getZeilenNummer(name));
  379. }
  380. void ObjTabelle::removeZeile(Text* name)
  381. {
  382. removeZeile(getZeilenNummer(name));
  383. }
  384. void ObjTabelle::setSpaltePosition(
  385. const char* name, int pos) // setzt die Position einer Spalte
  386. {
  387. setSpaltePosition(getSpaltenNummer(name), pos);
  388. }
  389. void ObjTabelle::setSpaltePosition(Text* name, int pos)
  390. {
  391. setSpaltePosition(getSpaltenNummer(name), pos);
  392. }
  393. void ObjTabelle::setSpaltePosition(int sNum, int pos)
  394. {
  395. if (sNum >= spaltenAnzahl || pos >= spaltenAnzahl || sNum == pos) return;
  396. int delPos = sNum;
  397. int insertPos = pos;
  398. if (pos < sNum)
  399. ++delPos;
  400. else
  401. ++insertPos;
  402. lockZeichnung();
  403. members->add(members->get(sNum), insertPos);
  404. members->remove(delPos);
  405. spaltenNamen->add(spaltenNamen->get(sNum), insertPos);
  406. spaltenNamen->remove(delPos);
  407. spaltenBreite->add(
  408. spaltenBreite->hat(sNum) ? spaltenBreite->get(sNum) : 0, insertPos);
  409. spaltenBreite->remove(delPos);
  410. minSpaltenBreite->add(
  411. minSpaltenBreite->hat(sNum) ? minSpaltenBreite->get(sNum) : 0,
  412. insertPos);
  413. minSpaltenBreite->remove(delPos);
  414. msaRam->add(msaRam->z(sNum), insertPos);
  415. msaRam->remove(delPos);
  416. msaAf->add(msaAf->z(sNum), insertPos);
  417. msaAf->remove(delPos);
  418. styles->add(styles->get(sNum), insertPos);
  419. styles->remove(delPos);
  420. rend = 1;
  421. unlockZeichnung();
  422. }
  423. void ObjTabelle::setZeilePosition(
  424. const char* name, int pos) // setzt die Zeilen Position
  425. {
  426. setZeilePosition(getZeilenNummer(name), pos);
  427. }
  428. void ObjTabelle::setZeilePosition(Text* name, int pos)
  429. {
  430. setZeilePosition(getZeilenNummer(name), pos);
  431. }
  432. void ObjTabelle::setZeilePosition(int zNum, int pos)
  433. {
  434. if (zNum >= zeilenAnzahl || pos >= zeilenAnzahl || pos == zNum) return;
  435. int delPos = zNum;
  436. int insertPos = pos;
  437. if (pos < zNum)
  438. ++delPos;
  439. else
  440. ++insertPos;
  441. lockZeichnung();
  442. zeilenNamen->add(zeilenNamen->get(zNum), insertPos);
  443. zeilenNamen->remove(delPos);
  444. zeilenHeight->add(
  445. zeilenHeight->hat(zNum) ? zeilenHeight->get(zNum) : 0, insertPos);
  446. zeilenHeight->remove(delPos);
  447. minZeilenHeight->add(
  448. minZeilenHeight->hat(zNum) ? minZeilenHeight->get(zNum) : 0, insertPos);
  449. minZeilenHeight->remove(delPos);
  450. maxZeilenHeight->add(
  451. maxZeilenHeight->hat(zNum) ? maxZeilenHeight->get(zNum) : 0, insertPos);
  452. maxZeilenHeight->remove(delPos);
  453. for (int i = 0; i < spaltenAnzahl; ++i)
  454. {
  455. if (members->z(i))
  456. {
  457. members->z(i)->add(
  458. members->z(i)->hat(zNum) ? members->z(i)->get(zNum) : 0,
  459. insertPos);
  460. members->z(i)->remove(delPos);
  461. }
  462. if (msaRam->z(i))
  463. {
  464. msaRam->z(i)->add(
  465. msaRam->z(i)->z(zNum) ? msaRam->z(i)->get(zNum) : 0, insertPos);
  466. msaRam->z(i)->remove(delPos);
  467. }
  468. if (msaAf->z(i))
  469. {
  470. msaAf->z(i)->add(
  471. msaAf->z(i)->z(zNum) ? msaAf->z(i)->get(zNum) : 0, insertPos);
  472. msaAf->z(i)->remove(delPos);
  473. }
  474. if (styles->z(i))
  475. {
  476. styles->z(i)->add(
  477. styles->z(i)->hat(zNum) ? styles->z(i)->get(zNum) : 0,
  478. insertPos);
  479. styles->z(i)->remove(delPos);
  480. }
  481. }
  482. rend = 1;
  483. unlockZeichnung();
  484. }
  485. void ObjTabelle::setZeichnungZ(
  486. int sNum, int zNum, Zeichnung* obj) // setzt ein Zeichnung
  487. {
  488. if (sNum >= spaltenAnzahl || zNum >= zeilenAnzahl) return;
  489. lockZeichnung();
  490. if (!members->z(sNum)) members->set(new RCArray<Zeichnung>(), sNum);
  491. while (members->z(sNum)->getEintragAnzahl() <= zNum)
  492. members->z(sNum)->add(0);
  493. members->z(sNum)->set(obj, zNum);
  494. rend = 1;
  495. unlockZeichnung();
  496. }
  497. void ObjTabelle::setZeichnungZ(
  498. const char* spaltenName, const char* zeilenName, Zeichnung* zZeichnung)
  499. {
  500. setZeichnungZ(
  501. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), zZeichnung);
  502. }
  503. void ObjTabelle::setZeichnungZ(
  504. Text* spaltenName, Text* zeilenName, Zeichnung* zZeichnung)
  505. {
  506. setZeichnungZ(
  507. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), zZeichnung);
  508. }
  509. void ObjTabelle::setSpaltenBreite(int sNum, int br) // setzt die Spaltenbreite
  510. {
  511. if (sNum >= spaltenAnzahl) return;
  512. lockZeichnung();
  513. spaltenBreite->set(br, sNum);
  514. rend = 1;
  515. unlockZeichnung();
  516. }
  517. void ObjTabelle::setSpaltenBreite(const char* name, int br)
  518. {
  519. setSpaltenBreite(getSpaltenNummer(name), br);
  520. }
  521. void ObjTabelle::setSpaltenBreite(Text* name, int br)
  522. {
  523. setSpaltenBreite(getSpaltenNummer(name), br);
  524. }
  525. void ObjTabelle::setZeilenHeight(int zNum, int hi) // setzt die Zeilenhöhe
  526. {
  527. if (zNum >= zeilenAnzahl) return;
  528. lockZeichnung();
  529. zeilenHeight->set(hi, zNum);
  530. rend = 1;
  531. unlockZeichnung();
  532. }
  533. void ObjTabelle::setZeilenHeight(const char* name, int hi)
  534. {
  535. setZeilenHeight(getZeilenNummer(name), hi);
  536. }
  537. void ObjTabelle::setZeilenHeight(Text* name, int hi)
  538. {
  539. setZeilenHeight(getZeilenNummer(name), hi);
  540. }
  541. void ObjTabelle::setMinSpaltenBreite(
  542. int sNum, int minBr) // setzt die mindest Spaltenbreite
  543. {
  544. if (sNum >= spaltenAnzahl) return;
  545. lockZeichnung();
  546. minSpaltenBreite->set(minBr, sNum);
  547. rend = 1;
  548. unlockZeichnung();
  549. }
  550. void ObjTabelle::setMinSpaltenBreite(const char* name, int minBr)
  551. {
  552. setMinSpaltenBreite(getSpaltenNummer(name), minBr);
  553. }
  554. void ObjTabelle::setMinSpaltenBreite(Text* name, int minBr)
  555. {
  556. setMinSpaltenBreite(getSpaltenNummer(name), minBr);
  557. }
  558. void ObjTabelle::setMaxSpaltenBreite(
  559. int sNum, int maxBr) // setzt die maximale Spaltenbreite
  560. {
  561. if (sNum >= spaltenAnzahl) return;
  562. lockZeichnung();
  563. maxSpaltenBreite->set(maxBr, sNum);
  564. rend = 1;
  565. unlockZeichnung();
  566. }
  567. void ObjTabelle::setMaxSpaltenBreite(const char* name, int maxBr)
  568. {
  569. setMaxSpaltenBreite(getSpaltenNummer(name), maxBr);
  570. }
  571. void ObjTabelle::setMaxSpaltenBreite(Text* name, int maxBr)
  572. {
  573. setMaxSpaltenBreite(getSpaltenNummer(name), maxBr);
  574. }
  575. void ObjTabelle::setMinZeilenHeight(
  576. int zNum, int minHi) // setzt die mindest Zeilenhöhe
  577. {
  578. if (zNum >= zeilenAnzahl) return;
  579. lockZeichnung();
  580. minZeilenHeight->set(minHi, zNum);
  581. rend = 1;
  582. unlockZeichnung();
  583. }
  584. void ObjTabelle::setMinZeilenHeight(const char* name, int minHi)
  585. {
  586. setMinZeilenHeight(getZeilenNummer(name), minHi);
  587. }
  588. void ObjTabelle::setMinZeilenHeight(Text* name, int minHi)
  589. {
  590. setMinZeilenHeight(getZeilenNummer(name), minHi);
  591. }
  592. void ObjTabelle::setMaxZeilenHeight(
  593. int zNum, int maxHi) // setzt die maximale Zeilenhöhe
  594. {
  595. if (zNum >= zeilenAnzahl) return;
  596. lockZeichnung();
  597. maxZeilenHeight->set(maxHi, zNum);
  598. rend = 1;
  599. unlockZeichnung();
  600. }
  601. void ObjTabelle::setMaxZeilenHeight(const char* name, int maxHi)
  602. {
  603. setMaxZeilenHeight(getZeilenHeight(name), maxHi);
  604. }
  605. void ObjTabelle::setMaxZeilenHeight(Text* name, int maxHi)
  606. {
  607. setMaxZeilenHeight(getZeilenHeight(name), maxHi);
  608. }
  609. void ObjTabelle::setAuswahl(
  610. int sNum, int zNum) // wählt das entsprechnde Feld aus
  611. {
  612. if (sNum >= spaltenAnzahl || zNum >= zeilenAnzahl) return;
  613. lockZeichnung();
  614. selected.x = sNum;
  615. selected.y = zNum;
  616. rend = 1;
  617. unlockZeichnung();
  618. }
  619. void ObjTabelle::setAuswahl(const char* spaltenName, const char* zeilenName)
  620. {
  621. setAuswahl(getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  622. }
  623. void ObjTabelle::setAuswahl(Text* spaltenName, Text* zeilenName)
  624. {
  625. setAuswahl(getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  626. }
  627. void ObjTabelle::setRasterFarbe(int f) // settzt die Farbe des Rasters
  628. {
  629. rasterFarbe = f;
  630. rend = 1;
  631. }
  632. void ObjTabelle::setRasterBreite(int br) // setzt die Breite des Rasters
  633. {
  634. rasterBreite = br;
  635. rend = 1;
  636. }
  637. void ObjTabelle::setARahmenZ(Rahmen* ram) // setzt den auswahl Rahmen
  638. {
  639. if (aRam) aRam->release();
  640. aRam = ram;
  641. rend = 1;
  642. }
  643. void ObjTabelle::setARFarbe(int f) // setzt die auswahl Rahmen Farbe
  644. {
  645. if (!aRam) aRam = new LRahmen();
  646. aRam->setFarbe(f);
  647. rend = 1;
  648. }
  649. void ObjTabelle::setARBreite(int br) // setzt die auswahl Rahmen Breite
  650. {
  651. if (!aRam) aRam = new LRahmen();
  652. aRam->setRamenBreite(br);
  653. rend = 1;
  654. }
  655. void ObjTabelle::setAAlphaFeldZ(AlphaFeld* af) // setzt das auswahl AlphaFeld
  656. {
  657. if (aAf) aAf->release();
  658. aAf = af;
  659. rend = 1;
  660. }
  661. void ObjTabelle::setAAfFarbe(int f) // setzt die Farbe des auswahl AlphaFeldes
  662. {
  663. if (!aAf) aAf = new AlphaFeld();
  664. aAf->setFarbe(f);
  665. rend = 1;
  666. }
  667. void ObjTabelle::setAAfStrength(
  668. int st) // setzt die Stärke des auswahl AlphaFeldes
  669. {
  670. if (!aAf) aAf = new AlphaFeld();
  671. aAf->setStrength(st);
  672. rend = 1;
  673. }
  674. void ObjTabelle::setARahmenZ(
  675. int sNum, int zNum, Rahmen* ram) // setzt den auswahl Rahmen
  676. {
  677. if (msaRam->z(sNum)) msaRam->z(sNum)->set(ram, zNum);
  678. rend = 1;
  679. }
  680. void ObjTabelle::setARahmenZ(
  681. const char* spaltenName, const char* zeilenName, Rahmen* ram)
  682. {
  683. setARahmenZ(
  684. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), ram);
  685. }
  686. void ObjTabelle::setARahmenZ(Text* spaltenName, Text* zeilenName, Rahmen* ram)
  687. {
  688. setARahmenZ(
  689. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), ram);
  690. }
  691. void ObjTabelle::setARFarbe(
  692. int sNum, int zNum, int f) // setzt die auswahl Rahmen Farbe
  693. {
  694. if (msaRam->z(sNum))
  695. {
  696. Rahmen* tmp = msaRam->z(sNum)->z(zNum);
  697. if (!tmp)
  698. {
  699. tmp = new LRahmen();
  700. msaRam->z(sNum)->set(tmp, zNum);
  701. }
  702. tmp->setFarbe(f);
  703. rend = 1;
  704. }
  705. }
  706. void ObjTabelle::setARFarbe(
  707. const char* spaltenName, const char* zeilenName, int f)
  708. {
  709. setARFarbe(getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), f);
  710. }
  711. void ObjTabelle::setARFarbe(Text* spaltenName, Text* zeilenName, int f)
  712. {
  713. setARFarbe(getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), f);
  714. }
  715. void ObjTabelle::setARBreite(
  716. int sNum, int zNum, int br) // setzt die auswahl Rahmen Breite
  717. {
  718. if (msaRam->z(sNum))
  719. {
  720. Rahmen* tmp = msaRam->z(sNum)->z(zNum);
  721. if (!tmp)
  722. {
  723. tmp = new LRahmen();
  724. msaRam->z(sNum)->set(tmp, zNum);
  725. }
  726. tmp->setRamenBreite(br);
  727. rend = 1;
  728. }
  729. }
  730. void ObjTabelle::setARBreite(
  731. const char* spaltenName, const char* zeilenName, int br)
  732. {
  733. setARBreite(getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), br);
  734. }
  735. void ObjTabelle::setARBreite(Text* spaltenName, Text* zeilenName, int br)
  736. {
  737. setARBreite(getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), br);
  738. }
  739. void ObjTabelle::setAAlphaFeldZ(
  740. int sNum, int zNum, AlphaFeld* af) // setzt das auswahl AlphaFeld
  741. {
  742. if (msaAf->z(sNum)) msaAf->z(sNum)->set(af, zNum);
  743. rend = 1;
  744. }
  745. void ObjTabelle::setAAlphaFeldZ(
  746. const char* spaltenName, const char* zeilenName, AlphaFeld* af)
  747. {
  748. setAAlphaFeldZ(
  749. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), af);
  750. }
  751. void ObjTabelle::setAAlphaFeldZ(
  752. Text* spaltenName, Text* zeilenName, AlphaFeld* af)
  753. {
  754. setAAlphaFeldZ(
  755. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), af);
  756. }
  757. void ObjTabelle::setAAfFarbe(
  758. int sNum, int zNum, int f) // setzt die Farbe des auswahl AlphaFeldes
  759. {
  760. if (msaAf->z(sNum))
  761. {
  762. AlphaFeld* tmp = msaAf->z(sNum)->z(zNum);
  763. if (!tmp)
  764. {
  765. tmp = new AlphaFeld();
  766. msaAf->z(sNum)->set(tmp, zNum);
  767. }
  768. tmp->setFarbe(f);
  769. rend = 1;
  770. }
  771. }
  772. void ObjTabelle::setAAfFarbe(
  773. const char* spaltenName, const char* zeilenName, int f)
  774. {
  775. setAAfFarbe(getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), f);
  776. }
  777. void ObjTabelle::setAAfFarbe(Text* spaltenName, Text* zeilenName, int f)
  778. {
  779. setAAfFarbe(getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), f);
  780. }
  781. void ObjTabelle::setAAfStrength(
  782. int sNum, int zNum, int st) // setzt die Stärke des auswahl AlphaFeldes
  783. {
  784. if (msaAf->z(sNum))
  785. {
  786. AlphaFeld* tmp = msaAf->z(sNum)->z(zNum);
  787. if (!tmp)
  788. {
  789. tmp = new AlphaFeld();
  790. msaAf->z(sNum)->set(tmp, zNum);
  791. }
  792. tmp->setStrength(st);
  793. rend = 1;
  794. }
  795. }
  796. void ObjTabelle::setAAfStrength(
  797. const char* spaltenName, const char* zeilenName, int st)
  798. {
  799. setAAfStrength(
  800. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), st);
  801. }
  802. void ObjTabelle::setAAfStrength(Text* spaltenName, Text* zeilenName, int st)
  803. {
  804. setAAfStrength(
  805. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), st);
  806. }
  807. void ObjTabelle::addMsStyle(
  808. int sNum, int zNum, __int64 style) // setzt den Style wenn Multistyled
  809. {
  810. if (sNum >= spaltenAnzahl || zNum >= zeilenAnzahl) return;
  811. if (styles->z(sNum))
  812. styles->z(sNum)->set(
  813. (styles->z(sNum)->hat(zNum) ? styles->z(sNum)->get(zNum) : 0)
  814. | style,
  815. zNum);
  816. rend = 1;
  817. }
  818. void ObjTabelle::addMsStyle(
  819. const char* spaltenName, const char* zeilenName, __int64 style)
  820. {
  821. addMsStyle(
  822. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), style);
  823. }
  824. void ObjTabelle::addMsStyle(Text* spaltenName, Text* zeilenName, __int64 style)
  825. {
  826. addMsStyle(
  827. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), style);
  828. }
  829. void ObjTabelle::setMsStyle(int sNum, int zNum, __int64 style)
  830. {
  831. if (sNum >= spaltenAnzahl || zNum >= zeilenAnzahl) return;
  832. if (styles->z(sNum)) styles->z(sNum)->set(style, zNum);
  833. rend = 1;
  834. }
  835. void ObjTabelle::setMsStyle(
  836. const char* spaltenName, const char* zeilenName, __int64 style)
  837. {
  838. setMsStyle(
  839. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), style);
  840. }
  841. void ObjTabelle::setMsStyle(Text* spaltenName, Text* zeilenName, __int64 style)
  842. {
  843. setMsStyle(
  844. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), style);
  845. }
  846. void ObjTabelle::setMsStyle(int sNum, int zNum, __int64 style, bool add_remove)
  847. {
  848. if (sNum >= spaltenAnzahl || zNum >= zeilenAnzahl) return;
  849. if (styles->z(sNum))
  850. {
  851. if (add_remove)
  852. styles->z(sNum)->set(
  853. (styles->z(sNum)->hat(zNum) ? styles->z(sNum)->get(zNum) : 0)
  854. | style,
  855. zNum);
  856. else
  857. styles->z(sNum)->set(
  858. (styles->z(sNum)->hat(zNum) ? styles->z(sNum)->get(zNum) : 0)
  859. & (~style),
  860. zNum);
  861. rend = 1;
  862. }
  863. }
  864. void ObjTabelle::setMsStyle(const char* spaltenName,
  865. const char* zeilenName,
  866. __int64 style,
  867. bool add_remove)
  868. {
  869. setMsStyle(getSpaltenNummer(spaltenName),
  870. getZeilenNummer(zeilenName),
  871. style,
  872. add_remove);
  873. }
  874. void ObjTabelle::setMsStyle(
  875. Text* spaltenName, Text* zeilenName, __int64 style, bool add_remove)
  876. {
  877. setMsStyle(getSpaltenNummer(spaltenName),
  878. getZeilenNummer(zeilenName),
  879. style,
  880. add_remove);
  881. }
  882. void ObjTabelle::removeMsStyle(int sNum, int zNum, __int64 style)
  883. {
  884. if (sNum >= spaltenAnzahl || zNum >= zeilenAnzahl) return;
  885. if (styles->z(sNum))
  886. styles->z(sNum)->set(
  887. (styles->z(sNum)->hat(zNum) ? styles->z(sNum)->get(zNum) : 0)
  888. & (~style),
  889. zNum);
  890. rend = 1;
  891. }
  892. void ObjTabelle::removeMsStyle(
  893. const char* spaltenName, const char* zeilenName, __int64 style)
  894. {
  895. removeMsStyle(
  896. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), style);
  897. }
  898. void ObjTabelle::removeMsStyle(
  899. Text* spaltenName, Text* zeilenName, __int64 style)
  900. {
  901. removeMsStyle(
  902. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), style);
  903. }
  904. bool ObjTabelle::tick(double tickVal) // tick Message
  905. {
  906. lockZeichnung();
  907. for (int i = 0; i < zeilenAnzahl; ++i)
  908. {
  909. for (int j = 0; j < spaltenAnzahl; ++j)
  910. {
  911. Zeichnung* obj = zZeichnung(j, i);
  912. if (obj) rend |= obj->tick(tickVal);
  913. }
  914. }
  915. unlockZeichnung();
  916. return ZeichnungHintergrund::tick(tickVal);
  917. }
  918. void ObjTabelle::doTastaturEreignis(TastaturEreignis& te)
  919. {
  920. bool ntakc = !te.verarbeitet;
  921. if (hatStyleNicht(Style::Fokus) || hatStyleNicht(Style::Erlaubt)
  922. || hatStyleNicht(Style::Sichtbar))
  923. return;
  924. if (tak && (te.verarbeitet || tak(takParam, this, te)))
  925. {
  926. lockZeichnung();
  927. if (zZeichnung(selected.x, selected.y))
  928. {
  929. zZeichnung(selected.x, selected.y)->doTastaturEreignis(te);
  930. if (!te.verarbeitet && te.id == TE_Press)
  931. {
  932. if (te.virtualKey == T_Oben)
  933. {
  934. --(selected.y);
  935. rend = 1;
  936. }
  937. if (te.virtualKey == T_Unten)
  938. {
  939. ++(selected.y);
  940. rend = 1;
  941. }
  942. if (te.virtualKey == T_Links)
  943. {
  944. --(selected.x);
  945. rend = 1;
  946. }
  947. if (te.virtualKey == T_Rechts)
  948. {
  949. ++(selected.x);
  950. rend = 1;
  951. }
  952. }
  953. }
  954. unlockZeichnung();
  955. }
  956. te.verarbeitet = 1;
  957. if (ntakc && te.verarbeitet && nTak)
  958. te.verarbeitet = nTak(ntakParam, this, te);
  959. }
  960. void ObjTabelle::render(Bild& zRObj) // zeichnet nach zRObj
  961. {
  962. if (hatStyleNicht(Style::Sichtbar)) return;
  963. ZeichnungHintergrund::render(zRObj);
  964. lockZeichnung();
  965. if (!zRObj.setDrawOptions(innenPosition, innenSize))
  966. {
  967. unlockZeichnung();
  968. return;
  969. }
  970. int xPos = 0;
  971. if (horizontalScrollBar && hatStyle(Style::HScroll))
  972. xPos -= horizontalScrollBar->getScroll();
  973. for (int s = 0; s < spaltenAnzahl; ++s)
  974. {
  975. int sBr = spaltenBreite->hat(s) ? spaltenBreite->get(s) : 0;
  976. int yPos = 0;
  977. if (vertikalScrollBar && hatStyle(Style::VScroll))
  978. yPos -= vertikalScrollBar->getScroll();
  979. RCArray<Zeichnung>* tmp_zZeichnungs = members->z(s);
  980. if (!tmp_zZeichnungs) continue;
  981. for (int z = 0; z < zeilenAnzahl && tmp_zZeichnungs; ++z)
  982. {
  983. int zHi = zeilenHeight->hat(z) ? zeilenHeight->get(z) : 0;
  984. if (hatStyle(Style::Raster)) yPos += rasterBreite;
  985. yPos += zHi;
  986. if (z == zeilenAnzahl - 1 && vertikalScrollBar
  987. && hatStyle(Style::VScroll))
  988. vertikalScrollBar->getScrollData()->max
  989. = yPos + vertikalScrollBar->getScroll();
  990. }
  991. for (int z = zeilenAnzahl - 1; z >= 0 && tmp_zZeichnungs; z--)
  992. {
  993. int zHi = zeilenHeight->hat(z) ? zeilenHeight->get(z) : 0;
  994. yPos -= zHi;
  995. if (hatStyle(Style::Raster))
  996. {
  997. yPos -= rasterBreite;
  998. for (int i = 0; i < rasterBreite; i++)
  999. zRObj.drawLinieHAlpha(
  1000. xPos, yPos + zHi + i, sBr, rasterFarbe);
  1001. }
  1002. Zeichnung* obj
  1003. = tmp_zZeichnungs->hat(z) ? tmp_zZeichnungs->z(z) : 0;
  1004. if (obj)
  1005. {
  1006. obj->setPosition(xPos, yPos);
  1007. obj->setSize(sBr, zHi);
  1008. obj->render(zRObj);
  1009. if (selected.x == s && selected.y == z)
  1010. {
  1011. Rahmen* tmp_aRam = aRam;
  1012. AlphaFeld* tmp_aAf = aAf;
  1013. bool aRamB = hatStyle(Style::AuswahlRahmen) && tmp_aRam;
  1014. bool aAfB = hatStyle(Style::AuswahlBuffer) && tmp_aAf;
  1015. if (hatStyle(Style::AuswahlMultistyled))
  1016. {
  1017. tmp_aRam = getARahmen(s, z);
  1018. tmp_aAf = getAAlphaFeld(s, z);
  1019. aRamB = hatMsStyle(s, z, Style::AuswahlRahmen)
  1020. && tmp_aRam;
  1021. aAfB
  1022. = hatMsStyle(s, z, Style::AuswahlBuffer) && tmp_aAf;
  1023. }
  1024. int aRbr = 0;
  1025. if (aRamB)
  1026. {
  1027. tmp_aRam->setPosition(xPos, yPos);
  1028. tmp_aRam->setSize(sBr, zHi);
  1029. tmp_aRam->render(zRObj);
  1030. aRbr = tmp_aRam->getRBreite();
  1031. }
  1032. if (aAfB)
  1033. {
  1034. tmp_aAf->setPosition(aRbr + xPos, aRbr + yPos);
  1035. tmp_aAf->setSize(sBr - aRbr * 2, zHi - aRbr * 2);
  1036. tmp_aAf->render(zRObj);
  1037. }
  1038. }
  1039. }
  1040. }
  1041. if (hatStyle(Style::Raster))
  1042. {
  1043. for (int i = 0; i < rasterBreite; i++)
  1044. zRObj.drawLinieVAlpha(
  1045. xPos + sBr + i, 0, innenSize.y, rasterFarbe);
  1046. xPos += rasterBreite;
  1047. }
  1048. xPos += sBr;
  1049. }
  1050. if (horizontalScrollBar && hatStyle(Style::HScroll))
  1051. horizontalScrollBar->getScrollData()->max
  1052. = xPos + horizontalScrollBar->getScroll();
  1053. zRObj.releaseDrawOptions();
  1054. unlockZeichnung();
  1055. }
  1056. // constant
  1057. int ObjTabelle::getSpaltenAnzahl() const // gibt die Anzahl der Spalten zurück
  1058. {
  1059. return spaltenAnzahl;
  1060. }
  1061. int ObjTabelle::getZeilenAnzahl() const // gibt die Anzahl der Zeilen zurück
  1062. {
  1063. return zeilenAnzahl;
  1064. }
  1065. int ObjTabelle::getSpaltenNummer(const char* name)
  1066. const // gibt die Nummer der Spalte mit dem Namen name zurück
  1067. {
  1068. for (int i = 0; i < spaltenAnzahl; ++i)
  1069. {
  1070. if (spaltenNamen->z(i)->istGleich(name)) return i;
  1071. }
  1072. return -1;
  1073. }
  1074. int ObjTabelle::getSpaltenNummer(Text* name) const
  1075. {
  1076. int ret = getSpaltenNummer(name->getText());
  1077. name->release();
  1078. return ret;
  1079. }
  1080. Text* ObjTabelle::getSpaltenName(
  1081. int num) const // gibt den Namen der Spalte mit Nummer num zurück
  1082. {
  1083. return spaltenNamen->get(num);
  1084. }
  1085. Text* ObjTabelle::zSpaltenName(int num) const
  1086. {
  1087. return spaltenNamen->z(num);
  1088. }
  1089. int ObjTabelle::getZeilenNummer(const char* name)
  1090. const // gibt die Nummer der Zeile mit dem Namen name zurück
  1091. {
  1092. for (int i = 0; i < zeilenAnzahl; ++i)
  1093. {
  1094. if (zeilenNamen->z(i)->istGleich(name)) return i;
  1095. }
  1096. return -1;
  1097. }
  1098. int ObjTabelle::getZeilenNummer(Text* name) const
  1099. {
  1100. int ret = getZeilenNummer(name->getText());
  1101. name->release();
  1102. return ret;
  1103. }
  1104. Text* ObjTabelle::getZeilenName(
  1105. int num) const // gibt den Namen der Zeile mit Nummer num zurück
  1106. {
  1107. return zeilenNamen->get(num);
  1108. }
  1109. Text* ObjTabelle::zZeilenName(int num) const
  1110. {
  1111. return zeilenNamen->z(num);
  1112. }
  1113. Punkt ObjTabelle::getZeichnungPosition(
  1114. Zeichnung* zObj) const // gibt die Position eines Zeichnungs zurück
  1115. {
  1116. for (int x = 0; x < spaltenAnzahl; ++x)
  1117. {
  1118. for (int y = 0; y < zeilenAnzahl; ++y)
  1119. {
  1120. if (zZeichnung(x, y) == zObj) return Punkt(x, y);
  1121. }
  1122. }
  1123. return Punkt(-1, -1);
  1124. }
  1125. Zeichnung* ObjTabelle::zZeichnung(
  1126. int sNum, int zNum) const // gibt das Zeichnung auf der Position zurück
  1127. {
  1128. if (!members->z(sNum)) return 0;
  1129. RCArray<Zeichnung>* tmp = members->z(sNum);
  1130. if (!tmp->hat(zNum)) return 0;
  1131. return tmp ? tmp->z(zNum) : 0;
  1132. }
  1133. Zeichnung* ObjTabelle::zZeichnung(
  1134. const char* spaltenName, const char* zeilenName) const
  1135. {
  1136. return zZeichnung(
  1137. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1138. }
  1139. Zeichnung* ObjTabelle::zZeichnung(Text* spaltenName, Text* zeilenName) const
  1140. {
  1141. return zZeichnung(
  1142. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1143. }
  1144. Zeichnung* ObjTabelle::getZeichnung(
  1145. int sNum, int zNum) const // gibt das Zeichnung auf der Position zurück
  1146. {
  1147. if (!members->z(sNum)) return 0;
  1148. RCArray<Zeichnung>* tmp = members->z(sNum);
  1149. if (!tmp->hat(zNum)) return 0;
  1150. return tmp ? tmp->get(zNum) : 0;
  1151. }
  1152. Zeichnung* ObjTabelle::getZeichnung(
  1153. const char* spaltenName, const char* zeilenName) const
  1154. {
  1155. return getZeichnung(
  1156. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1157. }
  1158. Zeichnung* ObjTabelle::getZeichnung(Text* spaltenName, Text* zeilenName) const
  1159. {
  1160. return getZeichnung(
  1161. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1162. }
  1163. int ObjTabelle::getSpaltenBreite(
  1164. int num) const // gibt die Breite der Spalte zurück
  1165. {
  1166. return spaltenBreite->get(num);
  1167. }
  1168. int ObjTabelle::getSpaltenBreite(const char* name) const
  1169. {
  1170. return getSpaltenBreite(getSpaltenNummer(name));
  1171. }
  1172. int ObjTabelle::getSpaltenBreite(Text* name) const
  1173. {
  1174. return getSpaltenBreite(getSpaltenNummer(name));
  1175. }
  1176. int ObjTabelle::getZeilenHeight(int num) const // gibt die Höhe der Zeile zurück
  1177. {
  1178. return zeilenHeight->get(num);
  1179. }
  1180. int ObjTabelle::getZeilenHeight(const char* name) const
  1181. {
  1182. return getZeilenHeight(getZeilenNummer(name));
  1183. }
  1184. int ObjTabelle::getZeilenHeight(Text* name) const
  1185. {
  1186. return getZeilenHeight(getZeilenNummer(name));
  1187. }
  1188. int ObjTabelle::getMinSpaltenBreite(
  1189. int num) const // gibt die minimale Spaltengröße zurück
  1190. {
  1191. return minSpaltenBreite->get(num);
  1192. }
  1193. int ObjTabelle::getMinSpaltenBreite(const char* name) const
  1194. {
  1195. return getMinSpaltenBreite(getSpaltenNummer(name));
  1196. }
  1197. int ObjTabelle::getMinSpaltenBreite(Text* name) const
  1198. {
  1199. return getMinSpaltenBreite(getSpaltenNummer(name));
  1200. }
  1201. int ObjTabelle::getMaxSpaltenBreite(
  1202. int num) const // gibt die maximale Spaltengröße zurück
  1203. {
  1204. return maxSpaltenBreite->get(num);
  1205. }
  1206. int ObjTabelle::getMaxSpaltenBreite(const char* name) const
  1207. {
  1208. return getMaxSpaltenBreite(getSpaltenNummer(name));
  1209. }
  1210. int ObjTabelle::getMaxSpaltenBreite(Text* name) const
  1211. {
  1212. return getMaxSpaltenBreite(getSpaltenNummer(name));
  1213. }
  1214. int ObjTabelle::getMinZeilenHeight(
  1215. int num) const // gibt die minimale Zeilenhöhe zurück
  1216. {
  1217. return minZeilenHeight->get(num);
  1218. }
  1219. int ObjTabelle::getMinZeilenHeight(const char* name) const
  1220. {
  1221. return getMinZeilenHeight(getZeilenNummer(name));
  1222. }
  1223. int ObjTabelle::getMinZeilenHeight(Text* name) const
  1224. {
  1225. return getMinZeilenHeight(getZeilenNummer(name));
  1226. }
  1227. int ObjTabelle::getMaxZeilenHeight(
  1228. int num) const // gibt die maximale Zeilenhöhe zurück
  1229. {
  1230. return maxZeilenHeight->get(num);
  1231. }
  1232. int ObjTabelle::getMaxZeilenHeight(const char* name) const
  1233. {
  1234. return getMaxZeilenHeight(getZeilenNummer(name));
  1235. }
  1236. int ObjTabelle::getMaxZeilenHeight(Text* name) const
  1237. {
  1238. return getMaxZeilenHeight(getZeilenNummer(name));
  1239. }
  1240. double ObjTabelle::getMausSpalte(
  1241. int mx) const // ermittelt die Spalte unter der Maus
  1242. {
  1243. if (mx >= gr.x) return -1;
  1244. int hsBeg = (horizontalScrollBar && hatStyle(Style::HScroll))
  1245. ? horizontalScrollBar->getScroll()
  1246. : 0;
  1247. mx += hsBeg;
  1248. if (mx < 0) return -1;
  1249. int xx = rahmen ? rahmen->getRBreite() : 0;
  1250. for (int i = 0; i < spaltenAnzahl; ++i)
  1251. {
  1252. xx += spaltenBreite->get(i);
  1253. if (mx < xx - 5) return i;
  1254. if (mx < xx + 5) return i + 0.5;
  1255. xx += rasterBreite;
  1256. }
  1257. return -1;
  1258. }
  1259. Text* ObjTabelle::getMausSpaltenName(int mx) const
  1260. {
  1261. double tmp = getMausSpalte(mx);
  1262. if (tmp != (int)tmp) return 0;
  1263. return getSpaltenName((int)tmp);
  1264. }
  1265. Text* ObjTabelle::zMausSpaltenName(int mx) const
  1266. {
  1267. double tmp = getMausSpalte(mx);
  1268. if (tmp != (int)tmp) return 0;
  1269. return zSpaltenName((int)tmp);
  1270. }
  1271. double ObjTabelle::getMausZeile(
  1272. int my) const // ermittelt die Zeile unter der Maus
  1273. {
  1274. if (my >= gr.y) return -1;
  1275. if (my < 0) return -1;
  1276. int vsBeg = vertikalScrollBar && hatStyle(Style::VScroll)
  1277. ? vertikalScrollBar->getScroll()
  1278. : 0;
  1279. my += vsBeg;
  1280. int yy = rahmen ? rahmen->getRBreite() : 0;
  1281. for (int i = 0; i < zeilenAnzahl; ++i)
  1282. {
  1283. yy += zeilenHeight->get(i);
  1284. if (my < yy - 5) return i;
  1285. if (my < yy + 5) return i + 0.5;
  1286. yy += rasterBreite;
  1287. }
  1288. return -1;
  1289. }
  1290. Text* ObjTabelle::getMausZeilenName(int my) const
  1291. {
  1292. double tmp = getMausZeile(my);
  1293. if (tmp != (int)tmp) return 0;
  1294. return getZeilenName((int)tmp);
  1295. }
  1296. Text* ObjTabelle::zMausZeilenName(int my) const
  1297. {
  1298. double tmp = getMausZeile(my);
  1299. if (tmp != (int)tmp) return 0;
  1300. return zZeilenName((int)tmp);
  1301. }
  1302. const Punkt&
  1303. ObjTabelle::getAuswahlPosition() const // gibt die Auswahl Position zurück
  1304. {
  1305. return selected;
  1306. }
  1307. int ObjTabelle::getRasterFarbe() const // gibt die Farbe des Rasters zurück
  1308. {
  1309. return rasterFarbe;
  1310. }
  1311. int ObjTabelle::getRasterBreite() const // gibt die Breite des Rasters zurück
  1312. {
  1313. return rasterBreite;
  1314. }
  1315. Rahmen* ObjTabelle::getARahmen() const // gibt den auswahl Rahmen zurück
  1316. {
  1317. return aRam ? dynamic_cast<Rahmen*>(aRam->getThis()) : 0;
  1318. }
  1319. Rahmen* ObjTabelle::zARahmen() const
  1320. {
  1321. return aRam;
  1322. }
  1323. AlphaFeld*
  1324. ObjTabelle::getAAlphaFeld() const // gibt das auswahl AlphaFeld zurück
  1325. {
  1326. return aAf ? dynamic_cast<AlphaFeld*>(aAf->getThis()) : 0;
  1327. }
  1328. AlphaFeld* ObjTabelle::zAAlphaFeld() const
  1329. {
  1330. return aAf;
  1331. }
  1332. Rahmen* ObjTabelle::getARahmen(
  1333. int sNum, int zNum) const // gibt den auswahl Rahmen zurück
  1334. {
  1335. RCArray<Rahmen>* tmp = msaRam->z(sNum);
  1336. return tmp ? tmp->get(zNum) : 0;
  1337. }
  1338. Rahmen* ObjTabelle::zARahmen(int sNum, int zNum) const
  1339. {
  1340. RCArray<Rahmen>* tmp = msaRam->z(sNum);
  1341. return tmp ? tmp->z(zNum) : 0;
  1342. }
  1343. AlphaFeld* ObjTabelle::getAAlphaFeld(
  1344. int sNum, int zNum) const // gibt das auswahl AlphaFeld zurück
  1345. {
  1346. RCArray<AlphaFeld>* tmp = msaAf->z(sNum);
  1347. return tmp ? tmp->get(zNum) : 0;
  1348. }
  1349. AlphaFeld* ObjTabelle::zAAlphaFeld(int sNum, int zNum) const
  1350. {
  1351. return msaAf->z(sNum) ? msaAf->z(sNum)->z(zNum) : 0;
  1352. }
  1353. Rahmen* ObjTabelle::getARahmen(const char* spaltenName,
  1354. const char* zeilenName) const // gibt den auswahl Rahmen zurück
  1355. {
  1356. return getARahmen(
  1357. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1358. }
  1359. Rahmen* ObjTabelle::zARahmen(
  1360. const char* spaltenName, const char* zeilenName) const
  1361. {
  1362. return zARahmen(getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1363. }
  1364. AlphaFeld* ObjTabelle::getAAlphaFeld(const char* spaltenName,
  1365. const char* zeilenName) const // gibt das auswahl AlphaFeld zurück
  1366. {
  1367. return getAAlphaFeld(
  1368. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1369. }
  1370. AlphaFeld* ObjTabelle::zAAlphaFeld(
  1371. const char* spaltenName, const char* zeilenName) const
  1372. {
  1373. return zAAlphaFeld(
  1374. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1375. }
  1376. Rahmen* ObjTabelle::getARahmen(
  1377. Text* spaltenName, Text* zeilenName) const // gibt den auswahl Rahmen zurück
  1378. {
  1379. return getARahmen(
  1380. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1381. }
  1382. Rahmen* ObjTabelle::zARahmen(Text* spaltenName, Text* zeilenName) const
  1383. {
  1384. return zARahmen(getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1385. }
  1386. AlphaFeld* ObjTabelle::getAAlphaFeld(Text* spaltenName,
  1387. Text* zeilenName) const // gibt das auswahl AlphaFeld zurück
  1388. {
  1389. return getAAlphaFeld(
  1390. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1391. }
  1392. AlphaFeld* ObjTabelle::zAAlphaFeld(Text* spaltenName, Text* zeilenName) const
  1393. {
  1394. return zAAlphaFeld(
  1395. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName));
  1396. }
  1397. bool ObjTabelle::hatMsStyle(
  1398. int sNum, int zNum, __int64 style) const // prüft, ob style vorhanden ist
  1399. {
  1400. __int64 s = styles->z(sNum) && styles->z(sNum)->hat(zNum)
  1401. ? styles->z(sNum)->get(zNum)
  1402. : 0;
  1403. return (s | style) == s;
  1404. }
  1405. bool ObjTabelle::hatMsStyleNicht(int sNum,
  1406. int zNum,
  1407. __int64 style) const // prüft, ob style nicht vorhanden ist
  1408. {
  1409. __int64 s = styles->z(sNum) && styles->z(sNum)->hat(zNum)
  1410. ? styles->z(sNum)->get(zNum)
  1411. : 0;
  1412. return (s | style) != s;
  1413. }
  1414. bool ObjTabelle::hatMsStyle(const char* spaltenName,
  1415. const char* zeilenName,
  1416. __int64 style) const // prüft, ob style vorhanden ist
  1417. {
  1418. return hatMsStyle(
  1419. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), style);
  1420. }
  1421. bool ObjTabelle::hatMsStyleNicht(const char* spaltenName,
  1422. const char* zeilenName,
  1423. __int64 style) const // prüft, ob style nicht vorhanden ist
  1424. {
  1425. return hatMsStyleNicht(
  1426. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), style);
  1427. }
  1428. bool ObjTabelle::hatMsStyle(Text* spaltenName,
  1429. Text* zeilenName,
  1430. __int64 style) const // prüft, ob style vorhanden ist
  1431. {
  1432. return hatMsStyle(
  1433. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), style);
  1434. }
  1435. bool ObjTabelle::hatMsStyleNicht(Text* spaltenName,
  1436. Text* zeilenName,
  1437. __int64 style) const // prüft, ob style nicht vorhanden ist
  1438. {
  1439. return hatMsStyleNicht(
  1440. getSpaltenNummer(spaltenName), getZeilenNummer(zeilenName), style);
  1441. }
  1442. Zeichnung* ObjTabelle::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
  1443. {
  1444. ObjTabelle* obj = new ObjTabelle();
  1445. obj->setPosition(pos);
  1446. obj->setSize(gr);
  1447. obj->setMausEreignisParameter(makParam);
  1448. obj->setTastaturEreignisParameter(takParam);
  1449. obj->setMausEreignis(mak);
  1450. obj->setTastaturEreignis(tak);
  1451. if (toolTip) obj->setToolTipZ((ToolTip*)toolTip->dublizieren());
  1452. obj->setStyle(style);
  1453. if (rahmen) obj->setRahmenZ((Rahmen*)rahmen->dublizieren());
  1454. obj->setHintergrundFarbe(hintergrundFarbe);
  1455. if (hintergrundBild)
  1456. obj->setHintergrundBild(
  1457. dynamic_cast<Bild*>(hintergrundBild->getThis()));
  1458. if (hintergrundFeld)
  1459. obj->setAlphaFeldZ((AlphaFeld*)hintergrundFeld->dublizieren());
  1460. obj->setRasterFarbe(rasterFarbe);
  1461. obj->setRasterBreite(rasterBreite);
  1462. if (aRam) obj->setARahmenZ((Rahmen*)aRam->dublizieren());
  1463. if (aAf) obj->setAAlphaFeldZ((AlphaFeld*)aAf->dublizieren());
  1464. for (int s = 0; s < spaltenAnzahl; ++s)
  1465. {
  1466. obj->addSpalte(spaltenNamen->get(s));
  1467. if (spaltenBreite->hat(s))
  1468. obj->setSpaltenBreite(s, spaltenBreite->get(s));
  1469. if (minSpaltenBreite->hat(s))
  1470. obj->setMinSpaltenBreite(s, minSpaltenBreite->get(s));
  1471. if (maxSpaltenBreite->hat(s))
  1472. obj->setMaxSpaltenBreite(s, maxSpaltenBreite->get(s));
  1473. for (int z = 0; z < zeilenAnzahl; ++z)
  1474. {
  1475. if (!s)
  1476. {
  1477. obj->addZeile(zeilenNamen->get(z));
  1478. if (zeilenHeight->hat(z))
  1479. obj->setZeilenHeight(z, zeilenHeight->get(z));
  1480. if (minZeilenHeight->hat(z))
  1481. obj->setMinZeilenHeight(z, minZeilenHeight->get(z));
  1482. if (maxZeilenHeight->hat(z))
  1483. obj->setMaxZeilenHeight(z, maxZeilenHeight->get(z));
  1484. }
  1485. if (members->z(s) && members->z(s)->hat(z))
  1486. obj->setZeichnungZ(s, z, members->z(s)->get(z));
  1487. if (styles->z(s) && styles->z(s)->hat(z))
  1488. obj->setMsStyle(s, z, styles->z(s)->get(z));
  1489. if (msaRam->z(s) && msaRam->z(s)->z(z))
  1490. obj->setARahmenZ(
  1491. s, z, (Rahmen*)msaRam->z(s)->z(z)->dublizieren());
  1492. if (msaAf->z(s) && msaAf->z(s)->z(z))
  1493. obj->setAAlphaFeldZ(
  1494. s, z, (AlphaFeld*)msaAf->z(s)->z(z)->dublizieren());
  1495. }
  1496. }
  1497. obj->setAuswahl(selected.x, selected.y);
  1498. return obj;
  1499. }