Tabelle.cpp 48 KB

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