Diagramm.cpp 58 KB

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