Tabelle.cpp 49 KB

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