Diagramm.cpp 58 KB

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