Schrift.cpp 35 KB

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