Text.cpp 42 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636
  1. //---Include---
  2. #include "Text.h"
  3. #include <sstream>
  4. #include <iomanip>
  5. #ifndef WIN32
  6. #include <string.h>
  7. #endif
  8. using namespace Framework;
  9. // inhalt der Text Klasse aus Text.h
  10. // Konstruktor
  11. Text::Text()
  12. : txt( 0 ),
  13. suchGBeg( 0 ),
  14. suchGEnd( 0 ),
  15. precision( 0 ),
  16. ref( 1 )
  17. {
  18. setText( "" );
  19. }
  20. Text::Text( const Text &txt )
  21. : txt( 0 ),
  22. suchGBeg( 0 ),
  23. suchGEnd( 0 ),
  24. precision( 0 ),
  25. ref( 1 )
  26. {
  27. setText( txt );
  28. }
  29. Text::Text( const char *t )
  30. : txt( 0 ),
  31. suchGBeg( 0 ),
  32. suchGEnd( 0 ),
  33. precision( 0 ),
  34. ref( 1 )
  35. {
  36. setText( t ); // Text setzen
  37. }
  38. Text::Text( int zahl )
  39. : txt( 0 ),
  40. suchGBeg( 0 ),
  41. suchGEnd( 0 ),
  42. precision( 0 ),
  43. ref( 1 )
  44. {
  45. *this = zahl;
  46. }
  47. // Erstellt ein neues Text Objekt mit einer zahl als text
  48. // num: Die Zahl, die im Text sein soll
  49. Text::Text( double num )
  50. : txt( 0 ),
  51. suchGBeg( 0 ),
  52. suchGEnd( 0 ),
  53. precision( 0 ),
  54. ref( 1 )
  55. {
  56. *this = num;
  57. }
  58. // Erstellt ein neues Text Objekt mit einer zahl als text
  59. // num: Die Zahl, die im Text sein soll
  60. Text::Text( float num )
  61. : txt( 0 ),
  62. suchGBeg( 0 ),
  63. suchGEnd( 0 ),
  64. precision( 0 ),
  65. ref( 1 )
  66. {
  67. *this = num;
  68. }
  69. // Destruktor
  70. Text::~Text()
  71. {
  72. delete[]txt;
  73. }
  74. void Text::toUpperCase()
  75. {
  76. if( !txt )
  77. return;
  78. for( int i = 0; txt[ i ]; i++ )
  79. {
  80. if( txt[ i ] >= 'a' && txt[ i ] <= 'z' )
  81. txt[ i ] -= (char)32;
  82. switch( txt[ i ] )
  83. {
  84. case 'ü':
  85. txt[ i ] = 'Ü';
  86. break;
  87. case 'ö':
  88. txt[ i ] = 'Ö';
  89. break;
  90. case 'ä':
  91. txt[ i ] = 'Ä';
  92. break;
  93. }
  94. }
  95. }
  96. void Text::toLowerCase()
  97. {
  98. if( !txt )
  99. return;
  100. for( int i = 0; txt[ i ]; i++ )
  101. {
  102. if( txt[ i ] >= 'A' && txt[ i ] <= 'Z' )
  103. txt[ i ] += (char)32;
  104. switch( txt[ i ] )
  105. {
  106. case 'Ü':
  107. txt[ i ] = 'ü';
  108. break;
  109. case 'Ö':
  110. txt[ i ] = 'ö';
  111. break;
  112. case 'Ä':
  113. txt[ i ] = 'ä';
  114. break;
  115. }
  116. }
  117. }
  118. // nicht constant
  119. void Text::setSuchGrenzen( char gBeg, char gEnd ) // sucht bei jeder suchfunktion nicht zwischen den Zeichen gBeg und gEnd
  120. {
  121. suchGBeg = gBeg;
  122. suchGEnd = gEnd;
  123. }
  124. void Text::setText( const char *t ) // ersetzt den Text
  125. {
  126. delete[]txt; // alter Text löschen
  127. int l = (int)strlen( t ); // Länge des neuen Textes ermitteln
  128. txt = new char[ l + 1 ]; // neuen Text erstellen
  129. for( int i = 0; i < l; ++i ) // Text befüllen
  130. txt[ i ] = t[ i ];
  131. txt[ l ] = '\0'; // Textende Festlegen
  132. }
  133. // unconstant
  134. void Text::setText( const char *t, int l ) // ersetzt den Text
  135. {
  136. delete[]txt; // alter Text löschen
  137. txt = new char[ l + 1 ]; // neuen Text erstellen
  138. for( int i = 0; i < l; ++i ) // Text befüllen
  139. txt[ i ] = t[ i ];
  140. txt[ l ] = '\0'; // Textende Festlegen
  141. }
  142. void Text::setText( Text *t )
  143. {
  144. setText( t->getText() ); // Text setzen
  145. t = t->release(); // übergabe loslassen
  146. }
  147. void Text::append( char c ) // hängt an den Text an
  148. {
  149. append( &c, 1 );
  150. }
  151. void Text::append( const char *t ) // hängt an den Text an
  152. {
  153. int tl = (int)strlen( t ); // länge der übergabe
  154. int txl = getLength(); // länge des Textes
  155. char *res = new char[ tl + txl + 1 ]; // neuen Text erstellen
  156. for( int i = 0; i < txl; ++i ) // mit jetzigem Text füllen
  157. res[ i ] = txt[ i ];
  158. for( int i = 0; i < tl; ++i ) // Übergabe anhängen
  159. res[ txl + i ] = t[ i ];
  160. res[ txl + tl ] = '\0'; // Textende festlegen
  161. setText( res ); // Test setzen
  162. delete[] res; // Speicher freigeben
  163. }
  164. void Text::appendHex( int num ) // hängt die zahl in hex anden Text an
  165. {
  166. int l = getLength();
  167. char *res = new char[ l + 9 ];
  168. for( int i = 0; i < l; ++i )
  169. res[ i ] = txt[ i ];
  170. std::stringstream stream;
  171. stream << std::setfill( '0' ) << std::setw( (int)sizeof( int ) * 2 ) << std::hex << num;
  172. std::string str = stream.str();
  173. for( int i = l; i < l + 8; ++i )
  174. res[ i ] = str.c_str()[ i - l ];
  175. res[ l + 8 ] = 0;
  176. setText( res );
  177. delete[] res;
  178. }
  179. void Text::appendColor( int fc ) // setzt die Farbe des folgenden Textes
  180. {
  181. int l = getLength();
  182. char *res = new char[ l + 12 ];
  183. for( int i = 0; i < l; ++i )
  184. res[ i ] = txt[ i ];
  185. res[ l ] = '\r';
  186. res[ l + 1 ] = '0';
  187. res[ l + 2 ] = 'x';
  188. std::stringstream stream;
  189. stream << std::setfill( '0' ) << std::setw( (int)sizeof( int ) * 2 ) << std::hex << fc;
  190. std::string str = stream.str();
  191. for( int i = l + 3; i < l + 11; ++i )
  192. res[ i ] = str.c_str()[ i - ( l + 3 ) ];
  193. res[ l + 11 ] = 0;
  194. setText( res );
  195. delete[] res;
  196. }
  197. void Text::append( const char *t, int l ) // hängt an den Text an
  198. {
  199. int txl = getLength(); // länge des Textes
  200. char *res = new char[ l + txl + 1 ]; // neuen Text erstellen
  201. for( int i = 0; i < txl; ++i ) // mit jetzigem Text füllen
  202. res[ i ] = txt[ i ];
  203. for( int i = 0; i < l; ++i ) // Übergabe anhängen
  204. res[ txl + i ] = t[ i ];
  205. res[ txl + l ] = '\0'; // Textende festlegen
  206. setText( res, txl + l ); // Test setzen
  207. delete[] res; // Speicher freigeben
  208. }
  209. void Text::append( Text *t )
  210. {
  211. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  212. append( t->getText() ); // Text anhängen
  213. t = t->release(); // Übergabe loslassen
  214. }
  215. void Text::append( int num )
  216. {
  217. std::stringstream ss;
  218. ss << num;
  219. append( ss.str().c_str() );
  220. }
  221. // Hängt eine Zahl ans Ende Des Textes an
  222. // num: Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
  223. void Text::append( __int64 num )
  224. {
  225. std::stringstream ss;
  226. ss << num;
  227. append( ss.str().c_str() );
  228. }
  229. void Text::append( unsigned int num )
  230. {
  231. std::stringstream ss;
  232. ss << num;
  233. append( ss.str().c_str() );
  234. }
  235. void Text::append( double num )
  236. {
  237. std::stringstream ss;
  238. ss.precision( precision );
  239. ss << num;
  240. append( ss.str().c_str() );
  241. }
  242. void Text::append( float num )
  243. {
  244. std::stringstream ss;
  245. ss.precision( precision );
  246. ss << num;
  247. append( ss.str().c_str() );
  248. }
  249. void Text::insert( int p, char c ) // Fügt an stelle p ein
  250. {
  251. if( p > getLength() || p < 0 ) // Auf unsinnige übergabe prüfen
  252. return;
  253. int txl = getLength(); // Länge des Textes
  254. char *res = new char[ txl + 2 ]; // neuer Text erstellen
  255. for( int i = 0; i < p; ++i ) // Text füllen
  256. res[ i ] = txt[ i ];
  257. res[ p ] = c;
  258. for( int i = p; i < txl; ++i ) // Text füllen
  259. res[ i + 1 ] = txt[ i ];
  260. res[ txl + 1 ] = '\0'; // Text ende festlegen
  261. setText( res ); // Text setzen
  262. delete[] res; // Speicher freigeben
  263. }
  264. void Text::insert( int p, const char *t ) // Fügt an stelle p ein
  265. {
  266. if( p > getLength() || p < 0 || strlen( t ) <= 0 ) // Auf unsinnige übergabe prüfen
  267. return;
  268. int tl = (int)strlen( t ); // Länge der übergabe
  269. int txl = getLength(); // Länge des Textes
  270. char *res = new char[ tl + txl + 1 ]; // neuer Text erstellen
  271. for( int i = 0; i < p; ++i ) // Text füllen
  272. res[ i ] = txt[ i ];
  273. for( int i = 0; i < tl; ++i ) // Text einfügen
  274. res[ i + p ] = t[ i ];
  275. for( int i = p; i < txl; ++i ) // Text füllen
  276. res[ i + tl ] = txt[ i ];
  277. res[ tl + txl ] = '\0'; // Text ende festlegen
  278. setText( res ); // Text setzen
  279. delete[] res; // Speicher freigeben
  280. }
  281. void Text::insert( int p, Text *t )
  282. {
  283. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  284. insert( p, t->getText() ); // Text einfügen
  285. t = t->release(); // Übergabe loslassen
  286. }
  287. void Text::ersetzen( int p1, int p2, const char *t ) // Ersetzt den Text von p1 bis p2
  288. {
  289. if( p1 > p2 )
  290. {
  291. int x = p1; // p1 und p2 tauschen
  292. p1 = p2;
  293. p2 = x;
  294. }
  295. remove( p1, p2 ); // Textabschnitt von p1 zu p2 löschen
  296. insert( p1, t ); // Übergabe bei p1 einfügen
  297. }
  298. void Text::ersetzen( int p1, int p2, Text *t )
  299. {
  300. if( t->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
  301. ersetzen( p1, p2, t->getText() ); // Text ersetzen
  302. t = t->release(); // Übergabe loslassen
  303. }
  304. void Text::ersetzen( char c1, char c2 ) // ersetzt jedes c1 durch c2
  305. {
  306. if( c1 == '\0' || c2 == '\0' ) // Auf unsinnige übergabe prüfen
  307. return;
  308. if( !hat( c1 ) ) // prüfen ob c1 vorhanden
  309. return;
  310. int l = getLength(); // Text Länge
  311. int suchGCount = 0;
  312. for( int i = 0; i < l; ++i ) // Text durchsuchen
  313. {
  314. bool b = suchGCount != 0;
  315. if( txt[ i ] == c1 && !suchGCount )
  316. txt[ i ] = c2; // Text ersetzen
  317. if( txt[ i ] == suchGBeg )
  318. ++suchGCount;
  319. if( txt[ i ] == suchGEnd )
  320. --suchGCount;
  321. if( txt[ i ] == c1 && !suchGCount && b )
  322. txt[ i ] = c2; // Text ersetzen
  323. }
  324. }
  325. void Text::ersetzen( const char *t1, const char *t2 ) // ersetzt jedes t1 durch t2
  326. {
  327. int txl = getLength(); // Text Länge
  328. int t1l = (int)strlen( t1 ); // Länge der Übergaben
  329. int t2l = (int)strlen( t2 );
  330. if( t1l > txl || t1l <= 0 ) // Auf unsinnige übergabe prüfen
  331. return;
  332. if( !hat( t1 ) ) // prüfen ob t1 vorhanden
  333. return;
  334. int anz = anzahlVon( t1 ); // Anzahl von t1 im Text
  335. int *begin = new int[ anz ];
  336. int *end = new int[ anz ];
  337. for( int i = 0; i < anz; ++i ) // Positionen von t1 speichern
  338. {
  339. begin[ i ] = positionVon( t1, i );
  340. end[ i ] = begin[ i ] + t1l;
  341. }
  342. int resl = ( txl - ( anz * t1l ) ) + ( anz * t2l ) + 1; // Länge des Ergebneses
  343. char *res = new char[ resl ]; // neuer Text erstellen
  344. int rep = 0; // Speichert bei welchen t1 man sich befindet
  345. int last = 0; // Füllposition von txt
  346. int neu = 0; // Füllporition von res
  347. for( ; neu < resl; ++neu ) // Text befüllen
  348. {
  349. if( rep < anz && last == begin[ rep ] ) // Text ersetzen
  350. {
  351. last = end[ rep ];
  352. ++rep;
  353. for( int ii = 0; ii < t2l; ++ii )
  354. {
  355. if( neu >= resl )
  356. break;
  357. res[ neu ] = t2[ ii ];
  358. ++neu;
  359. }
  360. if( neu >= resl )
  361. break;
  362. --neu;
  363. }
  364. else // Text Kopieren
  365. {
  366. res[ neu ] = txt[ last ];
  367. ++last;
  368. }
  369. }
  370. res[ resl - 1 ] = '\0'; // Textende festlegen
  371. setText( res ); // Text setzen
  372. delete[]begin; // Speicher freigeben
  373. delete[]end;
  374. delete[] res;
  375. }
  376. void Text::ersetzen( Text *t1, const char *t2 )
  377. {
  378. if( t1->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  379. ersetzen( t1->getText(), t2 ); // ersetzen
  380. t1 = t1->release(); // Übergabe loslassen
  381. }
  382. void Text::ersetzen( const char *t1, Text *t2 )
  383. {
  384. if( t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
  385. ersetzen( t1, t2->getText() ); // ersetzen
  386. t2 = t2->release(); // Übergabe loslassen
  387. }
  388. void Text::ersetzen( Text *t1, Text *t2 )
  389. {
  390. if( t1->getLength() > 0 && t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
  391. ersetzen( t1->getText(), t2->getText() ); // ersetzen
  392. t1 = t1->release(); // Übergaben loslassen
  393. t2 = t2->release();
  394. }
  395. void Text::ersetzen( int index, char c1, char c2 ) // ersetzt das i-te c1 durch c2
  396. {
  397. if( c1 == '\0' || c2 == '\0' || index < 0 ) // Auf unsinnige übergabe prüfen
  398. return;
  399. if( !hat( c1 ) ) // prüfen ob c1 vorhanden
  400. return;
  401. int anz = anzahlVon( c1 );
  402. if( index >= anz ) // prüfen ob es ein i-tes c1 gibt
  403. return;
  404. txt[ positionVon( c1, index ) ] = c2;
  405. }
  406. void Text::ersetzen( int index, const char *t1, const char *t2 ) // ersetzt das i-te t1 durch t2
  407. {
  408. int txl = getLength(); // Text Länge
  409. int t1l = (int)strlen( t1 ); // Länge der Übergaben
  410. if( t1l >= txl || t1l <= 0 || index < 0 ) // Auf unsinnige übergabe prüfen
  411. return;
  412. if( !hat( t1 ) ) // prüfen ob t1 vorhanden
  413. return;
  414. int anz = anzahlVon( t1 ); // Anzahl von t1 im Text
  415. if( index >= anz ) // prüfen ob es ein i-tes t1 gibt
  416. return;
  417. int begin = positionVon( t1, index );
  418. int end = begin + t1l;
  419. ersetzen( begin, end, t2 ); // ersetzen
  420. }
  421. void Text::ersetzen( int i, Text *t1, const char *t2 )
  422. {
  423. if( t1->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  424. ersetzen( i, t1->getText(), t2 ); // ersetzen
  425. t1 = t1->release(); // Übergabe loslassen
  426. }
  427. void Text::ersetzen( int i, const char *t1, Text *t2 )
  428. {
  429. if( t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
  430. ersetzen( i, t1, t2->getText() ); // ersetzen
  431. t2 = t2->release(); // Übergabe loslassen
  432. }
  433. void Text::ersetzen( int i, Text *t1, Text *t2 )
  434. {
  435. if( t1->getLength() > 0 || t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
  436. ersetzen( i, t1->getText(), t2->getText() ); // ersetzen
  437. t1 = t1->release(); // Übergaben loslassen
  438. t2 = t2->release();
  439. }
  440. void Text::fillText( char c, int len ) // setzt den Text zu so vielen c wie län groß ist
  441. {
  442. char *res = new char[ len + 1 ];
  443. for( int i = 0; i < len; ++i )
  444. res[ i ] = c;
  445. res[ len ] = '\0';
  446. setText( res );
  447. delete[] res;
  448. }
  449. void Text::remove( int p ) // löscht p
  450. {
  451. int l = getLength(); // Text Länge
  452. if( p < 0 || p >= l ) // Auf unsinnige übergabe prüfen
  453. return;
  454. char *res = new char[ l ]; // neuen Text anlegen
  455. for( int i = 0; i < p && i < l; ++i ) // Text befüllen
  456. res[ i ] = txt[ i ];
  457. for( int i = p + 1; i < l; ++i )
  458. res[ i - 1 ] = txt[ i ];
  459. res[ l - 1 ] = 0;
  460. setText( res ); // Text setzen
  461. delete[] res; // Speicher freigeben
  462. }
  463. void Text::remove( int p1, int p2 ) // löscht von p1 zu p2 ( p2 bleibt )
  464. {
  465. if( p1 == p2 )
  466. return;
  467. if( p1 > p2 ) // p1 und p2 tauschen
  468. {
  469. int x = p1;
  470. p1 = p2;
  471. p2 = x;
  472. }
  473. int l = getLength(); // Länge des Testes
  474. if( p1 < 0 ) // Auf unsinnige übergabe prüfen
  475. p1 = 0;
  476. if( p2 > l )
  477. p2 = l;
  478. int resl = l - ( p2 - p1 ); // Länge vom Ergebnis
  479. char *res = new char[ resl + 1 ]; // Neuen Text erstellen
  480. for( int i = 0; i < p1; ++i ) // Text füllen
  481. res[ i ] = txt[ i ];
  482. for( int i = p2; i < l; ++i )
  483. res[ i - ( p2 - p1 ) ] = txt[ i ];
  484. res[ resl ] = '\0'; // Testende festlegen
  485. setText( res ); // Text setzen
  486. delete[] res; // Speicher freigeben
  487. }
  488. void Text::remove( char c ) // löscht jetes c
  489. {
  490. if( !hat( c ) ) // prüfen ob c vorhanden
  491. return;
  492. int l = getLength(); // Länge des Textes
  493. int anz = anzahlVon( c ); // Anzahl von c
  494. char *res = new char[ l - anz + 1 ]; // neuen Text erstellen
  495. int anz2 = 0;
  496. int suchGCount = 0;
  497. for( int i = 0; i < l; ++i ) // Text befüllen
  498. {
  499. bool b = suchGCount != 0;
  500. if( txt[ i ] == c && !suchGCount )
  501. ++anz2;
  502. else
  503. res[ i - anz2 ] = txt[ i ];
  504. if( txt[ i ] == suchGBeg )
  505. ++suchGCount;
  506. if( txt[ i ] == suchGEnd )
  507. --suchGCount;
  508. if( b )
  509. {
  510. if( txt[ i ] == c && !suchGCount )
  511. ++anz2;
  512. else
  513. res[ i - anz2 ] = txt[ i ];
  514. }
  515. }
  516. res[ l - anz ] = '\0'; // Textende festlegen
  517. setText( res ); // Text setzen
  518. delete[] res; // Speicher freigeben
  519. }
  520. void Text::remove( const char *t ) // löscht jetes t
  521. {
  522. int tl = (int)strlen( t ); // Länge der Übergabe
  523. int txl = getLength(); // Länge des Textes
  524. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  525. return;
  526. if( !hat( t ) ) // prüfen ob Text ein t enthält
  527. return;
  528. int anz = anzahlVon( t ); // anzahl von t
  529. int *begin = new int[ anz ];
  530. for( int i = 0; i < anz; ++i ) // begin aller t-s finden
  531. begin[ i ] = positionVon( t, i );
  532. int resl = txl - ( anz * tl ); // Länge vom Ergebnes
  533. char *res = new char[ resl + 1 ]; // neuen Text erzeugen
  534. int del = 0;
  535. for( int i = 0; i < txl; ++i ) // Text befüllen
  536. {
  537. if( del < anz && i == begin[ del ] ) // Text auslassen
  538. {
  539. i += tl - 1;
  540. ++del;
  541. }
  542. else
  543. res[ i - ( del * tl ) ] = txt[ i ]; // Text befüllen
  544. }
  545. res[ resl ] = '\0'; // Text ende festlegen
  546. setText( res ); // Text setzen
  547. delete[]begin;
  548. delete[] res; // Speicher freigeben
  549. }
  550. void Text::remove( Text *t )
  551. {
  552. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  553. remove( t->getText() ); // löschen
  554. t = t->release(); // Übergabe loslassen
  555. }
  556. void Text::remove( int index, char c )
  557. {
  558. if( index < 0 || !hat( c ) ) // Auf unsinnige übergabe prüfen
  559. return;
  560. int anz = anzahlVon( c ); // anzahl der i-s
  561. if( index >= anz ) // prüfen ob ein i-tes c vorhanden ist
  562. return;
  563. int pos = positionVon( c, index ); // Position vom i-ten c
  564. if( pos < 0 )
  565. return;
  566. int l = getLength(); // Länge des Textes
  567. if( !l )
  568. return;
  569. char *res = new char[ l ]; // neuen Text erzeugen
  570. for( int i = 0; i < pos && i < l; ++i ) // Text befüllen
  571. res[ i ] = txt[ i ];
  572. for( int i = pos + 1; i < l; ++i )
  573. res[ i - 1 ] = txt[ i ];
  574. res[ l - 1 ] = '\0'; // Text ende festlegen
  575. setText( res ); // Text setzen
  576. delete[] res; // Speicher freigeben
  577. }
  578. void Text::remove( int index, const char *t ) // löscht das i-te t
  579. {
  580. int tl = (int)strlen( t ); // Länge der Übergabe
  581. if( index < 0 || !hat( t ) || tl <= 0 ) // Auf unsinnige übergabe prüfen
  582. return;
  583. int anz = anzahlVon( t ); // anzahl der i-s
  584. if( index >= anz ) // prüfen ob ein i-tes c vorhanden ist
  585. return;
  586. int pos = positionVon( t, index ); // Position vom i-ten c
  587. if( pos < 0 )
  588. return;
  589. int l = getLength(); // Länge des Textes
  590. if( !l )
  591. return;
  592. char *res = new char[ l - tl + 1 ]; // neuen Text erzeugen
  593. for( int i = 0; i < pos && i < l - tl + 1; ++i ) // Text befüllen
  594. res[ i ] = txt[ i ];
  595. for( int i = pos + tl; i < l; ++i )
  596. res[ i - tl ] = txt[ i ];
  597. res[ l - tl ] = '\0'; // Text ende festlegen
  598. setText( res ); // Text setzen
  599. delete[] res; // Speicher freigeben
  600. }
  601. void Text::remove( int i, Text *t )
  602. {
  603. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  604. remove( i, t->getText() ); // löschen
  605. t = t->release(); // Übergabe loslassen
  606. }
  607. // Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
  608. // pos: Die Position des ersten zeichens
  609. void Text::removeWhitespaceAfter( int pos )
  610. {
  611. int length = 0;
  612. for( int i = pos; i < txt[ i ]; i++ )
  613. {
  614. if( txt[ i ] == ' ' || txt[ i ] == '\n' || txt[ i ] == '\r' || txt[ i ] == '\t' )
  615. length++;
  616. else
  617. break;
  618. }
  619. remove( pos, pos + length );
  620. }
  621. // Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
  622. // pos: Die Position des ersten zeichens (beginnt bei pos-1)
  623. void Text::removeWhitespaceBefore( int pos )
  624. {
  625. int length = 0;
  626. for( int i = pos - 1; i >= 0; i-- )
  627. {
  628. if( txt[ i ] == ' ' || txt[ i ] == '\n' || txt[ i ] == '\r' || txt[ i ] == '\t' )
  629. length++;
  630. else
  631. break;
  632. }
  633. remove( pos - length, pos );
  634. }
  635. void Text::setPrecision( int p ) // setzt die Anzahl der Nachkommastellen bei doubles
  636. {
  637. precision = p;
  638. }
  639. // constant
  640. int Text::getLength() const // gibt die Text länge zurück
  641. {
  642. if( !txt )
  643. return -1;
  644. int ret = 0;
  645. for( ; txt[ ret ] != '\0'; ++ret ); // zählen
  646. return ret;
  647. }
  648. int Text::getLKick( int pos ) const
  649. {
  650. if( txt[ pos - 1 ] == ' ' )
  651. {
  652. int ret = 1;
  653. for( ; ret < pos && txt[ pos - ret - 1 ] == ' ' && txt[ pos - ret - 1 ] != '\n'; ++ret );
  654. return pos - ret;
  655. }
  656. else
  657. {
  658. int ret = 1;
  659. for( ; ret < pos && txt[ pos - ret - 1 ] != ' ' && txt[ pos - ret - 1 ] != '\n'; ++ret );
  660. return pos - ret;
  661. }
  662. }
  663. int Text::getOKick( int pos ) const
  664. {
  665. if( !hat( '\n' ) )
  666. return 0;
  667. int lpos = 0;
  668. while( pos - lpos - 1 > 0 && txt[ pos - lpos - 1 ] != '\n' )
  669. ++lpos;
  670. int vllen = 1;
  671. while( pos - lpos - vllen - 1 >= 0 && txt[ pos - lpos - vllen - 1 ] != '\n' )
  672. ++vllen;
  673. if( vllen > lpos )
  674. return pos - vllen;
  675. else
  676. return pos - lpos - 1;
  677. }
  678. int Text::getRKick( int pos ) const
  679. {
  680. int tl = getLength();
  681. if( txt[ pos ] == ' ' )
  682. {
  683. int ret = 1;
  684. for( ; ret + pos < tl && txt[ pos + ret ] == ' ' && txt[ pos + ret ] != '\n'; ++ret );
  685. return pos + ret;
  686. }
  687. else
  688. {
  689. int ret = 1;
  690. for( ; ret + pos < tl && txt[ pos + ret ] != ' '&& txt[ pos + ret ] != '\n'; ++ret );
  691. return pos + ret;
  692. }
  693. }
  694. int Text::getUKick( int pos ) const
  695. {
  696. if( !hat( '\n' ) )
  697. return getLength();
  698. int lpos = 0;
  699. while( pos - lpos > 0 && txt[ pos - lpos - 1 ] != '\n' )
  700. ++lpos;
  701. int llen = 1;
  702. while( pos + llen - 1 < getLength() && txt[ pos + llen - 1 ] != '\n' )
  703. ++llen;
  704. int vllen = 1;
  705. while( pos + llen + vllen - 1 < getLength() && txt[ pos + llen + vllen - 1 ] != '\n' )
  706. ++vllen;
  707. if( vllen == 1 )
  708. return pos + llen < getLength() ? pos + llen : getLength();
  709. if( vllen < lpos )
  710. return pos + llen + vllen - 1;
  711. return pos + llen + lpos;
  712. }
  713. bool Text::hat( Text *t ) const // enthält der Text t
  714. {
  715. bool ret = 0;
  716. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  717. ret = hat( t->getText() ); // prüfen
  718. t = t->release(); // Übergabe loslassen
  719. return ret;
  720. }
  721. bool Text::hat( const char *t ) const
  722. {
  723. int tl = (int)strlen( t ); // Länge der Übergabe
  724. int txl = getLength(); // Länge des Textes
  725. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  726. return 0;
  727. int suchGCount = 0;
  728. for( int i = 0; i + tl <= txl; ++i ) // Text durchsuchen
  729. {
  730. if( !suchGCount )
  731. {
  732. bool b = 1;
  733. for( int ii = 0; ii < tl; ++ii ) // Text überprüfen
  734. b &= txt[ i + ii ] == t[ ii ];
  735. if( b )
  736. return 1;
  737. }
  738. if( txt[ i ] == suchGBeg )
  739. ++suchGCount;
  740. if( txt[ i ] == suchGEnd )
  741. --suchGCount;
  742. if( !suchGCount )
  743. {
  744. bool b = 1;
  745. for( int ii = 0; ii < tl; ++ii ) // Text überprüfen
  746. b &= txt[ i + ii ] == t[ ii ];
  747. if( b )
  748. return 1;
  749. }
  750. }
  751. return 0;
  752. }
  753. // Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
  754. // t: Der Text, nach dessen Inhalt gesucht werden soll
  755. // return: (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
  756. // pos: die position an der die zeichenkette im string beginnen soll
  757. bool Text::hatAt( int pos, Text *t ) const
  758. {
  759. bool ret = 0;
  760. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  761. ret = hatAt( pos, t->getText() ); // prüfen
  762. t = t->release(); // Übergabe loslassen
  763. return ret;
  764. }
  765. // Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
  766. // t: Die Zeichenkette, nach der gesucht werden soll
  767. // return: (true), wenn die Zeichenkette vorkommt. (false) sonnst
  768. // pos: die position an der die zeichenkette im string beginnen soll
  769. bool Text::hatAt( int pos, const char *t ) const
  770. {
  771. int tl = (int)strlen( t ); // Länge der Übergabe
  772. int txl = getLength(); // Länge des Textes
  773. if( tl <= 0 || tl + pos > txl ) // Auf unsinnige übergabe prüfen
  774. return 0;
  775. bool b = 1;
  776. for( int i = 0; i < tl; ++i ) // Text überprüfen
  777. b &= txt[ pos + i ] == t[ i ];
  778. return b;
  779. }
  780. bool Text::hat( char c ) const // enthält c
  781. {
  782. int l = getLength(); // Text Länge
  783. bool ret = 0;
  784. int suchGCount = 0;
  785. for( int i = 0; i < l; ++i ) // suchen
  786. {
  787. bool b = suchGCount != 0;
  788. if( !suchGCount ) // überprüfen
  789. ret |= txt[ i ] == c;
  790. if( txt[ i ] == suchGBeg )
  791. ++suchGCount;
  792. if( txt[ i ] == suchGEnd )
  793. --suchGCount;
  794. if( !suchGCount && b ) // überprüfen
  795. ret |= txt[ i ] == c;
  796. }
  797. return ret;
  798. }
  799. bool Text::istGleich( const char *t ) const // prüft ob det Text gleich t ist
  800. {
  801. int txl = getLength(); // Text Länge
  802. int tl = (int)strlen( t ); // Länge der Übergabe
  803. if( txl != tl ) // Auf unsinniege Übergabe prüfen
  804. return 0;
  805. if( txl == -1 )
  806. return 1;
  807. bool ret = true;
  808. for( int i = 0; i < tl; ++i ) // prüfen
  809. ret &= txt[ i ] == t[ i ];
  810. return ret;
  811. }
  812. bool Text::istGleich( Text *t ) const
  813. {
  814. bool ret = istGleich( t->getText() ); // prüfen
  815. t->release(); // Übergabe loslassen
  816. return ret;
  817. }
  818. char *Text::getText() const // gibt Text zurück
  819. {
  820. return txt;
  821. }
  822. int Text::anzahlVon( char c ) const // gibt die Anzahl von c im Text zurück
  823. {
  824. int ret = 0;
  825. int l = getLength(); // Text Länge
  826. int suchGCount = 0;
  827. for( int i = 0; i < l; ++i ) // suchen
  828. {
  829. bool b = suchGCount != 0;
  830. ret += txt[ i ] == c && !suchGCount; // zählen
  831. if( txt[ i ] == suchGBeg )
  832. ++suchGCount;
  833. if( txt[ i ] == suchGEnd )
  834. --suchGCount;
  835. ret += txt[ i ] == c && !suchGCount && b; // zählen
  836. }
  837. return ret;
  838. }
  839. int Text::anzahlVon( const char *t ) const // gibt die Anzahl von t im Text zurück
  840. {
  841. int tl = (int)strlen( t ); // Länge der Übergabe
  842. int txl = getLength(); // Länge des Textes
  843. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  844. return 0;
  845. int ret = 0;
  846. int suchGCount = 0;
  847. for( int i = 0; i + tl <= txl; ++i ) // suchen
  848. {
  849. bool b = suchGCount != 0;
  850. if( !suchGCount )
  851. {
  852. bool b = 1;
  853. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  854. b &= txt[ i + ii ] == t[ ii ];
  855. if( b )
  856. ++ret; // zählen
  857. }
  858. if( txt[ i ] == suchGBeg )
  859. ++suchGCount;
  860. if( txt[ i ] == suchGEnd )
  861. --suchGCount;
  862. if( !suchGCount && b )
  863. {
  864. bool b = 1;
  865. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  866. b &= txt[ i + ii ] == t[ ii ];
  867. if( b )
  868. ++ret; // zählen
  869. }
  870. }
  871. return ret;
  872. }
  873. int Text::anzahlVon( Text *t ) const
  874. {
  875. int ret = 0;
  876. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  877. ret = anzahlVon( t->getText() ); // zählen
  878. t = t->release(); // Übergabe loslassen
  879. return ret;
  880. }
  881. int Text::positionVon( char c ) const // gibt die Position des ersten c zurück
  882. {
  883. int l = getLength(); // Text Länge
  884. int suchGCount = 0;
  885. for( int i = 0; i < l; ++i ) // suchen
  886. {
  887. bool b = suchGCount != 0;
  888. if( txt[ i ] == c && !suchGCount ) // überprüfen
  889. return i;
  890. if( txt[ i ] == suchGBeg )
  891. ++suchGCount;
  892. if( txt[ i ] == suchGEnd )
  893. --suchGCount;
  894. if( txt[ i ] == c && !suchGCount && b ) // überprüfen
  895. return i;
  896. }
  897. return -1;
  898. }
  899. int Text::positionVon( const char *t ) const // gibt die Position des ersten t zurück
  900. {
  901. int tl = (int)strlen( t ); // Länge der Übergabe
  902. int txl = getLength(); // Länge des Textes
  903. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  904. return -1;
  905. int suchGCount = 0;
  906. for( int i = 0; i + tl <= txl; ++i ) // suchen
  907. {
  908. bool b = suchGCount != 0;
  909. if( !suchGCount )
  910. {
  911. bool b = 1;
  912. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  913. b &= txt[ i + ii ] == t[ ii ];
  914. if( b )
  915. return i;
  916. }
  917. if( txt[ i ] == suchGBeg )
  918. ++suchGCount;
  919. if( txt[ i ] == suchGEnd )
  920. --suchGCount;
  921. if( !suchGCount && b )
  922. {
  923. bool b = 1;
  924. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  925. b &= txt[ i + ii ] == t[ ii ];
  926. if( b )
  927. return i;
  928. }
  929. }
  930. return -1;
  931. }
  932. int Text::positionVon( Text *t ) const
  933. {
  934. int ret = 0;
  935. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  936. ret = positionVon( t->getText() ); // position ermitteln
  937. t = t->release(); // Übergabe loslassen
  938. return ret;
  939. }
  940. int Text::positionVon( char c, int index ) const // gibt die Position des i-ten c zurück
  941. {
  942. int l = getLength(); // Text Länge
  943. int ii = 0;
  944. int suchGCount = 0;
  945. for( int i = 0; i < l; ++i ) // suchen
  946. {
  947. bool b = suchGCount != 0;
  948. if( txt[ i ] == c && !suchGCount ) // überprüfen
  949. {
  950. if( ii == index )
  951. return i;
  952. else
  953. ++ii;
  954. }
  955. if( txt[ i ] == suchGBeg )
  956. ++suchGCount;
  957. if( txt[ i ] == suchGEnd )
  958. --suchGCount;
  959. if( txt[ i ] == c && !suchGCount && b ) // überprüfen
  960. {
  961. if( ii == index )
  962. return i;
  963. else
  964. ++ii;
  965. }
  966. }
  967. return -1;
  968. }
  969. int Text::positionVon( const char *t, int index ) const // gibt die Position des i-ten t zurück
  970. {
  971. int tl = (int)strlen( t ); // Länge der Übergabe
  972. int txl = getLength(); // Länge des Textes
  973. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  974. return 0;
  975. int i2 = 0;
  976. int suchGCount = 0;
  977. for( int i = 0; i + tl <= txl; ++i ) // suchen
  978. {
  979. bool b = suchGCount != 0;
  980. if( !suchGCount )
  981. {
  982. bool b = 1;
  983. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  984. b &= txt[ i + ii ] == t[ ii ];
  985. if( b )
  986. {
  987. if( i2 == index )
  988. return i;
  989. else
  990. ++i2;
  991. }
  992. }
  993. if( txt[ i ] == suchGBeg )
  994. ++suchGCount;
  995. if( txt[ i ] == suchGEnd )
  996. --suchGCount;
  997. if( !suchGCount && b )
  998. {
  999. bool b = 1;
  1000. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  1001. b &= txt[ i + ii ] == t[ ii ];
  1002. if( b )
  1003. {
  1004. if( i2 == index )
  1005. return i;
  1006. else
  1007. ++i2;
  1008. }
  1009. }
  1010. }
  1011. return -1;
  1012. }
  1013. int Text::positionVon( Text *t, int i ) const
  1014. {
  1015. int ret = 0;
  1016. if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
  1017. ret = positionVon( t->getText(), i ); // position ermitteln
  1018. t = t->release(); // Übergabe loslassen
  1019. return ret;
  1020. }
  1021. Text *Text::getTeilText( int p1, int p2 ) const // gibt den Text von p1 bis p2 zurück
  1022. {
  1023. if( p1 > p2 ) // p1 und p2 tauschen
  1024. {
  1025. int x = p1;
  1026. p1 = p2;
  1027. p2 = x;
  1028. }
  1029. int l = getLength(); // Text Länge
  1030. if( p1 < 0 || p2 > l ) // Auf unsinnige übergabe prüfen
  1031. return new Text( "" );
  1032. char *cp = new char[ p2 - p1 + 1 ]; // neuen Text erstellen
  1033. for( int i = p1; i < p2; ++i ) // Text befüllen
  1034. {
  1035. cp[ i - p1 ] = txt[ i ];
  1036. }
  1037. cp[ p2 - p1 ] = '\0';
  1038. Text *t = new Text( cp ); // Text zurückgeben
  1039. delete[]cp;
  1040. return t;
  1041. }
  1042. Text *Text::getTeilText( int p ) const // gibt den Text von p bis zum Ende zurück
  1043. {
  1044. return getTeilText( p, getLength() ); // Text zurückgeben
  1045. }
  1046. // Reference Counting
  1047. Text *Text::getThis()
  1048. {
  1049. ++ref;
  1050. return this;
  1051. }
  1052. Text *Text::release()
  1053. {
  1054. --ref;
  1055. if( ref < 1 )
  1056. delete this;
  1057. return 0;
  1058. }
  1059. // Operatoren
  1060. Text &Text::operator+=( const int num )
  1061. {
  1062. append( num );
  1063. return *this;
  1064. }
  1065. // Hängt eine Zahl ans Ende des Textes an
  1066. Text &Text::operator+=( const __int64 num )
  1067. {
  1068. append( num );
  1069. return *this;
  1070. }
  1071. Text &Text::operator+=( const double num )
  1072. {
  1073. append( num );
  1074. return *this;
  1075. }
  1076. Text &Text::operator+=( const float num )
  1077. {
  1078. append( num );
  1079. return *this;
  1080. }
  1081. Text &Text::operator+=( const char *txt )
  1082. {
  1083. append( txt );
  1084. return *this;
  1085. }
  1086. Text &Text::operator+=( const Text &txt )
  1087. {
  1088. append( txt.getText() );
  1089. return *this;
  1090. }
  1091. Text &Text::operator=( const int num )
  1092. {
  1093. setText( "" );
  1094. append( num );
  1095. return *this;
  1096. }
  1097. Text &Text::operator=( const double num )
  1098. {
  1099. setText( "" );
  1100. append( num );
  1101. return *this;
  1102. }
  1103. Text &Text::operator=( const float num )
  1104. {
  1105. setText( "" );
  1106. append( num );
  1107. return *this;
  1108. }
  1109. Text &Text::operator=( const char *txt )
  1110. {
  1111. setText( txt );
  1112. return *this;
  1113. }
  1114. Text &Text::operator=( const Text &txt )
  1115. {
  1116. setText( txt.getText() );
  1117. return *this;
  1118. }
  1119. Text::operator char*( ) const
  1120. {
  1121. return txt;
  1122. }
  1123. Text::operator int() const
  1124. {
  1125. if( getLength() > 2 && txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
  1126. return TextZuInt( ( txt + 2 ), 16 );
  1127. return TextZuInt( txt, 10 );
  1128. }
  1129. Text::operator __int64() const
  1130. {
  1131. if( getLength() > 2 && txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
  1132. return TextZuInt64( ( txt + 2 ), 16 );
  1133. return TextZuInt64( txt, 10 );
  1134. }
  1135. Text::operator double() const
  1136. {
  1137. return TextZuDouble( txt );
  1138. }
  1139. Text::operator float() const
  1140. {
  1141. return TextZuFloat( txt );
  1142. }
  1143. bool Text::operator>( Text &t ) const
  1144. {
  1145. int len1 = getLength();
  1146. int len2 = t.getLength();
  1147. char *txt2 = t;
  1148. for( int i = 0; i < len1 && i < len2; ++i )
  1149. {
  1150. if( txt[ i ] > txt2[ i ] )
  1151. return 1;
  1152. if( txt[ i ] < txt2[ i ] )
  1153. return 0;
  1154. }
  1155. if( len1 > len2 )
  1156. return 1;
  1157. return 0;
  1158. }
  1159. bool Text::operator<( Text &t ) const
  1160. {
  1161. int len1 = getLength();
  1162. int len2 = t.getLength();
  1163. char *txt2 = t;
  1164. for( int i = 0; i < len1 && i < len2; ++i )
  1165. {
  1166. if( txt[ i ] < txt2[ i ] )
  1167. return 1;
  1168. if( txt[ i ] > txt2[ i ] )
  1169. return 0;
  1170. }
  1171. if( len1 < len2 )
  1172. return 1;
  1173. return 0;
  1174. }
  1175. // Inhalt der TextReader Klasse
  1176. // Konstructor
  1177. // txt: Der Text der gelesen werden soll. Er wird nicht kopiert sondern direkt gelesen.
  1178. TextReader::TextReader( Text *txt )
  1179. {
  1180. this->txt = txt;
  1181. lPos = 0;
  1182. ref = 1;
  1183. }
  1184. // Destructor
  1185. TextReader::~TextReader()
  1186. {
  1187. txt->release();
  1188. }
  1189. // Setzt die Position des Bytes, das als nächstes gelesen werden soll
  1190. // pos: Der Index des Bytes
  1191. // ende: 1, wenn der Index vom ende des Textes zählt. 0, wenn der Index vom Beginn des Textes zählt
  1192. void TextReader::setLPosition( __int64 pos, bool ende )
  1193. {
  1194. int l = txt->getLength();
  1195. lPos = ende ? l - pos : pos;
  1196. if( lPos < 0 )
  1197. lPos = 0;
  1198. if( lPos > l )
  1199. lPos = l;
  1200. }
  1201. // Ließt aus der Datei
  1202. // bytes: Ein Array, der mit Bytes aus dem Text gefüllt werden soll
  1203. // len: Wie viele Bytes aus dem Text gelesen werden sollen
  1204. void TextReader::lese( char *bytes, int len )
  1205. {
  1206. int l = txt->getLength();
  1207. len = (int)MIN( l - lPos, len );
  1208. for( __int64 i = lPos; i < lPos + len; i++ )
  1209. bytes[ i - lPos ] = txt->getText()[ i ];
  1210. lPos += len;
  1211. }
  1212. // Ließt die nächste zeile des Textes ein
  1213. // return: Die gelesene Zeile als Text mit zeilenumbruch
  1214. Text *TextReader::leseZeile()
  1215. {
  1216. if( istEnde() )
  1217. return 0;
  1218. Text *ret = new Text( "" );
  1219. __int64 len = txt->getLength();
  1220. for( char c = 0; c != '\n' && lPos < len; )
  1221. {
  1222. lese( &c, 1 );
  1223. if( c )
  1224. ret->append( (const char*)&c, 1 );
  1225. }
  1226. return ret;
  1227. }
  1228. // Prüft, ob die Resource vollständig gelesen wurde
  1229. // return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
  1230. bool TextReader::istEnde() const
  1231. {
  1232. return lPos >= txt->getLength();
  1233. }
  1234. // Gibt den Index des Bytes aus dem Text zurück, welches als nächstes gelesen werden würde
  1235. // return -1, falls ein Fehler aufgetreten ist. Sonst die Position des Lesezeigers
  1236. __int64 TextReader::getLPosition() const
  1237. {
  1238. return lPos;
  1239. }
  1240. // Erhöht den Reference Counting Zähler.
  1241. // return: this.
  1242. TextReader *TextReader::getThis()
  1243. {
  1244. ref++;
  1245. return this;
  1246. }
  1247. // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
  1248. // return: 0.
  1249. TextReader *TextReader::release()
  1250. {
  1251. if( !--ref )
  1252. delete this;
  1253. return 0;
  1254. }
  1255. // char* operationen
  1256. int Framework::stringPositionVonChar( char *string, char c, int num ) // sucht die position des num-ten c-s in string, -1 bei nicht gefunden
  1257. {
  1258. int gef = 0;
  1259. int p = 0;
  1260. for( char cc = *string; *string; ++string )
  1261. {
  1262. if( cc == c )
  1263. {
  1264. if( gef == num )
  1265. return p;
  1266. else
  1267. ++gef;
  1268. }
  1269. ++p;
  1270. }
  1271. return -1;
  1272. }
  1273. int Framework::stringPositionVonString( char *string, char *suche, int sBegPos ) // sucht die position von 'suche' in 'string' ab der Position 'sBegPos', -1 bei nicht gefunden
  1274. {
  1275. for( int i = 0; i < sBegPos; ++i )
  1276. {
  1277. if( !*string )
  1278. return -1;
  1279. ++string;
  1280. }
  1281. int tl = textLength( suche ); // Länge der Übergabe
  1282. int txl = textLength( string ); // Länge des Textes
  1283. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  1284. return -1;
  1285. for( int i = 0; i + tl <= txl; ++i ) // suchen
  1286. {
  1287. bool b = 1;
  1288. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  1289. if( b )
  1290. b = string[ i + ii ] == suche[ ii ];
  1291. if( b )
  1292. return i + sBegPos;
  1293. }
  1294. return -1;
  1295. }
  1296. //---Andere Funktionen---
  1297. void Framework::TextKopieren( const char *txt ) // kopiert den Text in den Zwischenspeicher
  1298. {
  1299. #ifdef WIN32
  1300. int län = textLength( txt ) + 1;
  1301. if( län == 1 )
  1302. return;
  1303. HGLOBAL hMem = GlobalAlloc( GMEM_MOVEABLE, län );
  1304. if( !hMem )
  1305. return;
  1306. memcpy( GlobalLock( hMem ), txt, län );
  1307. GlobalUnlock( hMem );
  1308. OpenClipboard( 0 );
  1309. EmptyClipboard();
  1310. SetClipboardData( CF_TEXT, hMem );
  1311. CloseClipboard();
  1312. #endif
  1313. }
  1314. char *Framework::TextInsert() // gibt den Text aus der Zwischenablage zurück
  1315. {
  1316. #ifdef WIN32
  1317. if( !OpenClipboard( 0 ) )
  1318. return "";
  1319. HANDLE hClipData = GetClipboardData( CF_TEXT );
  1320. char *cBuffer = (char*)GlobalLock( hClipData );
  1321. GlobalUnlock( hClipData );
  1322. CloseClipboard();
  1323. return cBuffer;
  1324. #else
  1325. return 0;
  1326. #endif
  1327. }
  1328. char Framework::smallOrBig( char c, bool gr )
  1329. {
  1330. int ret = c;
  1331. if( gr )
  1332. {
  1333. if( c >= 'a' && c <= 'z' )
  1334. ret -= 32;
  1335. else
  1336. {
  1337. switch( c )
  1338. {
  1339. case '^':
  1340. return '°';
  1341. case '1':
  1342. return '!';
  1343. case '<':
  1344. return '>';
  1345. case '2':
  1346. return '\"';
  1347. case '3':
  1348. return '§';
  1349. case '4':
  1350. return '$';
  1351. case '5':
  1352. return '%';
  1353. case '6':
  1354. return '&';
  1355. case '7':
  1356. return '/';
  1357. case '8':
  1358. return '(';
  1359. case '9':
  1360. return ')';
  1361. case '0':
  1362. return '=';
  1363. case ',':
  1364. return ';';
  1365. case '.':
  1366. return ':';
  1367. case 'ß':
  1368. return '?';
  1369. case '-':
  1370. return '_';
  1371. case '´':
  1372. return '`';
  1373. case '+':
  1374. return '*';
  1375. case '#':
  1376. return '\'';
  1377. case 'ü':
  1378. return 'Ü';
  1379. case 'ö':
  1380. return 'Ö';
  1381. case 'ä':
  1382. return 'Ä';
  1383. }
  1384. }
  1385. }
  1386. else
  1387. {
  1388. if( c >= 'A' && c <= 'Z' )
  1389. ret += 32;
  1390. else
  1391. {
  1392. switch( c )
  1393. {
  1394. case '°':
  1395. return '^';
  1396. case '!':
  1397. return '1';
  1398. case '>':
  1399. return '<';
  1400. case '\"':
  1401. return '2';
  1402. case '§':
  1403. return '3';
  1404. case '$':
  1405. return '4';
  1406. case '%':
  1407. return '5';
  1408. case '&':
  1409. return '6';
  1410. case '/':
  1411. return '7';
  1412. case '(':
  1413. return '8';
  1414. case ')':
  1415. return '9';
  1416. case '=':
  1417. return '0';
  1418. case ';':
  1419. return ',';
  1420. case ':':
  1421. return '.';
  1422. case '?':
  1423. return 'ß';
  1424. case '_':
  1425. return '-';
  1426. case '`':
  1427. return '´';
  1428. case '*':
  1429. return '+';
  1430. case '\'':
  1431. return '#';
  1432. case 'Ü':
  1433. return 'ü';
  1434. case 'Ö':
  1435. return 'ö';
  1436. case 'Ä':
  1437. return 'ä';
  1438. }
  1439. }
  1440. }
  1441. return (char)ret;
  1442. }
  1443. bool Framework::istSchreibbar( unsigned char zeichen ) // prüft, ob zeichen ein Schreibbarer Buchstabe ist
  1444. {
  1445. if( zeichen > 32 && zeichen < 127 )
  1446. return 1;
  1447. if( zeichen == 128 || zeichen == 181 || zeichen == 178 || zeichen == 179 )
  1448. return 1;
  1449. if( zeichen > 191 && zeichen < 198 )
  1450. return 1;
  1451. if( zeichen > 199 && zeichen < 208 )
  1452. return 1;
  1453. if( zeichen > 209 && zeichen < 215 )
  1454. return 1;
  1455. if( zeichen > 216 && zeichen < 221 )
  1456. return 1;
  1457. if( zeichen > 222 && zeichen < 230 )
  1458. return 1;
  1459. if( zeichen > 231 && zeichen < 240 )
  1460. return 1;
  1461. if( zeichen > 241 && zeichen < 247 )
  1462. return 1;
  1463. if( zeichen > 248 && zeichen < 253 )
  1464. return 1;
  1465. if( zeichen == ' ' || zeichen == '\t' )
  1466. return 1;
  1467. return 0;
  1468. }
  1469. unsigned int Framework::TextZuInt( char *c, int system ) // Konvertiert c zu int
  1470. {
  1471. if( system == 16 )
  1472. return (unsigned int)strtoul( c, 0, system );
  1473. return (unsigned int)strtol( c, 0, system );
  1474. }
  1475. unsigned int Framework::TextZuInt( char *c, char **c_ende, int system )
  1476. {
  1477. if( system == 16 )
  1478. return (unsigned int)strtoul( c, c_ende, system );
  1479. return (unsigned int)strtol( c, c_ende, system );
  1480. }
  1481. unsigned __int64 Framework::TextZuInt64( char *c, int system )
  1482. {
  1483. if( system == 16 )
  1484. return strtoull( c, 0, system );
  1485. return (unsigned __int64)strtoll( c, 0, system );
  1486. }
  1487. unsigned __int64 Framework::TextZuInt64( char *c, char **c_ende, int system )
  1488. {
  1489. if( system == 16 )
  1490. return strtoull( c, c_ende, system );
  1491. return (unsigned __int64)strtoll( c, c_ende, system );
  1492. }
  1493. double Framework::TextZuDouble( char *c ) // Konvertiert c zu double
  1494. {
  1495. return strtod( c, 0 );
  1496. }
  1497. float Framework::TextZuFloat( char *c ) // Konvertiert c zu double
  1498. {
  1499. return strtof( c, 0 );
  1500. }
  1501. double Framework::TextZuDouble( char *c, char **c_ende )
  1502. {
  1503. return strtod( c, c_ende );
  1504. }
  1505. float Framework::TextZuFloat( char *c, char **c_ende )
  1506. {
  1507. return strtof( c, c_ende );
  1508. }
  1509. int Framework::textLength( const char *txt ) // gibt die Länge von txt zurück
  1510. {
  1511. if( !txt )
  1512. return 0;
  1513. int ret = 0;
  1514. for( ; txt[ ret ] != 0; ++ret );
  1515. return ret;
  1516. }