Schrift.cpp 36 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123
  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. if( s )
  363. s->release();
  364. }
  365. void TextRenderer::setSchriftZ( Schrift * schrift )
  366. {
  367. if( s )
  368. s->release();
  369. s = schrift;
  370. }
  371. Schrift *TextRenderer::getSchrift()
  372. {
  373. if( s )
  374. return s->getThis();
  375. return 0;
  376. }
  377. Schrift *TextRenderer::zSchrift()
  378. {
  379. return s;
  380. }
  381. // Setzt die Schriftgröße, in der gezeichnet werden soll. Die Schrift wählt automatisch das passende Alphabet zum Zeichnen
  382. // sg: Die Schriftgröße
  383. void TextRenderer::setSchriftSize( int sg )
  384. {
  385. schriftSize = sg;
  386. }
  387. // Setzt den Zeilenabstand, der zum zeichnen verwendet werden soll
  388. // za: Der Zeilenabstand zum unteren Ende der darüber liegenden zeile in Pixeln
  389. void TextRenderer::setZeilenAbstand( int za )
  390. {
  391. zeilenAbstand = za;
  392. }
  393. // Setzt den Zeichenabstand, der zum zeichnen verwendet werden soll
  394. // za: Der Zeichenabstand zum unteren Ende der darüber liegenden zeile in Pixeln
  395. void TextRenderer::setZeichenAbstand( int za )
  396. {
  397. zeichenAbstand = za;
  398. }
  399. // Fügt Zeilenumbrüche in den Text ein, so dass er bei einer vorgegebenen Breite follständig angezeigt wird
  400. // zText: Der text, in den die Zeilenumbrüche eingefügt werden sollen
  401. // maxBreite: Die Breite in Pixeln auf der der Text follständig angezeigt werden soll
  402. void TextRenderer::textFormatieren( Text * zTxt, int maxBreite )
  403. {
  404. int lastPos = -1;
  405. int x = 0;
  406. const char *txt = zTxt->getText();
  407. Text result = txt;
  408. int len = zTxt->getLength();
  409. for( int i = 0; i < len; ++i )
  410. {
  411. if( txt[ i ] == ' ' )
  412. {
  413. lastPos = i;
  414. x += schriftSize / 2 + zeichenAbstand;
  415. continue;
  416. }
  417. if( txt[ i ] == '\t' )
  418. {
  419. lastPos = i;
  420. x += schriftSize + zeichenAbstand;
  421. continue;
  422. }
  423. if( txt[ i ] == '\n' )
  424. {
  425. x = 0;
  426. lastPos = -1;
  427. continue;
  428. }
  429. x += getCharWidth( txt[ i ] ) + zeichenAbstand;
  430. if( x > maxBreite && lastPos > -1 )
  431. {
  432. result.ersetzen( lastPos, lastPos + 1, "\n" );
  433. x = 0;
  434. i = lastPos;
  435. lastPos = -1;
  436. }
  437. }
  438. zTxt->setText( result );
  439. }
  440. // Zeichnet einen Bestimmten Text mit Cursor und einfärbung auf ein Bild
  441. // Nutze (setPosition) und (setDrawSchriftGröße) um die Position und die Größe zu verändern
  442. // x: x position des ersten zeichens
  443. // y: y position des ersten zeichens
  444. // txt: Der Text, der gezeichnet werden soll
  445. // zRObj: Das Bild, auf das gezeichnet werden soll
  446. // cpos: Die position des Cursors im Text
  447. // cf: Die Farbe des Cursors
  448. // fbeg: Die Position des Zeichens im Text, wo die Einfärbung beginnen soll. Der Text wird von dort bis zur Cursorposition eingefärbt
  449. // ff: Die Hintergrund Farbe des eingefärbten Textes
  450. // f: Eine Funktion die für jeden Buchstaben aufgerufen wird und seine Farbe zurückgibt
  451. 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 )
  452. {
  453. if( !s )
  454. return;
  455. if( fbeg == -1 )
  456. fbeg = cpos;
  457. int zRObjBr = zRObj.getBreite();
  458. int zRObjHi = zRObj.getHeight();
  459. const Punkt &zRObjOff = zRObj.getDrawOff();
  460. int beginX = x;
  461. int zh = getZeilenHeight();
  462. if( y + ( zh + zeilenAbstand ) * Text( txt ).anzahlVon( '\n' ) + zh + zRObjOff.y < 0 || x + zRObjOff.x >= zRObjBr || y + zRObjOff.y >= zRObjHi )
  463. return;
  464. bool faerb = 0;
  465. int len = textLength( txt );
  466. for( int i = 0; i < len; ++i )
  467. {
  468. if( i == fbeg )
  469. faerb = !faerb;
  470. if( i == cpos )
  471. {
  472. zRObj.drawLinieVAlpha( x, y, zh, cf );
  473. faerb = !faerb;
  474. }
  475. if( txt[ i ] == ' ' )
  476. {
  477. if( faerb )
  478. zRObj.alphaRegion( x, y, schriftSize / 2 + zeichenAbstand, zh, ff );
  479. x += schriftSize / 2 + zeichenAbstand;
  480. continue;
  481. }
  482. if( txt[ i ] == '\t' )
  483. {
  484. if( faerb )
  485. zRObj.alphaRegion( x, y, schriftSize + zeichenAbstand, zh, ff );
  486. x += schriftSize + zeichenAbstand;
  487. continue;
  488. }
  489. if( txt[ i ] == '\n' )
  490. {
  491. y += zh + zeilenAbstand;
  492. x = beginX;
  493. continue;
  494. }
  495. renderChar( x, y, txt[ i ], zRObj, f( x, y, i ), 0, faerb, ff );
  496. }
  497. if( textLength( txt ) == cpos )
  498. zRObj.drawLinieVAlpha( x, y, zh, cf );
  499. }
  500. // Zeichnet einen Bestimmten Text mit Cursor und einfärbung auf ein Bild
  501. // Nutze (setPosition) und (setDrawSchriftGröße) um die Position und die Größe zu verändern
  502. // x: x position des ersten zeichens
  503. // y: y position des ersten zeichens
  504. // txt: Der Text, der gezeichnet werden soll
  505. // zRObj: Das Bild, auf das gezeichnet werden soll
  506. // cpos: Die position des Cursors im Text
  507. // cf: Die Farbe des Cursors
  508. // fbeg: Die Position des Zeichens im Text, wo die Einfärbung beginnen soll. Der Text wird von dort bis zur Cursorposition eingefärbt
  509. // ff: Die Hintergrund Farbe des eingefärbten Textes
  510. // f: Die Farbe, in der der Text gezeichnet werden soll
  511. void TextRenderer::renderText( int x, int y, const char *txt, Bild & zRObj, int f, int cpos, int cf, int fbeg, int ff )
  512. {
  513. return renderText( x, y, txt, zRObj, [ f ]( int a, int b, int c ) { return f; }, cpos, cf, fbeg, ff );
  514. }
  515. // Zeichnet einen Bestimmten Buchstaben mit einfärbung auf ein Bild
  516. // Nutze (setPosition) und (setDrawSchriftGröße) um die Position und die Größe zu verändern
  517. // x: x position des ersten zeichens
  518. // y: y position des ersten zeichens
  519. // txt: Der Text, der gezeichnet werden soll
  520. // zRObj: Das Bild, auf das gezeichnet werden soll
  521. // color: Die Farbe, in der der Text gezeichnet werden soll
  522. // underlined: 1, falls der Text unterstrichen sein soll
  523. // selected: 1, falls das zeichen eingefärbt sein soll
  524. // selectedBackgroundColor: Die Hintergrund Farbe des eingefärbten Textes
  525. void TextRenderer::renderChar( int &x, int y, char c, Bild & zRObj, int color, bool underlined, bool selected, int selectedBackgroundColor )
  526. {
  527. if( !s )
  528. return;
  529. Alphabet *a = s->zAlphabet( schriftSize );
  530. if( !a )
  531. return;
  532. Buchstabe *b = a->zBuchstabe( c );
  533. if( b )
  534. {
  535. if( x >= zRObj.getBreite() )
  536. return;
  537. if( zRObj.isAreaDrawable( x, y, getCharWidth( c ), getCharHeight( c ) ) )
  538. {
  539. if( selected )
  540. {
  541. int br = getCharWidth( c ) + zeichenAbstand;
  542. zRObj.alphaRegion( x, y, br, getZeilenHeight(), selectedBackgroundColor );
  543. }
  544. if( b->getBuff() )
  545. {
  546. const Punkt &zRObjGr = zRObj.getDrawGr();
  547. const Punkt &zRObjPos = zRObj.getDrawPos();
  548. const Punkt &zRObjOff = zRObj.getDrawOff();
  549. int xp = x + zRObjOff.x, yp = y + zRObjOff.y;
  550. int xs = xp < zRObjPos.x ? ( zRObjPos.x - xp ) : 0, ys = yp < zRObjPos.y ? ( zRObjPos.y - yp ) : 0;
  551. int br = b->getBreite();
  552. unsigned char a2 = (unsigned char)( 255 - ( color >> 24 ) );
  553. color &= 0x00FFFFFF;
  554. double xoff = (double)b->getSchriftSize() / (double)schriftSize,
  555. yoff = (double)b->getSchriftSize() / (double)schriftSize;
  556. double x = xs * xoff, y = ys * yoff;
  557. int maxX = getCharWidth( c ), maxY = getCharHeight( c );
  558. maxX = ( xp + maxX ) >= zRObjGr.x ? ( zRObjGr.x - xp ) : maxX;
  559. maxY = ( yp + maxY ) >= zRObjGr.y ? ( zRObjGr.y - yp ) : maxY;
  560. int a, dx, ygr, ygr2;
  561. if( zRObj.hasAlpha3D() )
  562. {
  563. for( int dy = ys; dy < maxY; ++dy )
  564. {
  565. ygr2 = ( yp + dy ) * zRObj.getBreite();
  566. ygr = (int)y * br;
  567. for( dx = xs; dx < maxX; ++dx )
  568. {
  569. a = b->getBuff()[ (int)x + ygr ] - a2;
  570. zRObj.alphaPixel3D( xp + dx + ygr2, color | ( a << 24 ) );
  571. x += xoff;
  572. }
  573. x = xs;
  574. y += yoff;
  575. }
  576. }
  577. else
  578. {
  579. for( int dy = ys; dy < maxY; ++dy )
  580. {
  581. ygr2 = ( yp + dy ) * zRObj.getBreite();
  582. ygr = (int)y * br;
  583. for( dx = xs; dx < maxX; ++dx )
  584. {
  585. a = b->getBuff()[ (int)x + ygr ] - a2;
  586. zRObj.alphaPixel2D( xp + dx + ygr2, color | ( a << 24 ) );
  587. x += xoff;
  588. }
  589. x = xs;
  590. y += yoff;
  591. }
  592. }
  593. }
  594. if( underlined )
  595. zRObj.drawLinieHAlpha( x - (int)( zeichenAbstand / 2.0 + 0.5 ), y + getZeilenHeight() + getZeichenAbstand() / 2, getCharWidth( c ) + (int)( zeichenAbstand / 2.0 + 0.5 ), 0xFF000000 | color );
  596. }
  597. x += getCharWidth( c ) + zeichenAbstand;
  598. }
  599. else if( c == ' ' )
  600. {
  601. if( selected )
  602. zRObj.alphaRegion( x, y, schriftSize / 2 + zeichenAbstand, getZeilenHeight(), selectedBackgroundColor );
  603. if( underlined )
  604. zRObj.drawLinieHAlpha( x - (int)( zeichenAbstand / 2.0 + 0.5 ), y + getZeilenHeight() + getZeichenAbstand() / 2, schriftSize / 2 + zeichenAbstand + (int)( zeichenAbstand / 2.0 + 0.5 ), 0xFF000000 | color );
  605. x += schriftSize / 2 + zeichenAbstand;
  606. }
  607. else if( c == '\t' )
  608. {
  609. if( selected )
  610. zRObj.alphaRegion( x, y, schriftSize + zeichenAbstand, getZeilenHeight(), selectedBackgroundColor );
  611. if( underlined )
  612. zRObj.drawLinieHAlpha( x - (int)( zeichenAbstand / 2.0 + 0.5 ), y + getZeilenHeight() + getZeichenAbstand() / 2, schriftSize + zeichenAbstand + (int)( zeichenAbstand / 2.0 + 0.5 ), 0xFF000000 | color );
  613. x += schriftSize + zeichenAbstand;
  614. }
  615. }
  616. // Gibt die Schriftgröße zurück, die zum Zeichnen verwendet wird
  617. int TextRenderer::getSchriftSize() const
  618. {
  619. return schriftSize;
  620. }
  621. // Gibt den Abstand in Pixeln zum unteren Ende der darüber ligenden Zeile zurück
  622. int TextRenderer::getZeilenabstand() const
  623. {
  624. return zeilenAbstand;
  625. }
  626. // Gibt den Abstand in Pixeln zum zwischen zwei zeichen auf der x Achse zurück
  627. int TextRenderer::getZeichenAbstand() const
  628. {
  629. return zeichenAbstand;
  630. }
  631. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Text vollständig darzustellen
  632. // txt: Der Text, von dem die Breite in Pixeln ermitelt werden soll
  633. int TextRenderer::getTextBreite( const char *txt ) const
  634. {
  635. int ret = 0;
  636. int tmp = 0;
  637. int len = textLength( txt );
  638. for( int i = 0; i < len; ++i )
  639. {
  640. if( txt[ i ] == '\n' )
  641. {
  642. if( tmp > ret )
  643. ret = tmp;
  644. tmp = 0;
  645. }
  646. else if( txt[ i ] == '\t' )
  647. tmp += schriftSize + zeichenAbstand;
  648. else if( txt[ i ] == ' ' )
  649. tmp += schriftSize / 2 + zeichenAbstand;
  650. else
  651. tmp += getCharWidth( txt[ i ] ) + zeichenAbstand;
  652. }
  653. if( tmp > ret )
  654. ret = tmp;
  655. return ret;
  656. }
  657. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Text vollständig darzustellen
  658. // txt: Der Text, von dem die Höhe in Pixeln ermitelt werden soll
  659. int TextRenderer::getTextHeight( const char *txt ) const
  660. {
  661. int hi = getZeilenHeight();
  662. return hi + ( ( hi + zeilenAbstand ) * Text( txt ).anzahlVon( '\n' ) );
  663. }
  664. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Buchstaben vollständig darzustellen
  665. // c: Der Buchstabe, von dem die Breite in Pixeln ermitelt werden soll
  666. int TextRenderer::getCharWidth( const char c ) const
  667. {
  668. if( !s )
  669. return 0;
  670. Alphabet *a = s->zAlphabet( schriftSize );
  671. if( !a )
  672. return 0;
  673. Buchstabe *b = a->zBuchstabe( c );
  674. if( b )
  675. return (int)( ( (double)b->getBreite() / (double)b->getSchriftSize() ) * (double)schriftSize + 0.5 );
  676. return 0;
  677. }
  678. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Text vollständig darzustellen
  679. // c: Der Buchstabe, von dem die Höhe in Pixeln ermitelt werden soll
  680. int TextRenderer::getCharHeight( const char c ) const
  681. {
  682. if( !s )
  683. return 0;
  684. Alphabet *a = s->zAlphabet( schriftSize );
  685. if( !a )
  686. return 0;
  687. Buchstabe *b = a->zBuchstabe( c );
  688. if( b )
  689. return (int)( ( (double)b->getHeight() / (double)b->getSchriftSize() ) * (double)schriftSize + 0.5 );
  690. return 0;
  691. }
  692. // Gibt den Abstand in Pixeln zum unteren Ende der darüber ligenden Zeile zurück
  693. int TextRenderer::getZeilenAbstand() const
  694. {
  695. return zeilenAbstand;
  696. }
  697. // Gibt die skallierte Höhe zurück, die eine gezeichnete Zeile in Pixeln benötigt
  698. int TextRenderer::getZeilenHeight() const
  699. {
  700. int zh = 0;
  701. for( int i = 0; i < 256; ++i )
  702. {
  703. zh = maxInt( getCharHeight( (char)i ), zh );
  704. }
  705. return zh;
  706. }
  707. // Ermittelt das Zeichen im Text, auf das die Maus zeigt
  708. // txt: Der Text, auf den die Maus Zeigt
  709. // mausX: Die X Position der Maus in Pixeln Relativ zur Position des ersten Zeichens
  710. // mausY: Die Y Position der Maus in Pixeln Relativ zur Position des ersten Zeichens
  711. int TextRenderer::textPos( const char *txt, int mausX, int mausY ) const
  712. {
  713. int tx = 0;
  714. int ty = 0;
  715. int sh = getZeilenHeight();
  716. if( mausX < 0 || mausY < 0 )
  717. return -1;
  718. int len = textLength( txt );
  719. for( int i = 0; i < len; ++i )
  720. {
  721. if( txt[ i ] == '\n' )
  722. {
  723. ty += sh + zeilenAbstand;
  724. tx = 0;
  725. if( mausY < ty )
  726. return i;
  727. }
  728. if( txt[ i ] == '\t' )
  729. tx += schriftSize + zeichenAbstand;
  730. if( txt[ i ] == ' ' )
  731. tx += schriftSize / 2 + zeichenAbstand;
  732. tx += getCharWidth( txt[ i ] );
  733. int txpl = getCharWidth( txt[ i + 1 ] ) / 2;
  734. if( mausX < tx - txpl && mausY < ty + sh + zeilenAbstand )
  735. return i;
  736. }
  737. if( mausY < ty + sh + zeilenAbstand )
  738. return textLength( txt );
  739. return -1;
  740. }
  741. TextRenderer * TextRenderer::getThis()
  742. {
  743. ref++;
  744. return this;
  745. }
  746. TextRenderer *TextRenderer::release()
  747. {
  748. if( !--ref )
  749. delete this;
  750. return 0;
  751. }
  752. GravurTextRenderer::GravurTextRenderer()
  753. : GravurTextRenderer( 0 )
  754. {}
  755. GravurTextRenderer::GravurTextRenderer( Schrift * schrift )
  756. : TextRenderer( schrift )
  757. {}
  758. GravurTextRenderer::~GravurTextRenderer()
  759. {}
  760. // Zeichnet einen Bestimmten Buchstaben mit einfärbung auf ein Bild
  761. // Nutze (setPosition) und (setDrawSchriftGröße) um die Position und die Größe zu verändern
  762. // x: x position des ersten zeichens
  763. // y: y position des ersten zeichens
  764. // txt: Der Text, der gezeichnet werden soll
  765. // zRObj: Das Bild, auf das gezeichnet werden soll
  766. // color: Die Farbe, in der der Text gezeichnet werden soll
  767. // underlined: 1, falls der Text unterstrichen sein soll
  768. // selected: 1, falls das zeichen eingefärbt sein soll
  769. // selectedBackgroundColor: Die Hintergrund Farbe des eingefärbten Textes
  770. void GravurTextRenderer::renderChar( int &x, int y, char c, Bild & zRObj, int color, bool underlined, bool selected, int selectedBackgroundColor )
  771. {
  772. if( !s )
  773. return;
  774. Alphabet *a = s->zAlphabet( schriftSize );
  775. Buchstabe *b = a->zBuchstabe( c );
  776. if( b )
  777. {
  778. if( x >= zRObj.getBreite() )
  779. return;
  780. if( zRObj.isAreaDrawable( x, y, getCharWidth( c ), getCharHeight( c ) ) )
  781. {
  782. if( selected )
  783. {
  784. int br = getCharWidth( c ) + zeichenAbstand;
  785. zRObj.alphaRegion( x, y, br, getZeilenHeight(), selectedBackgroundColor );
  786. }
  787. if( b->getBuff() )
  788. {
  789. const Punkt &zRObjGr = zRObj.getDrawGr();
  790. const Punkt &zRObjPos = zRObj.getDrawPos();
  791. const Punkt &zRObjOff = zRObj.getDrawOff();
  792. int xp = x + zRObjOff.x, yp = y + zRObjOff.y;
  793. int xs = xp < zRObjPos.x ? ( zRObjPos.x - xp ) : 0, ys = yp < zRObjPos.y ? ( zRObjPos.y - yp ) : 0;
  794. int br = b->getBreite(), h = b->getHeight();
  795. color &= 0x00FFFFFF;
  796. double xoff = (double)b->getSchriftSize() / ( schriftSize * 2.0 ),
  797. yoff = (double)b->getSchriftSize() / ( schriftSize * 2.0 );
  798. double x = xs * xoff, y = ys * yoff;
  799. int maxX = getCharWidth( c ), maxY = getCharHeight( c );
  800. maxX = ( xp + maxX ) >= zRObjGr.x ? ( zRObjGr.x - xp ) : maxX;
  801. maxY = ( yp + maxY ) >= zRObjGr.y ? ( zRObjGr.y - yp ) : maxY;
  802. int dx, ygr, ygr2;
  803. if( zRObj.hasAlpha3D() )
  804. {
  805. for( int dy = ys; dy < maxY; ++dy )
  806. {
  807. ygr2 = ( yp + dy ) * zRObj.getBreite();
  808. ygr = (int)y * br;
  809. for( dx = xs; dx < maxX; ++dx )
  810. {
  811. int f = 0;
  812. if( b->getBuff()[ (int)x + ygr ] )
  813. f = 0x50000000;
  814. 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 ) )
  815. f = 0xA0000000;
  816. 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 ) )
  817. {
  818. f = 0xA0FFFFFF;
  819. }
  820. zRObj.alphaPixel3D( xp + dx + ygr2, f );
  821. x += xoff;
  822. }
  823. x = xs;
  824. y += yoff;
  825. }
  826. }
  827. else
  828. {
  829. for( int dy = ys; dy < maxY; ++dy )
  830. {
  831. ygr2 = ( yp + dy ) * zRObj.getBreite();
  832. ygr = (int)y * br;
  833. for( dx = xs; dx < maxX; ++dx )
  834. {
  835. int f = 0;
  836. if( b->getBuff()[ (int)x + ygr ] )
  837. f = 0x50000000;
  838. 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 ) )
  839. f = 0xA0000000;
  840. 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 ) )
  841. {
  842. f = 0xA0FFFFFF;
  843. }
  844. zRObj.alphaPixel2D( xp + dx + ygr2, f );
  845. x += xoff;
  846. }
  847. x = xs;
  848. y += yoff;
  849. }
  850. }
  851. }
  852. if( underlined )
  853. zRObj.drawLinieHAlpha( x - (int)( zeichenAbstand / 2.0 + 0.5 ), y + getZeilenHeight() + getZeichenAbstand() / 2, getCharWidth( c ) + (int)( zeichenAbstand / 2.0 + 0.5 ), 0xFF000000 | color );
  854. }
  855. x += getCharWidth( c ) + zeichenAbstand;
  856. }
  857. else if( c == ' ' )
  858. {
  859. if( selected )
  860. zRObj.alphaRegion( x, y, schriftSize / 2 + zeichenAbstand, getZeilenHeight(), selectedBackgroundColor );
  861. if( underlined )
  862. zRObj.drawLinieHAlpha( x - (int)( zeichenAbstand / 2.0 + 0.5 ), y + getZeilenHeight() + getZeichenAbstand() / 2, schriftSize / 2 + zeichenAbstand + (int)( zeichenAbstand / 2.0 + 0.5 ), 0xFF000000 | color );
  863. x += schriftSize / 2 + zeichenAbstand;
  864. }
  865. else if( c == '\t' )
  866. {
  867. if( selected )
  868. zRObj.alphaRegion( x, y, schriftSize + zeichenAbstand, getZeilenHeight(), selectedBackgroundColor );
  869. if( underlined )
  870. zRObj.drawLinieHAlpha( x - (int)( zeichenAbstand / 2.0 + 0.5 ), y + getZeilenHeight() + getZeichenAbstand() / 2, schriftSize + zeichenAbstand + (int)( zeichenAbstand / 2.0 + 0.5 ), 0xFF000000 | color );
  871. x += schriftSize + zeichenAbstand;
  872. }
  873. }
  874. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Buchstaben vollständig darzustellen
  875. // c: Der Buchstabe, von dem die Breite in Pixeln ermitelt werden soll
  876. int GravurTextRenderer::getCharWidth( const char c ) const
  877. {
  878. if( !s )
  879. return 0;
  880. Alphabet *a = s->zAlphabet( schriftSize );
  881. Buchstabe *b = a->zBuchstabe( c );
  882. if( b )
  883. return (int)( ( (double)b->getBreite() / (double)b->getSchriftSize() ) * (double)schriftSize * 2 + 0.5 );
  884. return 0;
  885. }
  886. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Text vollständig darzustellen
  887. // c: Der Buchstabe, von dem die Höhe in Pixeln ermitelt werden soll
  888. int GravurTextRenderer::getCharHeight( const char c ) const
  889. {
  890. if( !s )
  891. return 0;
  892. Alphabet *a = s->zAlphabet( schriftSize );
  893. Buchstabe *b = a->zBuchstabe( c );
  894. if( b )
  895. return (int)( ( (double)b->getHeight() / (double)b->getSchriftSize() ) * (double)schriftSize * 2 + 0.5 );
  896. return 0;
  897. }
  898. KursivTextRenderer::KursivTextRenderer()
  899. : KursivTextRenderer( 0 )
  900. {}
  901. KursivTextRenderer::KursivTextRenderer( Schrift * schrift )
  902. : TextRenderer( schrift )
  903. {}
  904. KursivTextRenderer::~KursivTextRenderer()
  905. {}
  906. // Zeichnet einen Bestimmten Buchstaben mit einfärbung auf ein Bild
  907. // Nutze (setPosition) und (setDrawSchriftGröße) um die Position und die Größe zu verändern
  908. // x: x position des ersten zeichens
  909. // y: y position des ersten zeichens
  910. // txt: Der Text, der gezeichnet werden soll
  911. // zRObj: Das Bild, auf das gezeichnet werden soll
  912. // color: Die Farbe, in der der Text gezeichnet werden soll
  913. // underlined: 1, falls der Text unterstrichen sein soll
  914. // selected: 1, falls das zeichen eingefärbt sein soll
  915. // selectedBackgroundColor: Die Hintergrund Farbe des eingefärbten Textes
  916. void KursivTextRenderer::renderChar( int &x, int y, char c, Bild & zRObj, int color, bool underlined, bool selected, int selectedBackgroundColor )
  917. {
  918. if( !s )
  919. return;
  920. Alphabet *a = s->zAlphabet( schriftSize );
  921. if( !a )
  922. return;
  923. Buchstabe *b = a->zBuchstabe( c );
  924. if( b )
  925. {
  926. if( x >= zRObj.getBreite() )
  927. return;
  928. if( zRObj.isAreaDrawable( x, y, getCharWidth( c ), getCharHeight( c ) ) )
  929. {
  930. if( selected )
  931. {
  932. int br = getCharWidth( c ) + zeichenAbstand;
  933. zRObj.alphaRegion( x, y, br, getZeilenHeight(), selectedBackgroundColor );
  934. }
  935. if( b->getBuff() )
  936. {
  937. const Punkt &zRObjGr = zRObj.getDrawGr();
  938. const Punkt &zRObjPos = zRObj.getDrawPos();
  939. const Punkt &zRObjOff = zRObj.getDrawOff();
  940. int xp = x + zRObjOff.x, yp = y + zRObjOff.y;
  941. int xStartBuffer = xp < zRObjPos.x ? ( zRObjPos.x - xp ) : 0, yStartBuffer = yp < zRObjPos.y ? ( zRObjPos.y - yp ) : 0;
  942. int bufferBreite = b->getBreite(), bufferHeight = b->getHeight();
  943. unsigned char colorAlpha = (unsigned char)( 255 - ( color >> 24 ) );
  944. color &= 0x00FFFFFF;
  945. double xStepBuffer = (double)b->getSchriftSize() / (double)schriftSize,
  946. yStepBuffer = (double)b->getSchriftSize() / (double)schriftSize;
  947. double xBuffer = xStartBuffer * xStepBuffer, yBuffer = yStartBuffer * yStepBuffer;
  948. int charHeight = getCharHeight( c );
  949. int maxXBuffer = getCharWidth( c ), maxYBuffer = charHeight;
  950. maxXBuffer = ( xp + maxXBuffer ) >= zRObjGr.x ? ( zRObjGr.x - xp ) : maxXBuffer;
  951. maxYBuffer = ( yp + maxYBuffer ) >= zRObjGr.y ? ( zRObjGr.y - yp ) : maxYBuffer;
  952. std::function< int( int x, int y ) > colorF = [ charHeight, bufferBreite, bufferHeight, colorAlpha, b, color ]( int x, int y )
  953. {
  954. x -= (int)( (float)( charHeight - y ) / 4.f + 0.5f );
  955. if( x < 0 || x >= bufferBreite )
  956. return 0x00FFFFFF;
  957. int a = b->getBuff()[ y * bufferBreite + x ] - colorAlpha;
  958. return color | ( a << 24 );
  959. };
  960. if( zRObj.hasAlpha3D() )
  961. {
  962. for( int yS = yStartBuffer; yS < maxYBuffer; ++yS )
  963. {
  964. int ygr2 = ( yp + yS ) * zRObj.getBreite();
  965. for( int xS = xStartBuffer; xS < maxXBuffer; ++xS )
  966. {
  967. zRObj.alphaPixel3D( xp + xS + ygr2, colorF( (int)xS, (int)yS ) );
  968. xBuffer += xStepBuffer;
  969. }
  970. xBuffer = xStartBuffer;
  971. yBuffer += yStepBuffer;
  972. }
  973. }
  974. else
  975. {
  976. for( int yS = yStartBuffer; yS < maxYBuffer; ++yS )
  977. {
  978. int ygr2 = ( yp + yS ) * zRObj.getBreite();
  979. for( int xS = xStartBuffer; xS < maxXBuffer; ++xS )
  980. {
  981. zRObj.alphaPixel2D( xp + xS + ygr2, colorF( (int)xS, (int)yS ) );
  982. xBuffer += xStepBuffer;
  983. }
  984. xBuffer = xStartBuffer;
  985. yBuffer += yStepBuffer;
  986. }
  987. }
  988. }
  989. if( underlined )
  990. zRObj.drawLinieHAlpha( x - (int)( zeichenAbstand / 2.0 + 0.5 ), y + getZeilenHeight() + getZeichenAbstand() / 2, getCharWidth( c ) + (int)( zeichenAbstand / 2.0 + 0.5 ), 0xFF000000 | color );
  991. }
  992. x += getCharWidth( c ) + zeichenAbstand;
  993. }
  994. else if( c == ' ' )
  995. {
  996. if( selected )
  997. zRObj.alphaRegion( x, y, schriftSize / 2 + zeichenAbstand, getZeilenHeight(), selectedBackgroundColor );
  998. if( underlined )
  999. zRObj.drawLinieHAlpha( x - (int)( zeichenAbstand / 2.0 + 0.5 ), y + getZeilenHeight() + getZeichenAbstand() / 2, schriftSize / 2 + zeichenAbstand + (int)( zeichenAbstand / 2.0 + 0.5 ), 0xFF000000 | color );
  1000. x += schriftSize / 2 + zeichenAbstand;
  1001. }
  1002. else if( c == '\t' )
  1003. {
  1004. if( selected )
  1005. zRObj.alphaRegion( x, y, schriftSize + zeichenAbstand, getZeilenHeight(), selectedBackgroundColor );
  1006. if( underlined )
  1007. zRObj.drawLinieHAlpha( x - (int)( zeichenAbstand / 2.0 + 0.5 ), y + getZeilenHeight() + getZeichenAbstand() / 2, schriftSize + zeichenAbstand + (int)( zeichenAbstand / 2.0 + 0.5 ), 0xFF000000 | color );
  1008. x += schriftSize + zeichenAbstand;
  1009. }
  1010. }
  1011. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Buchstaben vollständig darzustellen
  1012. // c: Der Buchstabe, von dem die Breite in Pixeln ermitelt werden soll
  1013. int KursivTextRenderer::getCharWidth( const char c ) const
  1014. {
  1015. if( !s )
  1016. return 0;
  1017. Alphabet *a = s->zAlphabet( schriftSize );
  1018. Buchstabe *b = a->zBuchstabe( c );
  1019. if( b )
  1020. return (int)( ( (double)b->getBreite() / (double)b->getSchriftSize() ) * (double)schriftSize + getCharHeight( c ) / 4.0 + 0.5 );
  1021. return 0;
  1022. }
  1023. // Ermittelt, wie viele Pixel benötigt werden, um einen Bestimmten Text vollständig darzustellen
  1024. // c: Der Buchstabe, von dem die Höhe in Pixeln ermitelt werden soll
  1025. int KursivTextRenderer::getCharHeight( const char c ) const
  1026. {
  1027. if( !s )
  1028. return 0;
  1029. Alphabet *a = s->zAlphabet( schriftSize );
  1030. Buchstabe *b = a->zBuchstabe( c );
  1031. if( b )
  1032. return (int)( ( (double)b->getHeight() / (double)b->getSchriftSize() ) * (double)schriftSize + 0.5 );
  1033. return 0;
  1034. }