Diagramm.cpp 60 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953
  1. #include "Diagramm.h"
  2. #include <math.h>
  3. #include "AlphaFeld.h"
  4. #include "Bild.h"
  5. #include "MausEreignis.h"
  6. #include "Rahmen.h"
  7. #include "Schrift.h"
  8. #include "Scroll.h"
  9. #include "Text.h"
  10. #include "ToolTip.h"
  11. using namespace Framework;
  12. // Inhalt der SLDiag Klasse aus Diagramm.h
  13. // Konstruktor
  14. SLDiag::SLDiag()
  15. : ZeichnungHintergrund(),
  16. gF(0xFF000000),
  17. lFarbe(new Array<int>()),
  18. lName(new RCArray<Text>()),
  19. ph(new RCArray<Array<int>>()),
  20. pb(new RCArray<Array<int>>()),
  21. lastValue(new Array<int>()),
  22. textRd(0),
  23. gitterGr(0, 0),
  24. lines(0)
  25. {
  26. style = 0;
  27. }
  28. // Destruktor
  29. SLDiag::~SLDiag()
  30. {
  31. lFarbe->release();
  32. lName->release();
  33. ph->release();
  34. pb->release();
  35. lastValue->release();
  36. if (textRd) textRd->release();
  37. }
  38. // nicht constant
  39. void SLDiag::setTextRendererZ(TextRenderer* textRd)
  40. {
  41. if (this->textRd) this->textRd->release();
  42. this->textRd = textRd;
  43. }
  44. void SLDiag::setSchriftZ(Schrift* schrift) // setzt die Schrift
  45. {
  46. if (!this->textRd)
  47. textRd = new TextRenderer(schrift);
  48. else
  49. textRd->setSchriftZ(schrift);
  50. rend = 1;
  51. }
  52. void SLDiag::setGSize(Punkt& gr) // setzt die Größe des Gitters
  53. {
  54. gitterGr = gr;
  55. rend = 1;
  56. }
  57. void SLDiag::setGFarbe(int f) // setzt die Gitter Farbe
  58. {
  59. gF = f;
  60. rend = 1;
  61. }
  62. void SLDiag::addLinie(const char* name) // fügt eine Linie hinzu
  63. {
  64. addLinie(new Text(name));
  65. rend = 1;
  66. }
  67. void SLDiag::addLinie(Text* txt)
  68. {
  69. lFarbe->add(0xFFFFFFFF, lines);
  70. lName->add(txt, lines);
  71. ph->add(new Array<int>(), lines);
  72. pb->add(new Array<int>(), lines);
  73. int rbr = rahmen && hatStyle(Style::Rahmen) ? rahmen->getRBreite() : 0;
  74. pb->z(lines)->set(gr.x - rbr * 2, 0);
  75. ++lines;
  76. rend = 1;
  77. }
  78. void SLDiag::setLFarbe(int lNum, int f) // setzt die Linienfarbe
  79. {
  80. lFarbe->set(f, lNum);
  81. rend = 1;
  82. }
  83. void SLDiag::addPunkt(int lNum, int x, int h) // fügt einen Punkt hinzu
  84. {
  85. Array<int>* ph_tmp = ph->z(lNum);
  86. Array<int>* pb_tmp = pb->z(lNum);
  87. if (ph_tmp && pb_tmp)
  88. {
  89. int i = pb_tmp->get(0);
  90. i -= x;
  91. if (i >= 0) pb_tmp->set(i, 0);
  92. while (i < 0)
  93. {
  94. ph_tmp->remove(0);
  95. pb_tmp->remove(0);
  96. if (!pb_tmp->getEintragAnzahl() || !ph_tmp->getEintragAnzahl())
  97. break;
  98. int ii = -i;
  99. i = pb_tmp->get(0);
  100. i -= ii;
  101. pb_tmp->set(i, 0);
  102. }
  103. pb_tmp->add(x);
  104. ph_tmp->add(h);
  105. lastValue->set(h, lNum);
  106. }
  107. rend = 1;
  108. }
  109. void SLDiag::removeLinie(int lNum) // entfernt eine Linie
  110. {
  111. lFarbe->remove(lNum);
  112. lName->remove(lNum);
  113. ph->remove(lNum);
  114. pb->remove(lNum);
  115. --lines;
  116. rend = 1;
  117. }
  118. void SLDiag::render(Bild& zRObj) // zeichnet nach zRObj
  119. {
  120. if (hatStyle(Style::Sichtbar))
  121. {
  122. lockZeichnung();
  123. removeStyle(Style::VScroll | Style::HScroll);
  124. ZeichnungHintergrund::render(zRObj);
  125. if (!zRObj.setDrawOptions(innenPosition, innenSize))
  126. {
  127. unlockZeichnung();
  128. return;
  129. }
  130. int hv = getHighestValue();
  131. hv = hv ? hv : 1;
  132. double yFaktor = innenSize.y / hv;
  133. if (hatStyle(Style::Gitter))
  134. {
  135. double ghi = gitterGr.y * yFaktor;
  136. int yo = innenSize.y - 1;
  137. int bo = innenSize.x, ho = innenSize.y;
  138. int maxBr = (int)((double)innenSize.x / gitterGr.x + 0.5);
  139. int maxHi = ghi ? (int)(innenSize.y / ghi + 0.5) : 0;
  140. if (hatStyle(Style::HAlpha))
  141. {
  142. for (int i = 0; i < maxBr; ++i)
  143. zRObj.drawLinieVAlpha(gitterGr.x * i, 0, ho, gF);
  144. for (int i = 0; i < maxHi; ++i)
  145. zRObj.drawLinieHAlpha(0, (int)(yo - ghi * i + 0.5), bo, gF);
  146. }
  147. else
  148. {
  149. for (int i = 0; i < maxBr; ++i)
  150. zRObj.drawLinieV(gitterGr.x * i, 0, ho, gF);
  151. for (int i = 0; i < maxHi; ++i)
  152. zRObj.drawLinieH(0, (int)(yo - ghi * i + 0.5), bo, gF);
  153. }
  154. }
  155. for (int i = 0; i < lines; ++i)
  156. {
  157. int f_tmp = lFarbe->hat(i) ? lFarbe->get(i) : 0;
  158. Text* n_tmp = lName->z(i);
  159. Array<int>* ph_tmp = ph->z(i);
  160. Array<int>* pb_tmp = pb->z(i);
  161. if (hatStyle(Style::LinienName) && textRd && n_tmp)
  162. {
  163. textRd->setSchriftSize(12);
  164. Text rtxt = n_tmp->getText();
  165. rtxt += ": ";
  166. rtxt += lastValue->get(i);
  167. textRd->renderText(5, 5 + 15 * i, rtxt, zRObj, f_tmp);
  168. }
  169. if (ph_tmp && pb_tmp)
  170. {
  171. int lastX = 0;
  172. int lastY = innenSize.y - 1;
  173. int ph_anz = ph_tmp->getEintragAnzahl();
  174. int pb_anz = pb_tmp->getEintragAnzahl();
  175. for (int ii = 0; ii < ph_anz && ii < pb_anz; ++ii)
  176. {
  177. if (!ph_tmp || !pb_tmp) break;
  178. int xpos = lastX + pb_tmp->get(ii);
  179. int ypos = innenSize.y
  180. - (int)(ph_tmp->get(ii) * yFaktor + 0.5) - 1;
  181. if (ypos == -1) ++ypos;
  182. if (ypos < 0 || xpos < 0) break;
  183. if (hatStyle(Style::HAlpha))
  184. zRObj.drawLinieAlpha(
  185. Punkt(lastX, lastY), Punkt(xpos, ypos), f_tmp);
  186. else
  187. zRObj.drawLinie(
  188. Punkt(lastX, lastY), Punkt(xpos, ypos), f_tmp);
  189. lastX = xpos;
  190. lastY = ypos;
  191. }
  192. }
  193. }
  194. zRObj.releaseDrawOptions();
  195. unlockZeichnung();
  196. }
  197. }
  198. // constant
  199. Schrift* SLDiag::getSchrift() const // gibt die Schrift zurück
  200. {
  201. if (textRd) return textRd->getSchrift();
  202. return 0;
  203. }
  204. Schrift* SLDiag::zSchrift() const
  205. {
  206. return textRd ? textRd->zSchrift() : 0;
  207. }
  208. const Punkt& SLDiag::getGSize() const // gibt die Gitter Größe zurück
  209. {
  210. return gitterGr;
  211. }
  212. int SLDiag::getGFarbe() const // gibt die Gitter Farbe zurück
  213. {
  214. return gF;
  215. }
  216. int SLDiag::getLinienNummer(
  217. const char* name) const // gibt die Linien Nummer zurück
  218. {
  219. for (int i = 0; i < lines; ++i)
  220. {
  221. if (lName->z(i)->istGleich(name)) return i;
  222. }
  223. return -1;
  224. }
  225. int SLDiag::getLinienNummer(Text* name) const
  226. {
  227. for (int i = 0; i < lines; ++i)
  228. {
  229. if (lName->z(i)->istGleich(name->getText()))
  230. {
  231. name->release();
  232. return i;
  233. }
  234. }
  235. name->release();
  236. return -1;
  237. }
  238. Text* SLDiag::getLinienName(int lNum) const // gibt den Linien Namen zurück
  239. {
  240. return lName->get(lNum);
  241. }
  242. Text* SLDiag::zLinienNamen(int lNum) const
  243. {
  244. return lName->z(lNum);
  245. }
  246. int SLDiag::getHighestValue() const // gibt den Höchsten Wert zurück
  247. {
  248. int ret = 0;
  249. for (int i = 0; i < lines; ++i)
  250. {
  251. int tmp = getHighestValue(i);
  252. ret = ret >= tmp ? ret : tmp;
  253. }
  254. return ret;
  255. }
  256. int SLDiag::getHighestValue(int lNum) const
  257. {
  258. int ret = 0;
  259. Array<int>* tmp = ph->z(lNum);
  260. int anz = tmp->getEintragAnzahl();
  261. for (int i = 0; i < anz; ++i)
  262. ret = ret >= tmp->get(i) ? ret : tmp->get(i);
  263. return ret;
  264. }
  265. int SLDiag::getMedian(int lNum) const // gibt den durchschnittswert zurück
  266. {
  267. int count;
  268. int all = 0;
  269. Array<int>* tmp = ph->z(lNum);
  270. int anz = tmp->getEintragAnzahl();
  271. for (count = 1; count <= anz; ++count)
  272. all += tmp->get(count - 1);
  273. return (int)((double)all / count + 0.5);
  274. }
  275. int SLDiag::getLAnzahl() const // gibt die Linien Anzahl zurück
  276. {
  277. return lines;
  278. }
  279. int SLDiag::getLastValue(int lNum) const // gibt den letzten Wert zurück
  280. {
  281. return lastValue->get(lNum);
  282. }
  283. // Inhalt der DiagWert Struktur aus Diagramm.h
  284. // Konstruktor
  285. DiagWert::DiagWert()
  286. : ReferenceCounter(),
  287. style(0),
  288. farbe(0xFFFFFFFF),
  289. hintergrund(0),
  290. name(new Text()),
  291. punkte(new Array<DiagPunkt*>)
  292. {}
  293. // Destruktor
  294. DiagWert::~DiagWert()
  295. {
  296. name->release();
  297. int anz = punkte->getEintragAnzahl();
  298. for (int i = 0; i < anz; ++i)
  299. {
  300. if (punkte->hat(i)) delete punkte->get(i);
  301. }
  302. punkte->release();
  303. }
  304. // Inhalt der DiagDaten Struktur aus Diagramm.h
  305. // Konstruktor
  306. DiagDaten::DiagDaten()
  307. : ReferenceCounter(),
  308. style(0),
  309. rasterDicke(0),
  310. rasterBreite(0),
  311. rasterHeight(0),
  312. rasterFarbe(0),
  313. hIntervallFarbe(0xFFFFFFFF),
  314. vIntervallFarbe(0xFFFFFFFF),
  315. hIntervallName(new Text()),
  316. vIntervallName(new Text()),
  317. hIntervallTexte(new RCArray<Text>),
  318. vIntervallTexte(new RCArray<Text>),
  319. hIntervallWerte(new Array<double>),
  320. vIntervallWerte(new Array<double>),
  321. hIntervallBreite(0),
  322. vIntervallHeight(0),
  323. werte(new RCArray<DiagWert>())
  324. {}
  325. // Destruktor
  326. DiagDaten::~DiagDaten()
  327. {
  328. hIntervallName->release();
  329. vIntervallName->release();
  330. hIntervallWerte->release();
  331. vIntervallWerte->release();
  332. hIntervallTexte->release();
  333. vIntervallTexte->release();
  334. werte->release();
  335. }
  336. // Inhalt der BaseDiag Klasse aus Diagramm.h
  337. // Konstruktor
  338. BaseDiag::BaseDiag(Critical* lock)
  339. : daten(new DiagDaten()),
  340. changed(0),
  341. lock(lock)
  342. {}
  343. // Destruktor
  344. BaseDiag::~BaseDiag()
  345. {
  346. if (daten) daten->release();
  347. }
  348. // nicht constant
  349. void BaseDiag::setDiagDatenZ(
  350. DiagDaten* dd) // Setzt einen Zeiger auf die Daten des Diagramms
  351. {
  352. lock->lock();
  353. if (daten) daten->release();
  354. daten = dd;
  355. lock->unlock();
  356. changed = 1;
  357. }
  358. void BaseDiag::setDiagDaten(DiagDaten* dd) // Kopiert die Daten eines Diagramms
  359. {
  360. lock->lock();
  361. if (!daten) daten = new DiagDaten();
  362. daten->style = dd->style;
  363. daten->rasterBreite = dd->rasterBreite;
  364. daten->rasterHeight = dd->rasterHeight;
  365. daten->rasterFarbe = dd->rasterFarbe;
  366. daten->hIntervallFarbe = dd->hIntervallFarbe;
  367. daten->vIntervallFarbe = dd->vIntervallFarbe;
  368. daten->hIntervallName->setText(*dd->hIntervallName);
  369. daten->vIntervallName->setText(*dd->vIntervallName);
  370. int anz = dd->hIntervallWerte->getEintragAnzahl();
  371. for (int i = 0; i < anz; ++i)
  372. {
  373. if (dd->hIntervallWerte->hat(i))
  374. daten->hIntervallWerte->set(dd->hIntervallWerte->get(i), i);
  375. }
  376. anz = dd->vIntervallWerte->getEintragAnzahl();
  377. for (int i = 0; i < anz; ++i)
  378. {
  379. if (dd->vIntervallWerte->hat(i))
  380. daten->vIntervallWerte->set(dd->vIntervallWerte->get(i), i);
  381. }
  382. daten->hIntervallBreite = dd->hIntervallBreite;
  383. daten->vIntervallHeight = dd->vIntervallHeight;
  384. anz = dd->werte->getEintragAnzahl();
  385. for (int i = 0; i < anz; ++i)
  386. {
  387. DiagWert* tmp = dd->werte->z(i);
  388. if (tmp)
  389. {
  390. DiagWert* w = new DiagWert();
  391. w->style = tmp->style;
  392. w->farbe = tmp->farbe;
  393. w->hintergrund = tmp->hintergrund;
  394. w->name->setText(tmp->name->getText());
  395. int anz = tmp->punkte->getEintragAnzahl();
  396. for (int j = 0; j < anz; ++j)
  397. {
  398. if (tmp->punkte->hat(j))
  399. {
  400. DiagPunkt* p = new DiagPunkt();
  401. p->hIntervall = tmp->punkte->get(j)->hIntervall;
  402. p->vIntervall = tmp->punkte->get(j)->vIntervall;
  403. w->punkte->set(p, j);
  404. }
  405. }
  406. daten->werte->set(w, i);
  407. }
  408. }
  409. dd->release();
  410. lock->unlock();
  411. changed = 1;
  412. }
  413. void BaseDiag::setRasterDicke(int d) // Rasterdicke setzen
  414. {
  415. lock->lock();
  416. if (!daten) daten = new DiagDaten();
  417. if (daten->rasterDicke != d) changed = 1;
  418. daten->rasterDicke = d;
  419. lock->unlock();
  420. }
  421. void BaseDiag::setRasterBreite(int br) // Rasterbreite setzen
  422. {
  423. lock->lock();
  424. if (!daten) daten = new DiagDaten();
  425. if (daten->rasterBreite != br) changed = 1;
  426. daten->rasterBreite = br;
  427. lock->unlock();
  428. }
  429. void BaseDiag::setRasterHeight(int hi) // Rasterhöhe setzen
  430. {
  431. lock->lock();
  432. if (!daten) daten = new DiagDaten();
  433. if (daten->rasterHeight != hi) changed = 1;
  434. daten->rasterHeight = hi;
  435. lock->unlock();
  436. }
  437. void BaseDiag::setRasterFarbe(int f) // Rasterfarbe setzen
  438. {
  439. lock->lock();
  440. if (!daten) daten = new DiagDaten();
  441. if (daten->rasterFarbe != f) changed = 1;
  442. daten->rasterFarbe = f;
  443. lock->unlock();
  444. }
  445. void BaseDiag::setHIntervallBreite(double br) // Intervall Breite
  446. {
  447. lock->lock();
  448. if (!daten) daten = new DiagDaten();
  449. daten->hIntervallBreite = br;
  450. lock->unlock();
  451. }
  452. void BaseDiag::setVIntervallHeight(double hi) // Intervall Höhe
  453. {
  454. lock->lock();
  455. if (!daten) daten = new DiagDaten();
  456. daten->vIntervallHeight = hi;
  457. lock->unlock();
  458. }
  459. void BaseDiag::setHIntervallFarbe(int f) // Farbe des Horizontalen Intervalls
  460. {
  461. lock->lock();
  462. if (!daten) daten = new DiagDaten();
  463. if (daten->hIntervallFarbe != f) changed = 1;
  464. daten->hIntervallFarbe = f;
  465. lock->unlock();
  466. }
  467. void BaseDiag::setVIntervallFarbe(int f) // Farbe des Vertikalen Intervalls
  468. {
  469. lock->lock();
  470. if (!daten) daten = new DiagDaten();
  471. if (daten->vIntervallFarbe != f) changed = 1;
  472. daten->vIntervallFarbe = f;
  473. lock->unlock();
  474. }
  475. void BaseDiag::setHIntervallName(
  476. const char* name) // Setzt den Namen des Horizontalen Intervalls
  477. {
  478. lock->lock();
  479. if (!daten) daten = new DiagDaten();
  480. if (!daten->hIntervallName) daten->hIntervallName = new Text();
  481. if (!daten->hIntervallName->istGleich(name)) changed = 1;
  482. daten->hIntervallName->setText(name);
  483. lock->unlock();
  484. }
  485. void BaseDiag::setHIntervallName(Text* name)
  486. {
  487. lock->lock();
  488. if (!daten) daten = new DiagDaten();
  489. if (!daten->hIntervallName) daten->hIntervallName = new Text();
  490. if (!daten->hIntervallName->istGleich(*name)) changed = 1;
  491. daten->hIntervallName->setText(name);
  492. lock->unlock();
  493. }
  494. void BaseDiag::setVIntervallName(
  495. const char* name) // Setzt den Namen des Vertikalen Intervalls
  496. {
  497. lock->lock();
  498. if (!daten) daten = new DiagDaten();
  499. if (!daten->vIntervallName) daten->vIntervallName = new Text();
  500. if (!daten->vIntervallName->istGleich(name)) changed = 1;
  501. daten->vIntervallName->setText(name);
  502. lock->unlock();
  503. }
  504. void BaseDiag::setVIntervallName(Text* name)
  505. {
  506. lock->lock();
  507. if (!daten) daten = new DiagDaten();
  508. if (!daten->vIntervallName) daten->vIntervallName = new Text();
  509. if (!daten->vIntervallName->istGleich(*name)) changed = 1;
  510. daten->vIntervallName->setText(name);
  511. lock->unlock();
  512. }
  513. void BaseDiag::addHIntervallText(double hIntervall,
  514. const char* text) // Text eines Horizontalen Intervalls hinzufügen
  515. {
  516. setHIntervallText(hIntervall, text);
  517. }
  518. void BaseDiag::addHIntervallText(double hIntervall, Text* text)
  519. {
  520. setHIntervallText(hIntervall, *text);
  521. text->release();
  522. }
  523. void BaseDiag::setHIntervallTextZ(double hIntervall,
  524. Text* text) // Setzt den Text eines Horizontalen Intervalls
  525. {
  526. lock->lock();
  527. if (!daten) daten = new DiagDaten();
  528. if (!daten->hIntervallWerte) daten->hIntervallWerte = new Array<double>();
  529. if (!daten->hIntervallTexte) daten->hIntervallTexte = new RCArray<Text>();
  530. int anz = daten->hIntervallWerte->getEintragAnzahl();
  531. for (int i = 0; i < anz; ++i)
  532. {
  533. if (daten->hIntervallWerte->hat(i)
  534. && daten->hIntervallWerte->get(i) == hIntervall)
  535. {
  536. daten->hIntervallTexte->set(text, i);
  537. lock->unlock();
  538. changed = 1;
  539. return;
  540. }
  541. }
  542. daten->hIntervallWerte->set(hIntervall, anz);
  543. daten->hIntervallTexte->set(text, anz);
  544. lock->unlock();
  545. changed = 1;
  546. }
  547. void BaseDiag::setHIntervallText(double hIntervall, Text* text)
  548. {
  549. setHIntervallText(hIntervall, *text);
  550. text->release();
  551. }
  552. void BaseDiag::setHIntervallText(double hIntervall, const char* text)
  553. {
  554. lock->lock();
  555. if (!daten) daten = new DiagDaten();
  556. if (!daten->hIntervallWerte) daten->hIntervallWerte = new Array<double>();
  557. if (!daten->hIntervallTexte) daten->hIntervallTexte = new RCArray<Text>();
  558. int anz = daten->hIntervallWerte->getEintragAnzahl();
  559. for (int i = 0; i < anz; ++i)
  560. {
  561. if (daten->hIntervallWerte->hat(i)
  562. && daten->hIntervallWerte->get(i) == hIntervall)
  563. {
  564. if (!daten->hIntervallTexte->z(i))
  565. daten->hIntervallTexte->set(new Text(text), i);
  566. else
  567. daten->hIntervallTexte->z(i)->setText(text);
  568. lock->unlock();
  569. changed = 1;
  570. return;
  571. }
  572. }
  573. daten->hIntervallWerte->set(hIntervall, anz);
  574. daten->hIntervallTexte->set(new Text(text), anz);
  575. lock->unlock();
  576. changed = 1;
  577. }
  578. void BaseDiag::removeHIntervallText(
  579. double hIntervall) // Text eines Horizontalen Intervalls entfernen
  580. {
  581. lock->lock();
  582. if (!daten) daten = new DiagDaten();
  583. if (!daten->hIntervallWerte) daten->hIntervallWerte = new Array<double>();
  584. if (!daten->hIntervallTexte) daten->hIntervallTexte = new RCArray<Text>();
  585. int anz = daten->hIntervallWerte->getEintragAnzahl();
  586. for (int i = 0; i < anz; ++i)
  587. {
  588. if (daten->hIntervallWerte->hat(i)
  589. && daten->hIntervallWerte->get(i) == hIntervall)
  590. {
  591. daten->hIntervallTexte->remove(i);
  592. daten->hIntervallWerte->remove(i);
  593. lock->unlock();
  594. changed = 1;
  595. return;
  596. }
  597. }
  598. lock->unlock();
  599. }
  600. void BaseDiag::addVIntervallText(double vIntervall,
  601. const char* text) // Text eines Vertikalen Intervalls hinzufügen
  602. {
  603. setVIntervallText(vIntervall, text);
  604. }
  605. void BaseDiag::addVIntervallText(double vIntervall, Text* text)
  606. {
  607. setVIntervallText(vIntervall, *text);
  608. text->release();
  609. }
  610. void BaseDiag::setVIntervallTextZ(
  611. double vIntervall, Text* text) // Setzt den Text eines Vertikalen Intervalls
  612. {
  613. lock->lock();
  614. if (!daten) daten = new DiagDaten();
  615. if (!daten->vIntervallWerte) daten->vIntervallWerte = new Array<double>();
  616. if (!daten->vIntervallTexte) daten->vIntervallTexte = new RCArray<Text>();
  617. int anz = daten->vIntervallWerte->getEintragAnzahl();
  618. for (int i = 0; i < anz; ++i)
  619. {
  620. if (daten->vIntervallWerte->hat(i)
  621. && daten->vIntervallWerte->get(i) == vIntervall)
  622. {
  623. daten->vIntervallTexte->set(text, i);
  624. lock->unlock();
  625. changed = 1;
  626. return;
  627. }
  628. }
  629. daten->vIntervallWerte->set(vIntervall, anz);
  630. daten->vIntervallTexte->set(text, anz);
  631. lock->unlock();
  632. changed = 1;
  633. }
  634. void BaseDiag::setVIntervallText(double vIntervall, Text* text)
  635. {
  636. setVIntervallText(vIntervall, *text);
  637. text->release();
  638. }
  639. void BaseDiag::setVIntervallText(double vIntervall, const char* text)
  640. {
  641. lock->lock();
  642. if (!daten) daten = new DiagDaten();
  643. if (!daten->vIntervallWerte) daten->vIntervallWerte = new Array<double>();
  644. if (!daten->vIntervallTexte) daten->vIntervallTexte = new RCArray<Text>();
  645. int anz = daten->vIntervallWerte->getEintragAnzahl();
  646. for (int i = 0; i < anz; ++i)
  647. {
  648. if (daten->vIntervallWerte->hat(i)
  649. && daten->vIntervallWerte->get(i) == vIntervall)
  650. {
  651. if (!daten->vIntervallTexte->z(i))
  652. daten->vIntervallTexte->set(new Text(text), i);
  653. else
  654. daten->vIntervallTexte->z(i)->setText(text);
  655. lock->unlock();
  656. changed = 1;
  657. return;
  658. }
  659. }
  660. daten->vIntervallWerte->set(vIntervall, anz);
  661. daten->vIntervallTexte->set(new Text(text), anz);
  662. lock->unlock();
  663. changed = 1;
  664. }
  665. void BaseDiag::removeVIntervallText(
  666. double vIntervall) // Text eines Vertikalen Intervalls entfernen
  667. {
  668. lock->lock();
  669. if (!daten) daten = new DiagDaten();
  670. if (!daten->vIntervallWerte) daten->vIntervallWerte = new Array<double>();
  671. if (!daten->vIntervallTexte) daten->vIntervallTexte = new RCArray<Text>();
  672. int anz = daten->vIntervallWerte->getEintragAnzahl();
  673. for (int i = 0; i < anz; ++i)
  674. {
  675. if (daten->vIntervallWerte->hat(i)
  676. && daten->vIntervallWerte->get(i) == vIntervall)
  677. {
  678. daten->vIntervallTexte->remove(i);
  679. daten->vIntervallWerte->remove(i);
  680. lock->unlock();
  681. changed = 1;
  682. return;
  683. }
  684. }
  685. lock->unlock();
  686. }
  687. void BaseDiag::addWertZ(DiagWert* w) // Fügt einen Wert hinzu
  688. {
  689. lock->lock();
  690. if (!daten) daten = new DiagDaten();
  691. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  692. daten->werte->add(w);
  693. lock->unlock();
  694. changed = 1;
  695. }
  696. void BaseDiag::addWert(DiagWert* w)
  697. {
  698. lock->lock();
  699. DiagWert* tmp = new DiagWert();
  700. tmp->style = w->style;
  701. tmp->farbe = w->farbe;
  702. tmp->hintergrund = w->hintergrund;
  703. tmp->name->setText(*w->name);
  704. int anz = w->punkte->getEintragAnzahl();
  705. for (int i = 0; i < anz; ++i)
  706. {
  707. if (w->punkte->hat(i))
  708. {
  709. DiagPunkt* p = new DiagPunkt();
  710. p->hIntervall = w->punkte->get(i)->hIntervall;
  711. p->vIntervall = w->punkte->get(i)->vIntervall;
  712. tmp->punkte->set(p, i);
  713. }
  714. }
  715. w->release();
  716. addWertZ(tmp);
  717. lock->unlock();
  718. changed = 1;
  719. }
  720. void BaseDiag::addWert(const char* name)
  721. {
  722. lock->lock();
  723. if (!daten) daten = new DiagDaten();
  724. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  725. DiagWert* w = new DiagWert();
  726. w->name->setText(name);
  727. daten->werte->add(w);
  728. lock->unlock();
  729. changed = 1;
  730. }
  731. void BaseDiag::addWert(Text* txt)
  732. {
  733. addWert(*txt);
  734. txt->release();
  735. }
  736. void BaseDiag::setWertFarbe(int wNum, int f) // setzt die Farbe eines Wertes
  737. {
  738. if (wNum < 0) return;
  739. lock->lock();
  740. if (!daten) daten = new DiagDaten();
  741. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  742. if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
  743. daten->werte->z(wNum)->farbe = f;
  744. lock->unlock();
  745. changed = 1;
  746. }
  747. void BaseDiag::addPunktZ(
  748. int wNum, DiagPunkt* p) // fügt einem Wert einen Punkt hinzu
  749. {
  750. if (wNum < 0) return;
  751. lock->lock();
  752. if (!daten) daten = new DiagDaten();
  753. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  754. while (!daten->werte->hat(wNum))
  755. daten->werte->add(new DiagWert());
  756. if (!daten->werte->z(wNum)->punkte)
  757. daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
  758. daten->werte->z(wNum)->punkte->add(p);
  759. lock->unlock();
  760. changed = 1;
  761. }
  762. void BaseDiag::addPunkt(int wNum, DiagPunkt* p)
  763. {
  764. if (wNum < 0) return;
  765. lock->lock();
  766. if (!daten) daten = new DiagDaten();
  767. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  768. while (!daten->werte->hat(wNum))
  769. daten->werte->add(new DiagWert());
  770. if (!daten->werte->z(wNum)->punkte)
  771. daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
  772. DiagPunkt* tmp = new DiagPunkt();
  773. tmp->hIntervall = p->hIntervall;
  774. tmp->vIntervall = p->vIntervall;
  775. daten->werte->z(wNum)->punkte->add(tmp);
  776. lock->unlock();
  777. changed = 1;
  778. }
  779. void BaseDiag::addPunkt(int wNum, double hI, double vI)
  780. {
  781. if (wNum < 0) return;
  782. lock->lock();
  783. if (!daten) daten = new DiagDaten();
  784. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  785. if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
  786. if (!daten->werte->z(wNum)->punkte)
  787. daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
  788. DiagPunkt* tmp = new DiagPunkt();
  789. tmp->hIntervall = hI;
  790. tmp->vIntervall = vI;
  791. daten->werte->z(wNum)->punkte->add(tmp);
  792. lock->unlock();
  793. changed = 1;
  794. }
  795. // Ändert einen vorhandenen Punkt eines Wertes
  796. void BaseDiag::setPunktZ(int wNum, double hI, DiagPunkt* p)
  797. {
  798. setPunktZ(wNum, getDiagPunktPos(wNum, hI), p);
  799. }
  800. void BaseDiag::setPunkt(int wNum, double hI, DiagPunkt* p)
  801. {
  802. setPunkt(wNum, getDiagPunktPos(wNum, hI), p->hIntervall, p->vIntervall);
  803. }
  804. void BaseDiag::setPunkt(int wNum, double hI, double h, double v)
  805. {
  806. setPunkt(wNum, getDiagPunktPos(wNum, hI), h, v);
  807. }
  808. void BaseDiag::setPunktZ(int wNum, int pNum, DiagPunkt* p)
  809. {
  810. if (pNum < 0 || wNum < 0) return;
  811. lock->lock();
  812. if (!daten) daten = new DiagDaten();
  813. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  814. if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
  815. if (!daten->werte->z(wNum)->punkte)
  816. daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
  817. if (daten->werte->z(wNum)->punkte->hat(pNum))
  818. delete daten->werte->z(wNum)->punkte->get(pNum);
  819. daten->werte->z(wNum)->punkte->set(p, pNum);
  820. lock->unlock();
  821. changed = 1;
  822. }
  823. void BaseDiag::setPunkt(int wNum, int pNum, DiagPunkt* p)
  824. {
  825. if (pNum < 0 || wNum < 0) return;
  826. setPunkt(wNum, pNum, p->hIntervall, p->vIntervall);
  827. }
  828. void BaseDiag::setPunkt(int wNum, int pNum, double h, double v)
  829. {
  830. if (pNum < 0 || wNum < 0) return;
  831. lock->lock();
  832. if (!daten) daten = new DiagDaten();
  833. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  834. if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
  835. if (!daten->werte->z(wNum)->punkte)
  836. daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
  837. if (!daten->werte->z(wNum)->punkte->hat(pNum))
  838. daten->werte->z(wNum)->punkte->set(new DiagPunkt(), pNum);
  839. daten->werte->z(wNum)->punkte->get(pNum)->hIntervall = h;
  840. daten->werte->z(wNum)->punkte->get(pNum)->vIntervall = v;
  841. lock->unlock();
  842. changed = 1;
  843. }
  844. // Löscht einen vorhandenen Punkt
  845. void BaseDiag::removePunkt(int wNum, double hI)
  846. {
  847. lock->lock();
  848. if (!daten) daten = new DiagDaten();
  849. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  850. if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
  851. if (!daten->werte->z(wNum)->punkte)
  852. daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
  853. int anz = daten->werte->z(wNum)->punkte->getEintragAnzahl();
  854. for (int i = 0; i < anz; ++i)
  855. {
  856. if (daten->werte->z(wNum)->punkte->hat(i)
  857. && daten->werte->z(wNum)->punkte->get(i)->hIntervall == hI)
  858. {
  859. delete daten->werte->z(wNum)->punkte->get(i);
  860. daten->werte->z(wNum)->punkte->remove(i);
  861. lock->unlock();
  862. changed = 1;
  863. return;
  864. }
  865. }
  866. lock->unlock();
  867. }
  868. void BaseDiag::removePunkt(int wNum, int pNum)
  869. {
  870. lock->lock();
  871. if (!daten) daten = new DiagDaten();
  872. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  873. if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
  874. if (!daten->werte->z(wNum)->punkte)
  875. daten->werte->z(wNum)->punkte = new Array<DiagPunkt*>();
  876. if (daten->werte->z(wNum)->punkte->hat(pNum))
  877. {
  878. delete daten->werte->z(wNum)->punkte->get(pNum);
  879. daten->werte->z(wNum)->punkte->remove(pNum);
  880. changed = 1;
  881. }
  882. lock->unlock();
  883. }
  884. void BaseDiag::removeWert(int wNum) // entfernt einen Wert
  885. {
  886. lock->lock();
  887. if (!daten) daten = new DiagDaten();
  888. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  889. daten->werte->remove(wNum);
  890. lock->unlock();
  891. changed = 1;
  892. }
  893. void BaseDiag::removeWert(const char* name)
  894. {
  895. lock->lock();
  896. if (!daten) daten = new DiagDaten();
  897. if (!daten->werte) daten->werte = new RCArray<DiagWert>();
  898. int anz = daten->werte->getEintragAnzahl();
  899. for (int i = 0; i < anz; ++i)
  900. {
  901. DiagWert* tmp = daten->werte->z(i);
  902. if (tmp && tmp->name && tmp->name->istGleich(name))
  903. {
  904. daten->werte->remove(i);
  905. lock->unlock();
  906. changed = 1;
  907. return;
  908. }
  909. }
  910. lock->unlock();
  911. }
  912. void BaseDiag::removeWert(Text* name)
  913. {
  914. removeWert(name->getText());
  915. name->release();
  916. }
  917. void BaseDiag::addDatenStyle(int style) // Setzt den Style der Daten
  918. {
  919. if (!daten) daten = new DiagDaten();
  920. if ((daten->style | style) != daten->style) changed = 1;
  921. daten->style |= style;
  922. }
  923. void BaseDiag::setDatenStyle(int style)
  924. {
  925. if (!daten) daten = new DiagDaten();
  926. if (daten->style != style) changed = 1;
  927. daten->style = style;
  928. }
  929. void BaseDiag::setDatenStyle(int style, bool addRemove)
  930. {
  931. if (addRemove)
  932. addDatenStyle(style);
  933. else
  934. removeDatenStyle(style);
  935. }
  936. void BaseDiag::removeDatenStyle(int style)
  937. {
  938. if (!daten) daten = new DiagDaten();
  939. if ((daten->style & ~style) != daten->style) changed = 1;
  940. daten->style &= ~style;
  941. }
  942. void BaseDiag::addWertStyle(int wNum, int style) // Setzt den Style eines Wertes
  943. {
  944. if (wNum < 0) return;
  945. if (!daten) daten = new DiagDaten();
  946. if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
  947. if ((daten->werte->z(wNum)->style | style) != daten->werte->z(wNum)->style)
  948. changed = 1;
  949. daten->werte->z(wNum)->style |= style;
  950. }
  951. void BaseDiag::setWertStyle(int wNum, int style)
  952. {
  953. if (wNum < 0) return;
  954. if (!daten) daten = new DiagDaten();
  955. if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
  956. if (daten->werte->z(wNum)->style != style) changed = 1;
  957. daten->werte->z(wNum)->style = style;
  958. }
  959. void BaseDiag::setWertStyle(int wNum, int style, bool addRemove)
  960. {
  961. if (wNum < 0) return;
  962. if (addRemove)
  963. addWertStyle(wNum, style);
  964. else
  965. removeWertStyle(wNum, style);
  966. }
  967. void BaseDiag::removeWertStyle(int wNum, int style)
  968. {
  969. if (wNum < 0) return;
  970. if (!daten) daten = new DiagDaten();
  971. if (!daten->werte->z(wNum)) daten->werte->set(new DiagWert(), wNum);
  972. if ((daten->werte->z(wNum)->style & ~style) != daten->werte->z(wNum)->style)
  973. changed = 1;
  974. daten->werte->z(wNum)->style &= ~style;
  975. }
  976. // constant
  977. DiagDaten* BaseDiag::getDiagDaten() const // Gibt die Daten des Diagramms zurück
  978. {
  979. return daten ? dynamic_cast<DiagDaten*>(daten->getThis()) : 0;
  980. }
  981. DiagDaten* BaseDiag::zDiagDaten() const
  982. {
  983. return daten;
  984. }
  985. DiagWert* BaseDiag::getDiagWert(
  986. int wNum) const // Gibt die Daten eines Wertes zurück
  987. {
  988. return (daten && daten->werte) ? daten->werte->get(wNum) : 0;
  989. }
  990. DiagWert* BaseDiag::zDiagWert(int wNum) const
  991. {
  992. return (daten && daten->werte) ? daten->werte->z(wNum) : 0;
  993. }
  994. DiagWert* BaseDiag::getDiagWert(const char* name) const
  995. {
  996. return getDiagWert(getDiagWertPos(name));
  997. }
  998. DiagWert* BaseDiag::zDiagWert(const char* name) const
  999. {
  1000. return zDiagWert(getDiagWertPos(name));
  1001. }
  1002. int BaseDiag::getDiagWertPos(
  1003. const char* name) const // Gibt die Position eines Wertes zurück
  1004. {
  1005. if (!daten || !daten->werte) return -1;
  1006. int anz = daten->werte->getEintragAnzahl();
  1007. for (int i = 0; i < anz; ++i)
  1008. {
  1009. if (daten->werte->z(i) && daten->werte->z(i)->name
  1010. && daten->werte->z(i)->name->istGleich(name))
  1011. return i;
  1012. }
  1013. return -1;
  1014. }
  1015. int BaseDiag::getDiagPunktPos(int wNum,
  1016. double hI) const // Gibt die Position eines Punktes von einem Wert zurück
  1017. {
  1018. if (!daten || !daten->werte || !daten->werte->z(wNum)
  1019. || !daten->werte->z(wNum)->punkte)
  1020. return -1;
  1021. int anz = daten->werte->z(wNum)->punkte->getEintragAnzahl();
  1022. for (int i = 0; i < anz; ++i)
  1023. {
  1024. if (daten->werte->z(wNum)->punkte->hat(i)
  1025. && daten->werte->z(wNum)->punkte->get(i)->hIntervall == hI)
  1026. return i;
  1027. }
  1028. return -1;
  1029. }
  1030. int BaseDiag::getDiagPunktPos(char* wName, double hI) const
  1031. {
  1032. return getDiagPunktPos(getDiagWertPos(wName), hI);
  1033. }
  1034. bool BaseDiag::hatDatenStyle(int style) const // Prüft den Style der Daten
  1035. {
  1036. if (!daten) return 0;
  1037. return (daten->style | style) == daten->style;
  1038. }
  1039. bool BaseDiag::hatDatenStyleNicht(int style) const
  1040. {
  1041. if (!daten) return 1;
  1042. return (daten->style | style) != daten->style;
  1043. }
  1044. bool BaseDiag::hatWertStyle(
  1045. int wNum, int style) const // Prüft den Style eines Wertes
  1046. {
  1047. if (!daten || !daten->werte || !daten->werte->z(wNum)) return 0;
  1048. return (daten->werte->z(wNum)->style | style)
  1049. == daten->werte->z(wNum)->style;
  1050. }
  1051. bool BaseDiag::hatWertStyleNicht(int wNum, int style) const
  1052. {
  1053. if (!daten || !daten->werte || !daten->werte->z(wNum)) return 1;
  1054. return (daten->werte->z(wNum)->style | style)
  1055. != daten->werte->z(wNum)->style;
  1056. }
  1057. // Inhalt der LDiag Klasse aus Diagramm.h
  1058. // Konstruktor
  1059. LDiag::LDiag()
  1060. : ZeichnungHintergrund(),
  1061. BaseDiag(&cs),
  1062. textRd(0),
  1063. dRam(new LRahmen()),
  1064. dBgF(0),
  1065. dBgB(0),
  1066. dAf(new AlphaFeld()),
  1067. vIntervallRB(new Bild()),
  1068. hIntervallRB(new Bild()),
  1069. schriftGr(12)
  1070. {
  1071. style = Style::MELockZeichnung;
  1072. vertikalScrollBar = new VScrollBar();
  1073. horizontalScrollBar = new HScrollBar();
  1074. }
  1075. // Destruktor
  1076. LDiag::~LDiag()
  1077. {
  1078. if (textRd) textRd->release();
  1079. if (dRam) dRam->release();
  1080. if (dBgB) dBgB->release();
  1081. if (dAf) dAf->release();
  1082. if (vIntervallRB) vIntervallRB->release();
  1083. if (hIntervallRB) hIntervallRB->release();
  1084. }
  1085. void LDiag::doMausEreignis(MausEreignis& me, bool userRet)
  1086. {
  1087. if (hatDatenStyle(DiagDaten::Style::Sichtbar)
  1088. && (hatStyle(Style::HScroll) || hatStyle(Style::VScroll)) && userRet)
  1089. {
  1090. int rbr = 0;
  1091. if (hatStyle(Style::Rahmen) && rahmen) rbr = rahmen->getRBreite();
  1092. bool vs = hatStyle(Style::VScroll) && vertikalScrollBar;
  1093. bool hs = hatStyle(Style::HScroll) && horizontalScrollBar;
  1094. if (vs)
  1095. {
  1096. if (hs)
  1097. horizontalScrollBar->doMausMessage(
  1098. rbr, gr.y - rbr - 15, gr.x - rbr * 2 - 15, 15, me);
  1099. vertikalScrollBar->doMausMessage(
  1100. gr.x - rbr - 15, rbr, 15, gr.y - rbr * 2, me);
  1101. }
  1102. else if (hs)
  1103. horizontalScrollBar->doMausMessage(
  1104. rbr, gr.y - rbr - 15, gr.x - rbr * 2, 15, me);
  1105. }
  1106. me.verarbeitet = userRet;
  1107. }
  1108. // nicht constant
  1109. void LDiag::setTextRendererZ(TextRenderer* textRd)
  1110. {
  1111. lockZeichnung();
  1112. if (this->textRd) this->textRd->release();
  1113. this->textRd = textRd;
  1114. unlockZeichnung();
  1115. }
  1116. void LDiag::setSchriftZ(Schrift* schrift) // Setzt die Schrift
  1117. {
  1118. lockZeichnung();
  1119. if (!this->textRd)
  1120. textRd = new TextRenderer(schrift);
  1121. else
  1122. textRd->setSchriftZ(schrift);
  1123. rend = 1;
  1124. unlockZeichnung();
  1125. }
  1126. void LDiag::setSchriftSize(int gr)
  1127. {
  1128. lockZeichnung();
  1129. if (schriftGr != gr) rend = 1;
  1130. schriftGr = gr;
  1131. unlockZeichnung();
  1132. }
  1133. void LDiag::setDatenRahmenZ(
  1134. Rahmen* ram) // Setzt den inneren Rahmen um das eigentliche Diagramm
  1135. {
  1136. lockZeichnung();
  1137. if (dRam) dRam->release();
  1138. dRam = ram;
  1139. unlockZeichnung();
  1140. rend = 1;
  1141. }
  1142. void LDiag::setDatenRahmen(Rahmen* ram)
  1143. {
  1144. lockZeichnung();
  1145. if (!dRam) dRam = new LRahmen();
  1146. dRam->setAlpha(ram->hatAlpha());
  1147. dRam->setFarbe(ram->getFarbe());
  1148. dRam->setRamenBreite(ram->getRBreite());
  1149. unlockZeichnung();
  1150. ram->release();
  1151. rend = 1;
  1152. }
  1153. void LDiag::setDatenRahmenBreite(int br)
  1154. {
  1155. lockZeichnung();
  1156. if (!dRam) dRam = new LRahmen();
  1157. if (dRam->getRBreite() != br) rend = 1;
  1158. dRam->setRamenBreite(br);
  1159. unlockZeichnung();
  1160. }
  1161. void LDiag::setDatenRahmenFarbe(int f)
  1162. {
  1163. lockZeichnung();
  1164. if (!dRam) dRam = new LRahmen();
  1165. dRam->setFarbe(f);
  1166. unlockZeichnung();
  1167. rend = 1;
  1168. }
  1169. void LDiag::setDatenHintergrundFarbe(
  1170. int f) // Setzt den Hintergrund des eigentlichen Diagramms
  1171. {
  1172. dBgF = f;
  1173. rend = 1;
  1174. }
  1175. void LDiag::setDatenHintergrundBildZ(Bild* b)
  1176. {
  1177. lockZeichnung();
  1178. if (dBgB) dBgB->release();
  1179. dBgB = b;
  1180. unlockZeichnung();
  1181. rend = 1;
  1182. }
  1183. void LDiag::setDatenHintergrundBild(Bild* b)
  1184. {
  1185. lockZeichnung();
  1186. if (!dBgB) dBgB = new Bild();
  1187. dBgB->neuBild(b->getBreite(), b->getHeight(), 0);
  1188. dBgB->drawBild(0, 0, b->getBreite(), b->getHeight(), *b);
  1189. unlockZeichnung();
  1190. b->release();
  1191. rend = 1;
  1192. }
  1193. void LDiag::setDatenAlphaFeldZ(
  1194. AlphaFeld* af) // Setzt das AlphaFeld des eigentlichen Diagramms
  1195. {
  1196. lockZeichnung();
  1197. if (dAf) dAf->release();
  1198. dAf = af;
  1199. unlockZeichnung();
  1200. rend = 1;
  1201. }
  1202. void LDiag::setDatenAlphaFeld(AlphaFeld* af)
  1203. {
  1204. lockZeichnung();
  1205. if (!dAf) dAf = new AlphaFeld();
  1206. dAf->setFarbe(af->getFarbe());
  1207. dAf->setStrength(af->getStrength());
  1208. unlockZeichnung();
  1209. af->release();
  1210. rend = 1;
  1211. }
  1212. void LDiag::setDatenAlphaFeldFarbe(int f)
  1213. {
  1214. lockZeichnung();
  1215. if (!dAf) dAf = new AlphaFeld();
  1216. dAf->setFarbe(f);
  1217. unlockZeichnung();
  1218. rend = 1;
  1219. }
  1220. void LDiag::setDatenAlphaFeldStrength(int st)
  1221. {
  1222. lockZeichnung();
  1223. if (!dAf) dAf = new AlphaFeld();
  1224. if (dAf->getStrength() != st) rend = 1;
  1225. dAf->setStrength(st);
  1226. unlockZeichnung();
  1227. }
  1228. void LDiag::render(Bild& zRObj)
  1229. {
  1230. if (!hatDatenStyle(DiagDaten::Style::Sichtbar)) return;
  1231. ZeichnungHintergrund::render(zRObj);
  1232. if (!zRObj.setDrawOptions(innenPosition, innenSize)) return;
  1233. lockZeichnung();
  1234. int dgy = 0;
  1235. int dgbr = innenSize.x;
  1236. int dghi = innenSize.y;
  1237. int vIAnz = 0;
  1238. int hIAnz = 0;
  1239. if (daten)
  1240. { // Auto werte berechnen
  1241. vIAnz = daten->vIntervallWerte
  1242. ? daten->vIntervallWerte->getEintragAnzahl()
  1243. : 0;
  1244. hIAnz = daten->hIntervallWerte
  1245. ? daten->hIntervallWerte->getEintragAnzahl()
  1246. : 0;
  1247. if (daten->vIntervallWerte
  1248. && hatDatenStyle(DiagDaten::Style::AutoIntervallHeight))
  1249. {
  1250. double maxW = 0;
  1251. for (int i = 0; i < vIAnz; ++i)
  1252. {
  1253. if (daten->vIntervallWerte->hat(i)
  1254. && daten->vIntervallWerte->get(i) > maxW)
  1255. maxW = daten->vIntervallWerte->get(i);
  1256. }
  1257. if (vertikalScrollBar && hatStyle(Style::VScroll))
  1258. daten->vIntervallHeight
  1259. = maxW ? (vertikalScrollBar->getScroll() / maxW) : 0;
  1260. else
  1261. daten->vIntervallHeight
  1262. = maxW ? (vIntervallRB->getBreite() / maxW) : 0;
  1263. }
  1264. if (hatDatenStyle(DiagDaten::Style::AutoRasterHeight))
  1265. daten->rasterHeight = daten->vIntervallHeight;
  1266. if (daten->hIntervallWerte
  1267. && hatDatenStyle(DiagDaten::Style::AutoIntervallBreite))
  1268. {
  1269. double maxW = 0;
  1270. for (int i = 0; i < hIAnz; ++i)
  1271. {
  1272. if (daten->hIntervallWerte->hat(i)
  1273. && daten->hIntervallWerte->get(i) > maxW)
  1274. maxW = daten->hIntervallWerte->get(i);
  1275. }
  1276. if (horizontalScrollBar && hatStyle(Style::HScroll))
  1277. daten->hIntervallBreite
  1278. = maxW ? (horizontalScrollBar->getScroll() / maxW) : 0;
  1279. else
  1280. daten->hIntervallBreite
  1281. = maxW ? (hIntervallRB->getBreite() / maxW) : 0;
  1282. }
  1283. if (hatDatenStyle(DiagDaten::Style::AutoRasterBreite))
  1284. daten->rasterBreite = daten->hIntervallBreite;
  1285. }
  1286. if (hatDatenStyle(DiagDaten::Style::VIntervall) && textRd && schriftGr
  1287. && daten)
  1288. { // Rendern des vertikalen Intervalls
  1289. int vIRBbr = innenSize.y;
  1290. if (hatDatenStyle(DiagDaten::Style::HIntervall)
  1291. && daten->hIntervallFarbe)
  1292. vIRBbr -= schriftGr + 2;
  1293. if (vIRBbr > 0)
  1294. {
  1295. if (vIntervallRB->getBreite() != vIRBbr
  1296. || vIntervallRB->getHeight() != schriftGr + 2)
  1297. vIntervallRB->neuBild(vIRBbr, schriftGr + 2, 0xFF000000);
  1298. else
  1299. vIntervallRB->fillRegion(
  1300. 0, 0, vIRBbr, schriftGr + 2, 0xFF000000);
  1301. textRd->setSchriftSize(schriftGr);
  1302. if (daten->vIntervallWerte)
  1303. {
  1304. int* rf = new int[vIAnz];
  1305. int anz = 0;
  1306. bool* fertig = new bool[vIAnz];
  1307. ZeroMemory(fertig, vIAnz);
  1308. for (int i = 0; i < vIAnz; ++i)
  1309. {
  1310. double min = 0;
  1311. int mI = -1;
  1312. for (int j = 0; j < vIAnz; ++j)
  1313. {
  1314. if (!fertig[j] && daten->vIntervallWerte->hat(j)
  1315. && (daten->vIntervallWerte->get(j) < min || mI < 0))
  1316. {
  1317. mI = j;
  1318. min = daten->vIntervallWerte->get(j);
  1319. }
  1320. }
  1321. if (mI < 0) break;
  1322. rf[anz] = mI;
  1323. ++anz;
  1324. fertig[mI] = 1;
  1325. }
  1326. delete[] fertig;
  1327. Text txt;
  1328. int xPos = 0;
  1329. if (vertikalScrollBar && hatStyle(Style::VScroll))
  1330. xPos -= vertikalScrollBar->getScroll();
  1331. int rWeite = xPos - 10;
  1332. for (int i = anz - 1; i >= 0; --i)
  1333. {
  1334. txt = "";
  1335. if (hatDatenStyle(DiagDaten::Style::VIntervallTexte)
  1336. && daten->vIntervallTexte
  1337. && daten->vIntervallTexte->z(rf[i]))
  1338. txt = daten->vIntervallTexte->z(rf[i])->getText();
  1339. else if (hatDatenStyleNicht(
  1340. DiagDaten::Style::VIntervallTexte)
  1341. || !daten->vIntervallWerte)
  1342. txt = daten->vIntervallWerte->get(rf[i]);
  1343. xPos = (int)(daten->vIntervallWerte->get(rf[i])
  1344. * daten->vIntervallHeight);
  1345. xPos = (vertikalScrollBar && hatStyle(Style::VScroll)
  1346. ? vertikalScrollBar->getScroll()
  1347. : vIntervallRB->getBreite())
  1348. - xPos;
  1349. if (vertikalScrollBar && hatStyle(Style::VScroll))
  1350. xPos -= vertikalScrollBar->getScroll();
  1351. int br = textRd->getTextBreite(txt);
  1352. if (xPos + br > vIntervallRB->getBreite()
  1353. && vIntervallRB->getBreite() - br >= rWeite + 10)
  1354. xPos = vIntervallRB->getBreite() - br;
  1355. if (xPos >= rWeite + 10)
  1356. {
  1357. textRd->renderText(xPos,
  1358. 1,
  1359. txt,
  1360. *vIntervallRB,
  1361. daten->vIntervallFarbe);
  1362. rWeite = xPos + br + 10;
  1363. }
  1364. }
  1365. delete[] rf;
  1366. }
  1367. if (daten->vIntervallName)
  1368. {
  1369. int vinbr
  1370. = textRd->getTextBreite(daten->vIntervallName->getText());
  1371. int vinx = vIntervallRB->getBreite() / 2 - vinbr / 2;
  1372. vIntervallRB->fillRegion(
  1373. vinx - 5, 1, vinbr + 10, schriftGr, 0xFF000000);
  1374. textRd->renderText(vinx,
  1375. 1,
  1376. daten->vIntervallName->getText(),
  1377. *vIntervallRB,
  1378. daten->vIntervallFarbe);
  1379. }
  1380. if (hatDatenStyle(DiagDaten::Style::HIntervall)
  1381. && daten->hIntervallFarbe)
  1382. zRObj.alphaBild90(innenSize.x - vIntervallRB->getHeight(),
  1383. schriftGr + 2,
  1384. vIntervallRB->getBreite(),
  1385. vIntervallRB->getHeight(),
  1386. *vIntervallRB);
  1387. else
  1388. zRObj.alphaBild90(innenSize.x - vIntervallRB->getHeight(),
  1389. 0,
  1390. vIntervallRB->getBreite(),
  1391. vIntervallRB->getHeight(),
  1392. *vIntervallRB);
  1393. dgbr -= vIntervallRB->getHeight();
  1394. }
  1395. }
  1396. if (hatDatenStyle(DiagDaten::Style::HIntervall) && textRd && schriftGr
  1397. && daten)
  1398. { // Rendern des horizontalen Intervalls
  1399. int hIRBbr = innenSize.x;
  1400. if (hatDatenStyle(DiagDaten::Style::VIntervall)
  1401. && daten->vIntervallFarbe)
  1402. hIRBbr -= schriftGr + 2;
  1403. if (hIRBbr > 0)
  1404. {
  1405. if (hIntervallRB->getBreite() != hIRBbr
  1406. || hIntervallRB->getHeight() != schriftGr + 2)
  1407. hIntervallRB->neuBild(hIRBbr, schriftGr + 2, 0xFF000000);
  1408. else
  1409. hIntervallRB->fillRegion(
  1410. 0, 0, hIRBbr, schriftGr + 2, 0xFF000000);
  1411. textRd->setSchriftSize(schriftGr);
  1412. if (daten->hIntervallWerte)
  1413. {
  1414. int* rf = new int[hIAnz];
  1415. int anz = 0;
  1416. bool* fertig = new bool[hIAnz];
  1417. ZeroMemory(fertig, hIAnz);
  1418. for (int i = 0; i < hIAnz; ++i)
  1419. {
  1420. double min = 0;
  1421. int mI = -1;
  1422. for (int j = 0; j < hIAnz; ++j)
  1423. {
  1424. if (!fertig[j] && daten->hIntervallWerte->hat(j)
  1425. && (daten->hIntervallWerte->get(j) < min || mI < 0))
  1426. {
  1427. mI = j;
  1428. min = daten->hIntervallWerte->get(j);
  1429. }
  1430. }
  1431. if (mI < 0) break;
  1432. rf[anz] = mI;
  1433. ++anz;
  1434. fertig[mI] = 1;
  1435. }
  1436. delete[] fertig;
  1437. Text txt;
  1438. int xPos = 0;
  1439. if (horizontalScrollBar && hatStyle(Style::HScroll))
  1440. xPos -= horizontalScrollBar->getScroll();
  1441. int rWeite = xPos - 10;
  1442. for (int i = 0; i < anz; ++i)
  1443. {
  1444. txt = "";
  1445. if (hatDatenStyle(DiagDaten::Style::HIntervallTexte)
  1446. && daten->hIntervallTexte
  1447. && daten->hIntervallTexte->z(rf[i]))
  1448. txt = daten->hIntervallTexte->z(rf[i])->getText();
  1449. else if (hatDatenStyleNicht(
  1450. DiagDaten::Style::HIntervallTexte)
  1451. || !daten->hIntervallWerte)
  1452. txt = daten->hIntervallWerte->get(rf[i]);
  1453. xPos = (int)(daten->hIntervallWerte->get(rf[i])
  1454. * daten->hIntervallBreite);
  1455. if (horizontalScrollBar && hatStyle(Style::HScroll))
  1456. xPos -= horizontalScrollBar->getScroll();
  1457. int br = textRd->getTextBreite(txt);
  1458. if (xPos + br > hIntervallRB->getBreite()
  1459. && hIntervallRB->getBreite() - br >= rWeite + 10)
  1460. xPos = hIntervallRB->getBreite() - br;
  1461. if (xPos >= rWeite + 10)
  1462. {
  1463. textRd->renderText(xPos,
  1464. 1,
  1465. txt,
  1466. *hIntervallRB,
  1467. daten->hIntervallFarbe);
  1468. rWeite = xPos + br + 10;
  1469. }
  1470. }
  1471. delete[] rf;
  1472. }
  1473. if (daten->hIntervallName)
  1474. {
  1475. int hinbr
  1476. = textRd->getTextBreite(daten->hIntervallName->getText());
  1477. int hinx = hIntervallRB->getBreite() / 2 - hinbr / 2;
  1478. hIntervallRB->fillRegion(
  1479. hinx - 5, 1, hinbr + 10, schriftGr, 0xFF000000);
  1480. textRd->renderText(hinx,
  1481. 1,
  1482. daten->hIntervallName->getText(),
  1483. *hIntervallRB,
  1484. daten->hIntervallFarbe);
  1485. }
  1486. zRObj.alphaBild(0,
  1487. 0,
  1488. hIntervallRB->getBreite(),
  1489. hIntervallRB->getHeight(),
  1490. *hIntervallRB);
  1491. dghi -= hIntervallRB->getHeight();
  1492. dgy += hIntervallRB->getHeight();
  1493. }
  1494. }
  1495. if (!zRObj.setDrawOptions(0, dgy, dgbr, dghi))
  1496. {
  1497. zRObj.releaseDrawOptions();
  1498. unlockZeichnung();
  1499. return;
  1500. }
  1501. dgy = 0;
  1502. int dgrbr = 0;
  1503. if (hatStyle(Style::DatenRahmen) && dRam)
  1504. {
  1505. dRam->setSize(dgbr, dghi);
  1506. dRam->render(zRObj);
  1507. dgrbr = dRam->getRBreite();
  1508. }
  1509. if (!zRObj.setDrawOptions(dgrbr, dgrbr, dgbr - dgrbr * 2, dghi - dgrbr * 2))
  1510. {
  1511. zRObj.releaseDrawOptions();
  1512. zRObj.releaseDrawOptions();
  1513. unlockZeichnung();
  1514. return;
  1515. }
  1516. if (hatStyle(Style::DatenHintergrund))
  1517. {
  1518. if (hatStyle(Style::DatenHAlpha))
  1519. zRObj.alphaRegion(0, 0, dgbr - dgrbr * 2, dghi - dgrbr * 2, dBgF);
  1520. else
  1521. zRObj.fillRegion(0, 0, dgbr - dgrbr * 2, dghi - dgrbr * 2, dBgF);
  1522. if (hatStyle(Style::DatenHBild) && dBgB)
  1523. {
  1524. if (hatStyle(Style::DatenHAlpha))
  1525. zRObj.alphaBild(
  1526. 0, 0, dgbr - dgrbr * 2, dghi - dgrbr * 2, *dBgB);
  1527. else
  1528. zRObj.drawBild(0, 0, dgbr - dgrbr * 2, dghi - dgrbr * 2, *dBgB);
  1529. }
  1530. }
  1531. if (hatStyle(Style::DatenBuffered) && dAf)
  1532. {
  1533. dAf->setSize(dgbr - dgrbr * 2, dghi - dgrbr * 2);
  1534. dAf->render(zRObj);
  1535. }
  1536. if (hatDatenStyle(DiagDaten::Style::Raster) && daten && daten->rasterDicke
  1537. && daten->rasterBreite && daten->rasterHeight)
  1538. { // Raster
  1539. int maxBr = dgbr;
  1540. if (horizontalScrollBar && hatStyle(Style::HScroll))
  1541. maxBr = horizontalScrollBar->getScroll();
  1542. int maxHi = dghi;
  1543. if (vertikalScrollBar && hatStyle(Style::VScroll))
  1544. maxHi = vertikalScrollBar->getScroll();
  1545. for (double x = horizontalScrollBar && hatStyle(Style::HScroll)
  1546. ? -horizontalScrollBar->getScroll()
  1547. : 0;
  1548. x < maxBr;
  1549. x += daten->rasterBreite)
  1550. {
  1551. for (int i = 0; i < daten->rasterDicke; ++i)
  1552. {
  1553. if (hatDatenStyle(DiagDaten::Style::RasterAlpha))
  1554. zRObj.drawLinieVAlpha((int)(x + i),
  1555. dgy + dgrbr,
  1556. dghi - dgrbr * 2,
  1557. daten->rasterFarbe);
  1558. else
  1559. zRObj.drawLinieV((int)(x + i),
  1560. dgy + dgrbr,
  1561. dghi - dgrbr * 2,
  1562. daten->rasterFarbe);
  1563. }
  1564. }
  1565. for (double y = maxHi;
  1566. y > (vertikalScrollBar && hatStyle(Style::VScroll)
  1567. ? -vertikalScrollBar->getScroll()
  1568. : 0);
  1569. y -= daten->rasterHeight)
  1570. {
  1571. for (int i = 0; i < daten->rasterDicke; ++i)
  1572. {
  1573. if (hatDatenStyle(DiagDaten::Style::RasterAlpha))
  1574. zRObj.drawLinieHAlpha(
  1575. 0, (int)(y + i), dgbr - dgrbr * 2, daten->rasterFarbe);
  1576. else
  1577. zRObj.drawLinieH(
  1578. 0, (int)(y + i), dgbr - dgrbr * 2, daten->rasterFarbe);
  1579. }
  1580. }
  1581. }
  1582. if (daten && daten->werte && daten->werte->getEintragAnzahl()
  1583. && daten->hIntervallBreite && daten->vIntervallHeight)
  1584. { // Werte
  1585. int wAnz = daten->werte->getEintragAnzahl();
  1586. for (int i = 0; i < wAnz; ++i)
  1587. {
  1588. DiagWert* wert = daten->werte->z(i);
  1589. if (wert && hatWertStyle(i, DiagWert::Style::Sichtbar)
  1590. && wert->punkte && wert->punkte->getEintragAnzahl())
  1591. {
  1592. int pAnz = wert->punkte->getEintragAnzahl();
  1593. int* rf = new int[pAnz];
  1594. bool* fertig = new bool[pAnz];
  1595. int anz = 0;
  1596. ZeroMemory(fertig, pAnz);
  1597. for (int j = 0; j < pAnz; ++j)
  1598. {
  1599. double min = -1;
  1600. int p = -1;
  1601. for (int pi = 0; pi < pAnz; ++pi)
  1602. {
  1603. if (wert->punkte->hat(pi) && !fertig[pi]
  1604. && (p < 0
  1605. || wert->punkte->get(pi)->hIntervall < min))
  1606. {
  1607. min = wert->punkte->get(pi)->hIntervall;
  1608. p = pi;
  1609. }
  1610. }
  1611. if (p < 0) break;
  1612. rf[anz] = p;
  1613. fertig[p] = 1;
  1614. ++anz;
  1615. }
  1616. delete[] fertig;
  1617. int rpx = horizontalScrollBar && hatStyle(Style::HScroll)
  1618. ? -horizontalScrollBar->getScroll()
  1619. : 0;
  1620. int rpy = vertikalScrollBar && hatStyle(Style::VScroll)
  1621. ? -vertikalScrollBar->getScroll()
  1622. : 0;
  1623. rpy += dgy;
  1624. int dgmhi
  1625. = vertikalScrollBar && hatStyle(Style::VScroll)
  1626. ? dgy + vertikalScrollBar->getScrollData()->max + dgrbr
  1627. : dgy + dghi - dgrbr;
  1628. if (hatWertStyle(i, DiagWert::Style::Hintergrund))
  1629. {
  1630. DiagPunkt* vorher = 0;
  1631. DiagPunkt* jetzt = 0;
  1632. for (int j = 0; j < anz; ++j)
  1633. {
  1634. jetzt = wert->punkte->get(rf[j]);
  1635. if (jetzt && vorher)
  1636. {
  1637. int ax = (int)(rpx
  1638. + vorher->hIntervall
  1639. * daten->hIntervallBreite);
  1640. int ay = (int)(dgmhi
  1641. - vorher->vIntervall
  1642. * daten->vIntervallHeight);
  1643. int bx = (int)(rpx
  1644. + jetzt->hIntervall
  1645. * daten->hIntervallBreite);
  1646. int by = (int)(dgmhi
  1647. - jetzt->vIntervall
  1648. * daten->vIntervallHeight);
  1649. if (ax >= bx)
  1650. {
  1651. vorher = jetzt;
  1652. continue;
  1653. }
  1654. if (!(ax > dgbr - dgrbr || bx < 0
  1655. || (ay > dgy + dghi - dgrbr
  1656. && by > dgy + dghi - dgrbr)))
  1657. {
  1658. double yf = (double)(by - ay) / (bx - ax);
  1659. double y = (double)ay;
  1660. ax = ax < 0 ? 0 : ax;
  1661. bx = bx > dgbr - dgrbr ? dgbr - dgrbr : bx;
  1662. if (hatWertStyle(i, DiagWert::Style::HAlpha))
  1663. {
  1664. for (int x = ax; x < bx; x++, y += yf)
  1665. zRObj.drawLinieVAlpha(x,
  1666. (int)(y + 0.5),
  1667. dgmhi - (int)(y + 0.5),
  1668. wert->hintergrund);
  1669. }
  1670. else
  1671. {
  1672. for (int x = ax; x < bx; x++, y += yf)
  1673. zRObj.drawLinieV(x,
  1674. (int)(y + 0.5),
  1675. dgmhi - (int)(y + 0.5),
  1676. wert->hintergrund);
  1677. }
  1678. if (hatWertStyle(i, DiagWert::Style::Alpha))
  1679. zRObj.drawLinieAlpha(Punkt(ax, ay),
  1680. Punkt(bx, by),
  1681. wert->farbe);
  1682. else
  1683. zRObj.drawLinie(Punkt(ax, ay),
  1684. Punkt(bx, by),
  1685. wert->farbe);
  1686. }
  1687. }
  1688. vorher = jetzt;
  1689. }
  1690. }
  1691. else
  1692. {
  1693. DiagPunkt* vorher = 0;
  1694. DiagPunkt* jetzt = 0;
  1695. for (int j = 0; j < anz; ++j)
  1696. {
  1697. jetzt = wert->punkte->get(rf[j]);
  1698. if (jetzt && vorher)
  1699. {
  1700. if (hatWertStyle(i, DiagWert::Style::Alpha))
  1701. zRObj.drawLinieAlpha(
  1702. Punkt(
  1703. (int)(rpx
  1704. + vorher->hIntervall
  1705. * daten->hIntervallBreite),
  1706. (int)(dgmhi
  1707. - vorher->vIntervall
  1708. * daten->vIntervallHeight)),
  1709. Punkt(
  1710. (int)(rpx
  1711. + jetzt->hIntervall
  1712. * daten->hIntervallBreite),
  1713. (int)(dgmhi
  1714. - jetzt->vIntervall
  1715. * daten->vIntervallHeight)),
  1716. wert->farbe);
  1717. else
  1718. zRObj.drawLinie(
  1719. Punkt(
  1720. (int)(rpx
  1721. + vorher->hIntervall
  1722. * daten->hIntervallBreite),
  1723. (int)(dgmhi
  1724. - vorher->vIntervall
  1725. * daten->vIntervallHeight)),
  1726. Punkt(
  1727. (int)(rpx
  1728. + jetzt->hIntervall
  1729. * daten->hIntervallBreite),
  1730. (int)(dgmhi
  1731. - jetzt->vIntervall
  1732. * daten->vIntervallHeight)),
  1733. wert->farbe);
  1734. }
  1735. vorher = jetzt;
  1736. }
  1737. }
  1738. delete[] rf;
  1739. }
  1740. }
  1741. }
  1742. if (daten && daten->werte && daten->werte->getEintragAnzahl() && textRd
  1743. && schriftGr)
  1744. {
  1745. int wAnz = daten->werte->getEintragAnzahl();
  1746. int rx = 5;
  1747. int ry = 5;
  1748. textRd->setSchriftSize(schriftGr);
  1749. for (int i = 0; i < wAnz; ++i)
  1750. {
  1751. DiagWert* w = daten->werte->z(i);
  1752. if (w && w->name && hatWertStyle(i, DiagWert::Style::Name)
  1753. && hatWertStyle(i, DiagWert::Style::Sichtbar))
  1754. {
  1755. int br = textRd->getTextBreite(w->name->getText());
  1756. zRObj.alphaRegion(rx, ry, br, schriftGr, 0xA0000000);
  1757. textRd->renderText(rx, ry, w->name->getText(), zRObj, w->farbe);
  1758. ry += 15;
  1759. }
  1760. }
  1761. }
  1762. zRObj.releaseDrawOptions();
  1763. zRObj.releaseDrawOptions();
  1764. zRObj.releaseDrawOptions();
  1765. unlockZeichnung();
  1766. }
  1767. // constant
  1768. Schrift* LDiag::getSchrift() const // Gibt die Schrift zurück
  1769. {
  1770. return textRd ? textRd->getSchrift() : 0;
  1771. }
  1772. Schrift* LDiag::zSchrift() const
  1773. {
  1774. return textRd ? textRd->zSchrift() : 0;
  1775. }
  1776. Rahmen* LDiag::getDatenRahmen()
  1777. const // Gibt den inneren Rahmen um das eigentliche Diagramm zurück
  1778. {
  1779. return dRam ? dynamic_cast<Rahmen*>(dRam->getThis()) : 0;
  1780. }
  1781. Rahmen* LDiag::zDatenRahmen() const
  1782. {
  1783. return dRam;
  1784. }
  1785. int LDiag::getDatenRahmenFarbe() const
  1786. {
  1787. return dRam ? dRam->getFarbe() : 0;
  1788. }
  1789. int LDiag::getDatenRahmenBreite() const
  1790. {
  1791. return dRam ? dRam->getRBreite() : 0;
  1792. }
  1793. int LDiag::getDatenHintergrundFarbe()
  1794. const // Gibt den Hintergrund des eigentlichen Diagramms zurück
  1795. {
  1796. return dBgF;
  1797. }
  1798. Bild* LDiag::getDatenHintergrundBild() const
  1799. {
  1800. return dBgB ? dynamic_cast<Bild*>(dBgB->getThis()) : 0;
  1801. }
  1802. Bild* LDiag::zDatenHintergrundBild() const
  1803. {
  1804. return dBgB;
  1805. }
  1806. AlphaFeld* LDiag::getDatenAlphaFeld()
  1807. const // Gibt das AlphaFeld des eigentlichen Diagramms zurück
  1808. {
  1809. return dAf ? dynamic_cast<AlphaFeld*>(dAf->getThis()) : 0;
  1810. }
  1811. AlphaFeld* LDiag::zDatenAlphaFeld() const
  1812. {
  1813. return dAf;
  1814. }
  1815. int LDiag::getDatenAlphaFeldFarbe() const
  1816. {
  1817. return dAf ? dAf->getFarbe() : 0;
  1818. }
  1819. int LDiag::getDatenAlphaFeldStrength() const
  1820. {
  1821. return dAf ? dAf->getStrength() : 0;
  1822. }