Schrift.cpp 32 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069
  1. #include "Schrift.h"
  2. #include "Bild.h"
  3. #include "Text.h"
  4. #include "Scroll.h"
  5. #include "Globals.h"
  6. #ifdef WIN32
  7. #include <Windows.h>
  8. #endif
  9. #include "FrameworkMath.h"
  10. using namespace Framework;
  11. // Inhalt der Buchstabe Klasse aus Schrift.h
  12. // Konstruktor
  13. Buchstabe::Buchstabe()
  14. : size( 0, 0 ),
  15. alpha( 0 ),
  16. schriftSize( 0 ),
  17. ref( 1 )
  18. {}
  19. // Destruktor
  20. Buchstabe::~Buchstabe()
  21. {
  22. if( alpha )
  23. delete[]alpha;
  24. }
  25. // nicht constant
  26. void Buchstabe::NeuBuchstabe( Punkt &size ) // Initialisierung
  27. {
  28. this->size = size;
  29. if( alpha )
  30. delete[]alpha;
  31. alpha = new unsigned char[ size.x * size.y ];
  32. ZeroMemory( alpha, size.x * size.y );
  33. }
  34. void Buchstabe::setPixel( Punkt &pos, unsigned char alpha ) // setzt den alphawert des Pixels
  35. {
  36. this->alpha[ pos.x + pos.y * size.x ] = alpha;
  37. }
  38. void Buchstabe::setPixel( int x, int y, unsigned char alpha )
  39. {
  40. this->alpha[ x + y * size.x ] = alpha;
  41. }
  42. void Buchstabe::setPixel( int i, unsigned char alpha )
  43. {
  44. this->alpha[ i ] = alpha;
  45. }
  46. void Buchstabe::setSchriftSize( int sg ) // setzt die Schriftgröße des Buchstaben
  47. {
  48. schriftSize = sg;
  49. }
  50. int Buchstabe::getSchriftSize() const
  51. {
  52. return schriftSize;
  53. }
  54. // constant
  55. const Punkt &Buchstabe::getSize() const // gibt die Buchstabenbildgröße zurück
  56. {
  57. return size;
  58. }
  59. int Buchstabe::getBreite() const // Buchstabenbreite
  60. {
  61. return size.x;
  62. }
  63. int Buchstabe::getHeight() const // Buchstabenhöhe
  64. {
  65. return size.y;
  66. }
  67. unsigned char *Buchstabe::getBuff() const // gibt den Alphabuffer zurück
  68. {
  69. return alpha;
  70. }
  71. // Reference Counting
  72. Buchstabe *Buchstabe::getThis()
  73. {
  74. ++ref;
  75. return this;
  76. }
  77. Buchstabe *Buchstabe::release()
  78. {
  79. --ref;
  80. if( ref == 0 )
  81. delete this;
  82. return 0;
  83. }
  84. // Inhalt der Alphabet Klasse aus Schrift.h
  85. // Konstruktor
  86. Alphabet::Alphabet()
  87. : zeichen( new Buchstabe*[ 256 ] ),
  88. schriftSize( 12 ),
  89. ref( 1 )
  90. {
  91. for( int i = 0; i < 256; ++i )
  92. zeichen[ i ] = 0;
  93. }
  94. // Destruktor
  95. Alphabet::~Alphabet()
  96. {
  97. for( int i = 0; i < 256; ++i )
  98. {
  99. if( zeichen[ i ] )
  100. zeichen[ i ]->release();
  101. }
  102. delete[]zeichen;
  103. }
  104. // nicht constant
  105. void Alphabet::NeuAlphabet() // Initialisierung
  106. {
  107. for( int i = 0; i < 256; ++i )
  108. {
  109. if( zeichen[ i ] )
  110. zeichen[ i ]->release();
  111. }
  112. for( int i = 0; i < 256; ++i )
  113. zeichen[ i ] = 0;
  114. }
  115. void Alphabet::setBuchstabe( unsigned char i, Buchstabe *buchstabe ) // setzt einen Buchstaben
  116. {
  117. if( zeichen[ i ] )
  118. zeichen[ i ]->release();
  119. zeichen[ i ] = buchstabe;
  120. if( zeichen[ i ] )
  121. {
  122. zeichen[ i ]->setSchriftSize( schriftSize );
  123. }
  124. }
  125. void Alphabet::setSchriftSize( int gr ) // setzt die Schriftgröße
  126. {
  127. schriftSize = gr;
  128. for( int i = 0; i < 256; ++i )
  129. {
  130. if( zeichen[ i ] )
  131. zeichen[ i ]->setSchriftSize( gr );
  132. }
  133. }
  134. // constant
  135. Buchstabe *Alphabet::getBuchstabe( unsigned char i ) const // gibt einen Buchstaben zurück
  136. {
  137. if( zeichen[ i ] )
  138. return zeichen[ i ]->getThis();
  139. return 0;
  140. }
  141. Buchstabe *Alphabet::zBuchstabe( unsigned char i ) const
  142. {
  143. return zeichen[ i ];
  144. }
  145. bool Alphabet::hatBuchstabe( unsigned char b ) const
  146. {
  147. return zeichen[ b ] != 0;
  148. }
  149. int Alphabet::getSchriftSize() const // gibt die Schriftgröße zurück
  150. {
  151. return schriftSize;
  152. }
  153. // Reference Counting
  154. Alphabet *Alphabet::getThis()
  155. {
  156. ++ref;
  157. return this;
  158. }
  159. Alphabet *Alphabet::release()
  160. {
  161. --ref;
  162. if( ref == 0 )
  163. delete this;
  164. return 0;
  165. }
  166. // Inhalt der AlphabetArray Klasse aus Schrift.h
  167. // Konstruktor
  168. AlphabetArray::AlphabetArray()
  169. : next( 0 ),
  170. This( 0 )
  171. {}
  172. // Destruktor
  173. AlphabetArray::~AlphabetArray()
  174. {
  175. if( This )
  176. This->release();
  177. delete next;
  178. }
  179. // nicht constant
  180. bool AlphabetArray::addAlphabet( Alphabet *alphabet ) // Fügt ein Alphabet hinzu
  181. {
  182. if( This )
  183. {
  184. if( This->getSchriftSize() == alphabet->getSchriftSize() )
  185. {
  186. alphabet->release();
  187. return false;
  188. }
  189. }
  190. else
  191. {
  192. This = alphabet;
  193. return true;
  194. }
  195. if( !next )
  196. next = new AlphabetArray();
  197. return next->addAlphabet( alphabet );
  198. }
  199. bool AlphabetArray::removeAlphabet( int sg ) // entfernt ein Alphabet
  200. {
  201. if( This )
  202. {
  203. if( This->getSchriftSize() == sg )
  204. This = This->release();
  205. return 1;
  206. }
  207. if( !next )
  208. return 0;
  209. if( next->removeAlphabet( sg ) )
  210. {
  211. AlphabetArray *tmp = next->getNext();
  212. next->setNext0();
  213. delete next;
  214. next = tmp;
  215. }
  216. return 0;
  217. }
  218. void AlphabetArray::setNext0() // setzt den next Zeiger zu 0
  219. {
  220. next = 0;
  221. }
  222. // constant
  223. Alphabet *AlphabetArray::getAlphabet( unsigned char sg ) const // gibt getThis von einem Alphabet zurück
  224. {
  225. if( !This )
  226. return 0;
  227. if( This->getSchriftSize() == sg )
  228. return This->getThis();
  229. if( next )
  230. return next->getAlphabet( sg );
  231. return 0;
  232. }
  233. Alphabet *AlphabetArray::zAlphabet( unsigned char sg ) const // gibt ein Alphabet zurück
  234. {
  235. if( !This )
  236. return 0;
  237. if( This->getSchriftSize() == sg )
  238. return This;
  239. if( next )
  240. return next->zAlphabet( sg );
  241. return 0;
  242. }
  243. Alphabet *AlphabetArray::getAlphabetI( int index, int count ) const
  244. {
  245. if( count == index )
  246. return This->getThis();
  247. if( next )
  248. return next->getAlphabetI( index, count + 1 );
  249. return 0;
  250. }
  251. Alphabet *AlphabetArray::zAlphabetI( int index, int count ) const
  252. {
  253. if( count == index )
  254. return This;
  255. if( next )
  256. return next->zAlphabetI( index, count + 1 );
  257. return 0;
  258. }
  259. AlphabetArray *AlphabetArray::getNext() const // gibt das nächste Alphabet zurück
  260. {
  261. return next;
  262. }
  263. // Inhalt der Schrift Klasse aus Schrift.h
  264. // Konstruktor
  265. Schrift::Schrift()
  266. : alphabetAnzahl( 0 ),
  267. alphabet( new AlphabetArray() ),
  268. ref( 1 )
  269. {}
  270. // Destruktor
  271. Schrift::~Schrift()
  272. {
  273. delete alphabet;
  274. }
  275. bool Schrift::addAlphabet( Alphabet *alphabet ) // Fügt der Schrift ein Alphabet hinzu
  276. {
  277. if( this->alphabet->addAlphabet( alphabet ) )
  278. {
  279. ++alphabetAnzahl;
  280. return true;
  281. }
  282. return false;
  283. }
  284. void Schrift::removeAlphabet( int sg ) // Entfernt ein Alphabet
  285. {
  286. if( alphabet->removeAlphabet( sg ) )
  287. --alphabetAnzahl;
  288. }
  289. // constant
  290. Alphabet *Schrift::getAlphabet( int sg ) const
  291. {
  292. Alphabet *drawAlphabet = alphabet->zAlphabet( (unsigned char)sg );
  293. if( !drawAlphabet )
  294. {
  295. for( int i = 0; i < 256; ++i )
  296. {
  297. drawAlphabet = alphabet->zAlphabet( (unsigned char)( sg - i ) );
  298. if( drawAlphabet )
  299. break;
  300. drawAlphabet = alphabet->zAlphabet( (unsigned char)( sg + i ) );
  301. if( drawAlphabet )
  302. break;
  303. }
  304. }
  305. return drawAlphabet->getThis();
  306. }
  307. Alphabet *Schrift::zAlphabet( int sg ) const
  308. {
  309. Alphabet *drawAlphabet = alphabet->zAlphabet( (unsigned char)sg );
  310. if( !drawAlphabet )
  311. {
  312. for( int i = 0; i < 256; ++i )
  313. {
  314. drawAlphabet = alphabet->zAlphabet( (unsigned char)( sg - i ) );
  315. if( drawAlphabet )
  316. break;
  317. drawAlphabet = alphabet->zAlphabet( (unsigned char)( sg + i ) );
  318. if( drawAlphabet )
  319. break;
  320. }
  321. }
  322. return drawAlphabet;
  323. }
  324. Alphabet *Schrift::getAlphabetI( int index ) const
  325. {
  326. return alphabet->getAlphabetI( index, 0 );
  327. }
  328. Alphabet *Schrift::zAlphabetI( int index ) const
  329. {
  330. return alphabet->zAlphabetI( index, 0 );
  331. }
  332. unsigned char Schrift::getAlphabetAnzahl() const // gibt die anzahl von in der Schrift enthaltenen Alphabeten zurück
  333. {
  334. return alphabetAnzahl;
  335. }
  336. // Reference Counting
  337. Schrift *Schrift::getThis()
  338. {
  339. ++ref;
  340. return this;
  341. }
  342. Schrift *Schrift::release()
  343. {
  344. --ref;
  345. if( ref == 0 )
  346. delete this;
  347. return 0;
  348. }
  349. TextRenderer::TextRenderer()
  350. : TextRenderer( 0 )
  351. {}
  352. TextRenderer::TextRenderer( Schrift *schrift )
  353. {
  354. s = schrift;
  355. schriftSize = 12;
  356. zeilenAbstand = 5;
  357. zeichenAbstand = 0;
  358. ref = 1;
  359. }
  360. TextRenderer::~TextRenderer()
  361. {
  362. s->release();
  363. }
  364. void TextRenderer::setSchriftZ( Schrift *schrift )
  365. {
  366. if( s )
  367. s->release();
  368. s = schrift;
  369. }
  370. Schrift *TextRenderer::getSchrift()
  371. {
  372. if( s )
  373. return s->getThis();
  374. return 0;
  375. }
  376. Schrift *TextRenderer::zSchrift()
  377. {
  378. return s;
  379. }
  380. // Setzt die Schriftgröße, in der gezeichnet werden soll. Die Schrift wählt automatisch das passende Alphabet zum Zeichnen
  381. // sg: Die Schriftgröße
  382. void TextRenderer::setSchriftSize( int sg )
  383. {
  384. schriftSize = sg;
  385. }
  386. // Setzt den Zeilenabstand, der zum zeichnen verwendet werden soll
  387. // za: Der Zeilenabstand zum unteren Ende der darüber liegenden zeile in Pixeln
  388. void TextRenderer::setZeilenAbstand( int za )
  389. {
  390. zeilenAbstand = za;
  391. }
  392. // Setzt den Zeichenabstand, der zum zeichnen verwendet werden soll
  393. // za: Der Zeichenabstand zum unteren Ende der darüber liegenden zeile in Pixeln
  394. void TextRenderer::setZeichenAbstand( int za )
  395. {
  396. zeichenAbstand = za;
  397. }
  398. // Fügt Zeilenumbrüche in den Text ein, so dass er bei einer vorgegebenen Breite follständig angezeigt wird
  399. // zText: Der text, in den die Zeilenumbrüche eingefügt werden sollen
  400. // maxBreite: Die Breite in Pixeln auf der der Text follständig angezeigt werden soll
  401. void TextRenderer::textFormatieren( Text *zTxt, int maxBreite )
  402. {
  403. int lastPos = -1;
  404. int x = 0;
  405. const char *txt = zTxt->getText();
  406. Text result = txt;
  407. int len = zTxt->getLength();
  408. for( int i = 0; txt[ i ]; ++i )
  409. {
  410. if( txt[ i ] == ' ' )
  411. {
  412. lastPos = i;
  413. x += schriftSize / 2 + zeichenAbstand;
  414. continue;
  415. }
  416. if( txt[ i ] == '\t' )
  417. {
  418. lastPos = i;
  419. x += schriftSize + zeichenAbstand;
  420. continue;
  421. }
  422. if( txt[ i ] == '\n' )
  423. {
  424. x = 0;
  425. lastPos = -1;
  426. continue;
  427. }
  428. if( txt[ i ] == '\r' && len - i >= 11 )
  429. {
  430. i += 10;
  431. continue;
  432. }
  433. x += getCharWidth( txt[ i ] ) + zeichenAbstand;
  434. if( x > maxBreite && lastPos > -1 )
  435. {
  436. result.ersetzen( lastPos, lastPos + 1, "\n" );
  437. x = 0;
  438. i = lastPos;
  439. lastPos = -1;
  440. }
  441. }
  442. zTxt->setText( result );
  443. }
  444. // Zeichnet einen Bestimmten Text mit Cursor und einfärbung auf ein Bild
  445. // Nutze (setPosition) und (setDrawSchriftGröße) um die Position und die Größe zu verändern
  446. // x: x position des ersten zeichens
  447. // y: y position des ersten zeichens
  448. // txt: Der Text, der gezeichnet werden soll
  449. // zRObj: Das Bild, auf das gezeichnet werden soll
  450. // cpos: Die position des Cursors im Text
  451. // cf: Die Farbe des Cursors
  452. // fbeg: Die Position des Zeichens im Text, wo die Einfärbung beginnen soll. Der Text wird von dort bis zur Cursorposition eingefärbt
  453. // ff: Die Hintergrund Farbe des eingefärbten Textes
  454. // f: Eine Funktion die für jeden Buchstaben aufgerufen wird und seine Farbe zurückgibt
  455. void TextRenderer::renderText( int x, int y, const char *txt, Bild &zRObj, std::function< int( int, int, int ) > f, int cpos, int cf, int fbeg, int ff )
  456. {
  457. if( !s )
  458. return;
  459. if( fbeg == -1 )
  460. fbeg = cpos;
  461. int zRObjBr = zRObj.getBreite();
  462. int zRObjHi = zRObj.getHeight();
  463. int beginX = x;
  464. int zh = getZeilenHeight();
  465. if( y + ( zh + zeilenAbstand ) * Text( txt ).anzahlVon( '\n' ) + zh < 0 || x >= zRObjBr || y >= zRObjHi )
  466. return;
  467. bool faerb = 0;
  468. for( int i = 0; txt[ i ]; ++i )
  469. {
  470. if( i == fbeg )
  471. faerb = !faerb;
  472. if( i == cpos )
  473. {
  474. zRObj.drawLinieVAlpha( x, y, zh, cf );
  475. faerb = !faerb;
  476. }
  477. if( txt[ i ] == ' ' )
  478. {
  479. if( faerb )
  480. zRObj.alphaRegion( x, y, schriftSize / 2 + zeichenAbstand, zh, ff );
  481. x += schriftSize / 2 + zeichenAbstand;
  482. continue;
  483. }
  484. if( txt[ i ] == '\t' )
  485. {
  486. if( faerb )
  487. zRObj.alphaRegion( x, y, schriftSize + zeichenAbstand, zh, ff );
  488. x += schriftSize + zeichenAbstand;
  489. continue;
  490. }
  491. if( txt[ i ] == '\n' )
  492. {
  493. y += zh + zeilenAbstand;
  494. x = beginX;
  495. continue;
  496. }
  497. if( txt[ i ] == '\r' && textLength( txt ) - i >= 11 )
  498. {
  499. i += 3;
  500. Text *hex1 = Text( txt ).getTeilText( i, i + 6 );
  501. Text *hex2 = Text( txt ).getTeilText( i + 6, i + 8 );
  502. int nf = ( TextZuInt( hex1->getText(), 16 ) << 8 ) |
  503. ( TextZuInt( hex2->getText(), 16 ) );
  504. f = [ nf ]( int a, int b, int c )
  505. {
  506. return nf;
  507. };
  508. hex1->release();
  509. hex2->release();
  510. i += 7;
  511. continue;
  512. }
  513. renderChar( x, y, txt[ i ], zRObj, faerb, ff, f( x, y, i ) );
  514. }
  515. if( textLength( txt ) == cpos )
  516. zRObj.drawLinieVAlpha( x, y, zh, cf );
  517. }
  518. // Zeichnet einen Bestimmten Text mit Cursor und einfärbung auf ein Bild
  519. // Nutze (setPosition) und (setDrawSchriftGröße) um die Position und die Größe zu verändern
  520. // x: x position des ersten zeichens
  521. // y: y position des ersten zeichens
  522. // txt: Der Text, der gezeichnet werden soll
  523. // zRObj: Das Bild, auf das gezeichnet werden soll
  524. // cpos: Die position des Cursors im Text
  525. // cf: Die Farbe des Cursors
  526. // fbeg: Die Position des Zeichens im Text, wo die Einfärbung beginnen soll. Der Text wird von dort bis zur Cursorposition eingefärbt
  527. // ff: Die Hintergrund Farbe des eingefärbten Textes
  528. // f: Die Farbe, in der der Text gezeichnet werden soll
  529. void TextRenderer::renderText( int x, int y, const char *txt, Bild &zRObj, int f, int cpos, int cf, int fbeg, int ff )
  530. {
  531. return renderText( x, y, txt, zRObj, [ f ]( int a, int b, int c ) { return f; }, cpos, cf, fbeg, ff );
  532. }
  533. // Zeichnet einen Bestimmten Buchstaben mit einfärbung auf ein Bild
  534. // Nutze (setPosition) und (setDrawSchriftGröße) um die Position und die Größe zu verändern
  535. // x: x position des ersten zeichens
  536. // y: y position des ersten zeichens
  537. // txt: Der Text, der gezeichnet werden soll
  538. // zRObj: Das Bild, auf das gezeichnet werden soll
  539. // selected: 1, falls das zeichen eingefärbt sein soll
  540. // ff: Die Hintergrund Farbe des eingefärbten Textes
  541. // f: Die Farbe, in der der Text gezeichnet werden soll
  542. void TextRenderer::renderChar( int &x, int y, char c, Bild &zRObj, bool selected, int ff, int f )
  543. {
  544. if( !s )
  545. return;
  546. Alphabet *a = s->zAlphabet( schriftSize );
  547. if( !a )
  548. return;
  549. Buchstabe *b = a->zBuchstabe( c );
  550. if( b )
  551. {
  552. if( x >= zRObj.getBreite() )
  553. return;
  554. if( zRObj.isAreaDrawable( x, y, getCharWidth( c ), getCharHeight( c ) ) )
  555. {
  556. if( selected )
  557. {
  558. int br = getCharWidth( c ) + zeichenAbstand;
  559. zRObj.alphaRegion( x, y, br, getZeilenHeight(), ff );
  560. }
  561. if( b->getBuff() )
  562. {
  563. const Punkt &zRObjGr = zRObj.getDrawGr();
  564. const Punkt &zRObjPos = zRObj.getDrawPos();
  565. const Punkt &zRObjOff = zRObj.getDrawOff();
  566. int xp = x + zRObjOff.x, yp = y + zRObjOff.y;
  567. int xs = xp < zRObjPos.x ? ( zRObjPos.x - xp ) : 0, ys = yp < zRObjPos.y ? ( zRObjPos.y - yp ) : 0;
  568. int br = b->getBreite(), h = b->getHeight();
  569. unsigned char a2 = (unsigned char)( 255 - ( f >> 24 ) );
  570. f &= 0x00FFFFFF;
  571. if( schriftSize == b->getSchriftSize() )
  572. {
  573. if( xp >= zRObjGr.x || yp >= zRObjGr.y || xp + br < zRObjPos.x || yp + h < zRObjPos.y )
  574. return;
  575. br = ( xp + br ) > zRObjGr.x ? ( zRObjGr.x - xp ) : br;
  576. h = ( yp + h ) > zRObjGr.y ? ( zRObjGr.y - yp ) : h;
  577. if( !a2 )
  578. {
  579. int xx, ygr = ( ys - 1 ) * b->getBreite(), ygr2 = ( yp + ys - 1 ) * zRObj.getBreite();
  580. if( zRObj.hasAlpha3D() )
  581. {
  582. for( int yy = ys; yy < h; ++yy )
  583. {
  584. ygr += b->getBreite();
  585. ygr2 += zRObj.getBreite();
  586. for( xx = xs; xx < br; ++xx )
  587. zRObj.alphaPixel3D( xp + xx + ygr2, f | ( b->getBuff()[ xx + ygr ] << 24 ) );
  588. }
  589. }
  590. else
  591. {
  592. for( int yy = ys; yy < h; ++yy )
  593. {
  594. ygr += b->getBreite();
  595. ygr2 += zRObj.getBreite();
  596. for( xx = xs; xx < br; ++xx )
  597. zRObj.alphaPixel2D( xp + xx + ygr2, f | ( b->getBuff()[ xx + ygr ] << 24 ) );
  598. }
  599. }
  600. }
  601. else
  602. {
  603. int a;
  604. int xx, ygr = ( ys - 1 ) * b->getBreite(), ygr2 = ( yp + ys - 1 ) * zRObj.getBreite();
  605. if( zRObj.hasAlpha3D() )
  606. {
  607. for( int yy = ys; yy < h; ++yy )
  608. {
  609. ygr += b->getBreite();
  610. ygr2 += zRObj.getBreite();
  611. for( xx = xs; xx < br; ++xx )
  612. {
  613. a = b->getBuff()[ xx + ygr ] - a2;
  614. if( a > 0 )
  615. zRObj.alphaPixel3D( xp + xx + ygr2, f | ( a << 24 ) );
  616. }
  617. }
  618. }
  619. else
  620. {
  621. for( int yy = ys; yy < h; ++yy )
  622. {
  623. ygr += b->getBreite();
  624. ygr2 += zRObj.getBreite();
  625. for( xx = xs; xx < br; ++xx )
  626. {
  627. a = b->getBuff()[ xx + ygr ] - a2;
  628. if( a > 0 )
  629. zRObj.alphaPixel2D( xp + xx + ygr2, f | ( a << 24 ) );
  630. }
  631. }
  632. }
  633. }
  634. }
  635. else
  636. {
  637. double xoff = (double)b->getSchriftSize() / (double)schriftSize,
  638. yoff = (double)b->getSchriftSize() / (double)schriftSize;
  639. double x = xs * xoff, y = ys * yoff;
  640. int maxX = getCharWidth( c ), maxY = getCharHeight( c );
  641. maxX = ( xp + maxX ) >= zRObjGr.x ? ( zRObjGr.x - xp ) : maxX;
  642. maxY = ( yp + maxY ) >= zRObjGr.y ? ( zRObjGr.y - yp ) : maxY;
  643. if( !a2 )
  644. {
  645. int dx, ygr, ygr2;
  646. if( zRObj.hasAlpha3D() )
  647. {
  648. for( int dy = ys; dy < maxY; ++dy )
  649. {
  650. ygr2 = ( yp + dy ) * zRObj.getBreite();
  651. ygr = (int)y * br;
  652. for( dx = xs; dx < maxX; ++dx )
  653. {
  654. zRObj.alphaPixel3D( xp + dx + ygr2, f | ( b->getBuff()[ (int)x + ygr ] << 24 ) );
  655. x += xoff;
  656. }
  657. x = xs;
  658. y += yoff;
  659. }
  660. }
  661. else
  662. {
  663. for( int dy = ys; dy < maxY; ++dy )
  664. {
  665. ygr2 = ( yp + dy ) * zRObj.getBreite();
  666. ygr = (int)y * br;
  667. for( dx = xs; dx < maxX; ++dx )
  668. {
  669. zRObj.alphaPixel2D( xp + dx + ygr2, f | ( b->getBuff()[ (int)x + ygr ] << 24 ) );
  670. x += xoff;
  671. }
  672. x = xs;
  673. y += yoff;
  674. }
  675. }
  676. }
  677. else
  678. {
  679. int a, dx, ygr, ygr2;
  680. if( zRObj.hasAlpha3D() )
  681. {
  682. for( int dy = ys; dy < maxY; ++dy )
  683. {
  684. ygr2 = ( yp + dy ) * zRObj.getBreite();
  685. ygr = (int)y * br;
  686. for( dx = xs; dx < maxX; ++dx )
  687. {
  688. a = b->getBuff()[ (int)x + ygr ] - a2;
  689. zRObj.alphaPixel3D( xp + dx + ygr2, f | ( a << 24 ) );
  690. x += xoff;
  691. }
  692. x = xs;
  693. y += yoff;
  694. }
  695. }
  696. else
  697. {
  698. for( int dy = ys; dy < maxY; ++dy )
  699. {
  700. ygr2 = ( yp + dy ) * zRObj.getBreite();
  701. ygr = (int)y * br;
  702. for( dx = xs; dx < maxX; ++dx )
  703. {
  704. a = b->getBuff()[ (int)x + ygr ] - a2;
  705. zRObj.alphaPixel2D( xp + dx + ygr2, f | ( a << 24 ) );
  706. x += xoff;
  707. }
  708. x = xs;
  709. y += yoff;
  710. }
  711. }
  712. }
  713. }
  714. }
  715. }
  716. x += getCharWidth( c ) + zeichenAbstand;
  717. }
  718. }
  719. // Gibt die Schriftgröße zurück, die zum Zeichnen verwendet wird
  720. int TextRenderer::getSchriftSize() const
  721. {
  722. return schriftSize;
  723. }
  724. // Gibt den Abstand in Pixeln zum unteren Ende der darüber ligenden Zeile zurück
  725. int TextRenderer::getZeilenabstand() const
  726. {
  727. return zeilenAbstand;
  728. }
  729. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Text vollständig darzustellen
  730. // txt: Der Text, von dem die Breite in Pixeln ermitelt werden soll
  731. int TextRenderer::getTextBreite( const char *txt ) const
  732. {
  733. int ret = 0;
  734. int tmp = 0;
  735. for( int i = 0; txt[ i ]; ++i )
  736. {
  737. if( txt[ i ] == '\n' )
  738. {
  739. if( tmp > ret )
  740. ret = tmp;
  741. tmp = 0;
  742. }
  743. else if( txt[ i ] == '\r' )
  744. {
  745. i += 10;
  746. continue;
  747. }
  748. else if( txt[ i ] == '\t' )
  749. tmp += schriftSize + zeichenAbstand;
  750. else if( txt[ i ] == ' ' )
  751. tmp += schriftSize / 2 + zeichenAbstand;
  752. else
  753. tmp += getCharWidth( txt[ i ] ) + zeichenAbstand;
  754. }
  755. if( tmp > ret )
  756. ret = tmp;
  757. return ret;
  758. }
  759. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Text vollständig darzustellen
  760. // txt: Der Text, von dem die Höhe in Pixeln ermitelt werden soll
  761. int TextRenderer::getTextHeight( const char *txt ) const
  762. {
  763. int hi = getZeilenHeight();
  764. return hi + ( ( hi + zeilenAbstand ) * Text( txt ).anzahlVon( '\n' ) );
  765. }
  766. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Buchstaben vollständig darzustellen
  767. // c: Der Buchstabe, von dem die Breite in Pixeln ermitelt werden soll
  768. int TextRenderer::getCharWidth( const char c ) const
  769. {
  770. if( !s )
  771. return 0;
  772. Alphabet *a = s->zAlphabet( schriftSize );
  773. if( !a )
  774. return 0;
  775. Buchstabe *b = a->zBuchstabe( c );
  776. if( b )
  777. return (int)( ( (double)b->getBreite() / (double)b->getSchriftSize() ) * (double)schriftSize + 0.5 );
  778. return 0;
  779. }
  780. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Text vollständig darzustellen
  781. // c: Der Buchstabe, von dem die Höhe in Pixeln ermitelt werden soll
  782. int TextRenderer::getCharHeight( const char c ) const
  783. {
  784. if( !s )
  785. return 0;
  786. Alphabet *a = s->zAlphabet( schriftSize );
  787. if( !a )
  788. return 0;
  789. Buchstabe *b = a->zBuchstabe( c );
  790. if( b )
  791. return (int)( ( (double)b->getHeight() / (double)b->getSchriftSize() ) * (double)schriftSize + 0.5 );
  792. return 0;
  793. }
  794. // Gibt den Abstand in Pixeln zum unteren Ende der darüber ligenden Zeile zurück
  795. int TextRenderer::getZeilenAbstand() const
  796. {
  797. return zeilenAbstand;
  798. }
  799. // Gibt die skallierte Höhe zurück, die eine gezeichnete Zeile in Pixeln benötigt
  800. int TextRenderer::getZeilenHeight() const
  801. {
  802. int zh = 0;
  803. for( int i = 0; i < 256; ++i )
  804. {
  805. zh = maxInt( getCharHeight( (char)i ), zh );
  806. }
  807. return zh;
  808. }
  809. // Ermittelt das Zeichen im Text, auf das die Maus zeigt
  810. // txt: Der Text, auf den die Maus Zeigt
  811. // mausX: Die X Position der Maus in Pixeln Relativ zur Position des ersten Zeichens
  812. // mausY: Die Y Position der Maus in Pixeln Relativ zur Position des ersten Zeichens
  813. int TextRenderer::textPos( const char *txt, int mausX, int mausY ) const
  814. {
  815. int tx = 0;
  816. int ty = 0;
  817. int sh = getZeilenHeight();
  818. if( mausX < 0 || mausY < 0 )
  819. return -1;
  820. for( int i = 0; i < txt[ i ]; ++i )
  821. {
  822. if( txt[ i ] == '\n' )
  823. {
  824. ty += sh + zeilenAbstand;
  825. tx = 0;
  826. if( mausY < ty )
  827. return i;
  828. }
  829. if( txt[ i ] == '\t' )
  830. tx += schriftSize + zeichenAbstand;
  831. if( txt[ i ] == ' ' )
  832. tx += schriftSize / 2 + zeichenAbstand;
  833. tx += getCharWidth( txt[ i ] );
  834. int txpl = getCharWidth( txt[ i + 1 ] ) / 2;
  835. if( mausX < tx - txpl && mausY < ty + sh + zeilenAbstand )
  836. return i;
  837. }
  838. if( mausY < ty + sh + zeilenAbstand )
  839. return textLength( txt );
  840. return -1;
  841. }
  842. TextRenderer *TextRenderer::getThis()
  843. {
  844. ref++;
  845. return this;
  846. }
  847. TextRenderer *TextRenderer::release()
  848. {
  849. if( !--ref )
  850. delete this;
  851. return 0;
  852. }
  853. GravurTextRenderer::GravurTextRenderer()
  854. : GravurTextRenderer( 0 )
  855. {}
  856. GravurTextRenderer::GravurTextRenderer( Schrift *schrift )
  857. : TextRenderer( schrift )
  858. {}
  859. GravurTextRenderer::~GravurTextRenderer()
  860. {}
  861. // Zeichnet einen Bestimmten Buchstaben mit einfärbung auf ein Bild
  862. // Nutze (setPosition) und (setDrawSchriftGröße) um die Position und die Größe zu verändern
  863. // x: x position des ersten zeichens
  864. // y: y position des ersten zeichens
  865. // txt: Der Text, der gezeichnet werden soll
  866. // zRObj: Das Bild, auf das gezeichnet werden soll
  867. // selected: 1, falls das zeichen eingefärbt sein soll
  868. // ff: Die Hintergrund Farbe des eingefärbten Textes
  869. // f: Die Farbe, in der der Text gezeichnet werden soll
  870. void GravurTextRenderer::renderChar( int &x, int y, char c, Bild &zRObj, bool selected, int ff, int f )
  871. {
  872. if( !s )
  873. return;
  874. Alphabet *a = s->zAlphabet( schriftSize );
  875. Buchstabe *b = a->zBuchstabe( c );
  876. if( b )
  877. {
  878. if( x >= zRObj.getBreite() )
  879. return;
  880. if( zRObj.isAreaDrawable( x, y, getCharWidth( c ), getCharHeight( c ) ) )
  881. {
  882. if( selected )
  883. {
  884. int br = getCharWidth( c ) + zeichenAbstand;
  885. zRObj.alphaRegion( x, y, br, getZeilenHeight(), ff );
  886. }
  887. if( b->getBuff() )
  888. {
  889. const Punkt &zRObjGr = zRObj.getDrawGr();
  890. const Punkt &zRObjPos = zRObj.getDrawPos();
  891. const Punkt &zRObjOff = zRObj.getDrawOff();
  892. int xp = x + zRObjOff.x, yp = y + zRObjOff.y;
  893. int xs = xp < zRObjPos.x ? ( zRObjPos.x - xp ) : 0, ys = yp < zRObjPos.y ? ( zRObjPos.y - yp ) : 0;
  894. int br = b->getBreite(), h = b->getHeight();
  895. f &= 0x00FFFFFF;
  896. double xoff = (double)b->getSchriftSize() / ( schriftSize * 2.0 ),
  897. yoff = (double)b->getSchriftSize() / ( schriftSize * 2.0 );
  898. double x = xs * xoff, y = ys * yoff;
  899. int maxX = getCharWidth( c ), maxY = getCharHeight( c );
  900. maxX = ( xp + maxX ) >= zRObjGr.x ? ( zRObjGr.x - xp ) : maxX;
  901. maxY = ( yp + maxY ) >= zRObjGr.y ? ( zRObjGr.y - yp ) : maxY;
  902. int dx, ygr, ygr2;
  903. if( zRObj.hasAlpha3D() )
  904. {
  905. for( int dy = ys; dy < maxY; ++dy )
  906. {
  907. ygr2 = ( yp + dy ) * zRObj.getBreite();
  908. ygr = (int)y * br;
  909. for( dx = xs; dx < maxX; ++dx )
  910. {
  911. int f = 0;
  912. if( b->getBuff()[ (int)x + ygr ] )
  913. f = 0x20000000;
  914. else if( ( (int)( x + xoff ) < br && b->getBuff()[ (int)( x + xoff ) + ygr ] ) || ( (int)( y - yoff ) < h && b->getBuff()[ (int)x + (int)( y - yoff ) * br ] > 0xF0 ) )
  915. f = 0x70000000;
  916. else if( ( (int)( x - xoff ) < br && b->getBuff()[ (int)( x - xoff ) + ygr ] ) || ( (int)( y + yoff ) < h && b->getBuff()[ (int)x + (int)( y + yoff ) * br ] > 0xF0 ) )
  917. {
  918. f = 0x70FFFFFF;
  919. }
  920. zRObj.alphaPixel3D( xp + dx + ygr2, f );
  921. x += xoff;
  922. }
  923. x = xs;
  924. y += yoff;
  925. }
  926. }
  927. else
  928. {
  929. for( int dy = ys; dy < maxY; ++dy )
  930. {
  931. ygr2 = ( yp + dy ) * zRObj.getBreite();
  932. ygr = (int)y * br;
  933. for( dx = xs; dx < maxX; ++dx )
  934. {
  935. int f = 0;
  936. if( b->getBuff()[ (int)x + ygr ] )
  937. f = 0x20000000;
  938. else if( ( (int)( x + xoff ) < br && b->getBuff()[ (int)( x + xoff ) + ygr ] ) || ( (int)( y - yoff ) < h && b->getBuff()[ (int)x + (int)( y - yoff ) * br ] > 0xF0 ) )
  939. f = 0x70000000;
  940. else if( ( (int)( x - xoff ) < br && b->getBuff()[ (int)( x - xoff ) + ygr ] ) || ( (int)( y + yoff ) < h && b->getBuff()[ (int)x + (int)( y + yoff ) * br ] > 0xF0 ) )
  941. {
  942. f = 0x70FFFFFF;
  943. }
  944. zRObj.alphaPixel2D( xp + dx + ygr2, f );
  945. x += xoff;
  946. }
  947. x = xs;
  948. y += yoff;
  949. }
  950. }
  951. }
  952. }
  953. x += getCharWidth( c ) + zeichenAbstand;
  954. }
  955. }
  956. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Buchstaben vollständig darzustellen
  957. // c: Der Buchstabe, von dem die Breite in Pixeln ermitelt werden soll
  958. int GravurTextRenderer::getCharWidth( const char c ) const
  959. {
  960. if( !s )
  961. return 0;
  962. Alphabet *a = s->zAlphabet( schriftSize );
  963. Buchstabe *b = a->zBuchstabe( c );
  964. if( b )
  965. return (int)( ( (double)b->getBreite() / (double)b->getSchriftSize() ) * (double)schriftSize * 2 + 0.5 );
  966. return 0;
  967. }
  968. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Text vollständig darzustellen
  969. // c: Der Buchstabe, von dem die Höhe in Pixeln ermitelt werden soll
  970. int GravurTextRenderer::getCharHeight( const char c ) const
  971. {
  972. if( !s )
  973. return 0;
  974. Alphabet *a = s->zAlphabet( schriftSize );
  975. Buchstabe *b = a->zBuchstabe( c );
  976. if( b )
  977. return (int)( ( (double)b->getHeight() / (double)b->getSchriftSize() ) * (double)schriftSize * 2 + 0.5 );
  978. return 0;
  979. }
  980. // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
  981. // return: 0.
  982. TextRenderer *GravurTextRenderer::release()
  983. {
  984. if( !--ref )
  985. delete this;
  986. return 0;
  987. }