Diagramm.cpp 60 KB

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