Schrift.cpp 35 KB

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