Text.cpp 30 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346
  1. //---Include---
  2. #include "Text.h"
  3. #include <sstream>
  4. #include <string>
  5. #include <stdlib.h>
  6. #include <stdio.h>
  7. #include <iomanip>
  8. #ifndef WIN32
  9. #include <string.h>
  10. #endif
  11. using namespace Framework;
  12. // inhalt der Text Klasse aus Text.h
  13. // Konstruktor
  14. Text::Text()
  15. : txt( 0 ),
  16. suchGBeg( 0 ),
  17. suchGEnd( 0 ),
  18. präzision( 0 ),
  19. ref( 1 )
  20. {
  21. setText( "" );
  22. }
  23. Text::Text( const Text &txt )
  24. : txt( 0 ),
  25. suchGBeg( 0 ),
  26. suchGEnd( 0 ),
  27. präzision( 0 ),
  28. ref( 1 )
  29. {
  30. setText( txt );
  31. }
  32. Text::Text( const char *t )
  33. : txt( 0 ),
  34. suchGBeg( 0 ),
  35. suchGEnd( 0 ),
  36. präzision( 0 ),
  37. ref( 1 )
  38. {
  39. setText( t ); // Text setzen
  40. }
  41. Text::Text( int zahl )
  42. : txt( 0 ),
  43. suchGBeg( 0 ),
  44. suchGEnd( 0 ),
  45. präzision( 0 ),
  46. ref( 1 )
  47. {
  48. *this = zahl;
  49. }
  50. // Destruktor
  51. Text::~Text()
  52. {
  53. delete[]txt;
  54. }
  55. // nicht constant
  56. void Text::setSuchGrenzen( char gBeg, char gEnd ) // sucht bei jeder suchfunktion nicht zwischen den Zeichen gBeg und gEnd
  57. {
  58. suchGBeg = gBeg;
  59. suchGEnd = gEnd;
  60. }
  61. void Text::setText( const char *t ) // ersetzt den Text
  62. {
  63. delete[]txt; // alter Text löschen
  64. int l = (int)strlen( t ); // Länge des neuen Textes ermitteln
  65. txt = new char[ l + 1 ]; // neuen Text erstellen
  66. for( int i = 0; i < l; ++i ) // Text befüllen
  67. txt[ i ] = t[ i ];
  68. txt[ l ] = '\0'; // Textende Festlegen
  69. }
  70. // unconstant
  71. void Text::setText( const char *t, int l ) // ersetzt den Text
  72. {
  73. delete[]txt; // alter Text löschen
  74. txt = new char[ l + 1 ]; // neuen Text erstellen
  75. for( int i = 0; i < l; ++i ) // Text befüllen
  76. txt[ i ] = t[ i ];
  77. txt[ l ] = '\0'; // Textende Festlegen
  78. }
  79. void Text::setText( Text *t )
  80. {
  81. setText( t->getText() ); // Text setzen
  82. t = t->release(); // übergabe loslassen
  83. }
  84. void Text::anhängen( char c ) // hängt an den Text an
  85. {
  86. anhängen( &c, 1 );
  87. }
  88. void Text::anhängen( const char *t ) // hängt an den Text an
  89. {
  90. int tl = (int)strlen( t ); // länge der übergabe
  91. int txl = getLänge(); // länge des Textes
  92. char *res = new char[ tl + txl + 1 ]; // neuen Text erstellen
  93. for( int i = 0; i < txl; ++i ) // mit jetzigem Text füllen
  94. res[ i ] = txt[ i ];
  95. for( int i = 0; i < tl; ++i ) // Übergabe anhängen
  96. res[ txl + i ] = t[ i ];
  97. res[ txl + tl ] = '\0'; // Textende festlegen
  98. setText( res ); // Test setzen
  99. delete[] res; // Speicher freigeben
  100. }
  101. void Text::hexAnhängen( int num ) // hängt die zahl in hex anden Text an
  102. {
  103. int l = getLänge();
  104. char *res = new char[ l + 9 ];
  105. for( int i = 0; i < l; ++i )
  106. res[ i ] = txt[ i ];
  107. std::stringstream stream;
  108. stream << std::setfill( '0' ) << std::setw( sizeof( int ) * 2 ) << std::hex << num;
  109. std::string str = stream.str();
  110. for( int i = l; i < l + 8; ++i )
  111. res[ i ] = str.c_str()[ i - l ];
  112. res[ l + 8 ] = 0;
  113. setText( res );
  114. delete[] res;
  115. }
  116. void Text::farbeAnhängen( int fc ) // setzt die Farbe des folgenden Textes
  117. {
  118. int l = getLänge();
  119. char *res = new char[ l + 12 ];
  120. for( int i = 0; i < l; ++i )
  121. res[ i ] = txt[ i ];
  122. res[ l ] = '\r';
  123. res[ l + 1 ] = '0';
  124. res[ l + 2 ] = 'x';
  125. std::stringstream stream;
  126. stream << std::setfill( '0' ) << std::setw( sizeof( int ) * 2 ) << std::hex << fc;
  127. std::string str = stream.str();
  128. for( int i = l + 3; i < l + 11; ++i )
  129. res[ i ] = str.c_str()[ i - ( l + 3 ) ];
  130. res[ l + 11 ] = 0;
  131. setText( res );
  132. delete[] res;
  133. }
  134. void Text::anhängen( const char *t, int l ) // hängt an den Text an
  135. {
  136. int txl = getLänge(); // länge des Textes
  137. char *res = new char[ l + txl + 1 ]; // neuen Text erstellen
  138. for( int i = 0; i < txl; ++i ) // mit jetzigem Text füllen
  139. res[ i ] = txt[ i ];
  140. for( int i = 0; i < l; ++i ) // Übergabe anhängen
  141. res[ txl + i ] = t[ i ];
  142. res[ txl + l ] = '\0'; // Textende festlegen
  143. setText( res, txl + l ); // Test setzen
  144. delete[] res; // Speicher freigeben
  145. }
  146. void Text::anhängen( Text *t )
  147. {
  148. if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
  149. anhängen( t->getText() ); // Text anhängen
  150. t = t->release(); // Übergabe loslassen
  151. }
  152. void Text::anhängen( int num )
  153. {
  154. std::stringstream ss;
  155. ss << num;
  156. anhängen( ss.str().c_str() );
  157. }
  158. void Text::anhängen( unsigned int num )
  159. {
  160. std::stringstream ss;
  161. ss << num;
  162. anhängen( ss.str().c_str() );
  163. }
  164. void Text::anhängen( double num )
  165. {
  166. std::stringstream ss;
  167. ss.precision( präzision );
  168. ss << num;
  169. anhängen( ss.str().c_str() );
  170. }
  171. void Text::einfügen( int p, char c ) // Fügt an stelle p ein
  172. {
  173. if( p > getLänge() || p < 0 ) // Auf unsinnige übergabe prüfen
  174. return;
  175. int txl = getLänge(); // Länge des Textes
  176. char *res = new char[ txl + 2 ]; // neuer Text erstellen
  177. for( int i = 0; i < p; ++i ) // Text füllen
  178. res[ i ] = txt[ i ];
  179. res[ p ] = c;
  180. for( int i = p; i < txl; ++i ) // Text füllen
  181. res[ i + 1 ] = txt[ i ];
  182. res[ txl + 1 ] = '\0'; // Text ende festlegen
  183. setText( res ); // Text setzen
  184. delete[] res; // Speicher freigeben
  185. }
  186. void Text::einfügen( int p, const char *t ) // Fügt an stelle p ein
  187. {
  188. if( p > getLänge() || p < 0 || strlen( t ) <= 0 ) // Auf unsinnige übergabe prüfen
  189. return;
  190. int tl = (int)strlen( t ); // Länge der übergabe
  191. int txl = getLänge(); // Länge des Textes
  192. char *res = new char[ tl + txl + 1 ]; // neuer Text erstellen
  193. for( int i = 0; i < p; ++i ) // Text füllen
  194. res[ i ] = txt[ i ];
  195. for( int i = 0; i < tl; ++i ) // Text einfügen
  196. res[ i + p ] = t[ i ];
  197. for( int i = p; i < txl; ++i ) // Text füllen
  198. res[ i + tl ] = txt[ i ];
  199. res[ tl + txl ] = '\0'; // Text ende festlegen
  200. setText( res ); // Text setzen
  201. delete[] res; // Speicher freigeben
  202. }
  203. void Text::einfügen( int p, Text *t )
  204. {
  205. if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
  206. einfügen( p, t->getText() ); // Text einfügen
  207. t = t->release(); // Übergabe loslassen
  208. }
  209. void Text::ersetzen( int p1, int p2, const char *t ) // Ersetzt den Text von p1 bis p2
  210. {
  211. if( p1 > p2 )
  212. {
  213. int x = p1; // p1 und p2 tauschen
  214. p1 = p2;
  215. p2 = x;
  216. }
  217. löschen( p1, p2 ); // Textabschnitt von p1 zu p2 löschen
  218. einfügen( p1, t ); // Übergabe bei p1 einfügen
  219. }
  220. void Text::ersetzen( int p1, int p2, Text *t )
  221. {
  222. if( t->getLänge() >= 0 ) // Auf unsinnige übergabe prüfen
  223. ersetzen( p1, p2, t->getText() ); // Text ersetzen
  224. t = t->release(); // Übergabe loslassen
  225. }
  226. void Text::ersetzen( char c1, char c2 ) // ersetzt jedes c1 durch c2
  227. {
  228. if( c1 == '\0' || c2 == '\0' ) // Auf unsinnige übergabe prüfen
  229. return;
  230. if( !hat( c1 ) ) // prüfen ob c1 vorhanden
  231. return;
  232. int l = getLänge(); // Text Länge
  233. int suchGCount = 0;
  234. for( int i = 0; i < l; ++i ) // Text durchsuchen
  235. {
  236. bool b = suchGCount != 0;
  237. if( txt[ i ] == c1 && !suchGCount )
  238. txt[ i ] = c2; // Text ersetzen
  239. if( txt[ i ] == suchGBeg )
  240. ++suchGCount;
  241. if( txt[ i ] == suchGEnd )
  242. --suchGCount;
  243. if( txt[ i ] == c1 && !suchGCount && b )
  244. txt[ i ] = c2; // Text ersetzen
  245. }
  246. }
  247. void Text::ersetzen( const char *t1, const char *t2 ) // ersetzt jedes t1 durch t2
  248. {
  249. int txl = getLänge(); // Text Länge
  250. int t1l = (int)strlen( t1 ); // Länge der Übergaben
  251. int t2l = (int)strlen( t2 );
  252. if( t1l > txl || t1l <= 0 ) // Auf unsinnige übergabe prüfen
  253. return;
  254. if( !hat( t1 ) ) // prüfen ob t1 vorhanden
  255. return;
  256. int anz = anzahlVon( t1 ); // Anzahl von t1 im Text
  257. int *begin = new int[ anz ];
  258. int *end = new int[ anz ];
  259. for( int i = 0; i < anz; ++i ) // Positionen von t1 speichern
  260. {
  261. begin[ i ] = positionVon( t1, i );
  262. end[ i ] = begin[ i ] + t1l;
  263. }
  264. int resl = ( txl - ( anz * t1l ) ) + ( anz * t2l ) + 1; // Länge des Ergebneses
  265. char *res = new char[ resl ]; // neuer Text erstellen
  266. int rep = 0; // Speichert bei welchen t1 man sich befindet
  267. int last = 0; // Füllposition von txt
  268. int neu = 0; // Füllporition von res
  269. for( ; neu < resl; ++neu ) // Text befüllen
  270. {
  271. if( rep < anz && last == begin[ rep ] ) // Text ersetzen
  272. {
  273. last = end[ rep ];
  274. ++rep;
  275. for( int ii = 0; ii < t2l; ++ii )
  276. {
  277. if( neu >= resl )
  278. break;
  279. res[ neu ] = t2[ ii ];
  280. ++neu;
  281. }
  282. if( neu >= resl )
  283. break;
  284. --neu;
  285. }
  286. else // Text Kopieren
  287. {
  288. res[ neu ] = txt[ last ];
  289. ++last;
  290. }
  291. }
  292. res[ resl - 1 ] = '\0'; // Textende festlegen
  293. setText( res ); // Text setzen
  294. delete[]begin; // Speicher freigeben
  295. delete[]end;
  296. delete[] res;
  297. }
  298. void Text::ersetzen( Text *t1, const char *t2 )
  299. {
  300. if( t1->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
  301. ersetzen( t1->getText(), t2 ); // ersetzen
  302. t1 = t1->release(); // Übergabe loslassen
  303. }
  304. void Text::ersetzen( const char *t1, Text *t2 )
  305. {
  306. if( t2->getLänge() >= 0 ) // Auf unsinnige übergabe prüfen
  307. ersetzen( t1, t2->getText() ); // ersetzen
  308. t2 = t2->release(); // Übergabe loslassen
  309. }
  310. void Text::ersetzen( Text *t1, Text *t2 )
  311. {
  312. if( t1->getLänge() > 0 && t2->getLänge() >= 0 ) // Auf unsinnige übergabe prüfen
  313. ersetzen( t1->getText(), t2->getText() ); // ersetzen
  314. t1 = t1->release(); // Übergaben loslassen
  315. t2 = t2->release();
  316. }
  317. void Text::ersetzen( int index, char c1, char c2 ) // ersetzt das i-te c1 durch c2
  318. {
  319. if( c1 == '\0' || c2 == '\0' || index < 0 ) // Auf unsinnige übergabe prüfen
  320. return;
  321. if( !hat( c1 ) ) // prüfen ob c1 vorhanden
  322. return;
  323. int anz = anzahlVon( c1 );
  324. if( index >= anz ) // prüfen ob es ein i-tes c1 gibt
  325. return;
  326. txt[ positionVon( c1, index ) ] = c2;
  327. }
  328. void Text::ersetzen( int index, const char *t1, const char *t2 ) // ersetzt das i-te t1 durch t2
  329. {
  330. int txl = getLänge(); // Text Länge
  331. int t1l = (int)strlen( t1 ); // Länge der Übergaben
  332. if( t1l >= txl || t1l <= 0 || index < 0 ) // Auf unsinnige übergabe prüfen
  333. return;
  334. if( !hat( t1 ) ) // prüfen ob t1 vorhanden
  335. return;
  336. int anz = anzahlVon( t1 ); // Anzahl von t1 im Text
  337. if( index >= anz ) // prüfen ob es ein i-tes t1 gibt
  338. return;
  339. int begin = positionVon( t1, index );
  340. int end = begin + t1l;
  341. ersetzen( begin, end, t2 ); // ersetzen
  342. }
  343. void Text::ersetzen( int i, Text *t1, const char *t2 )
  344. {
  345. if( t1->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
  346. ersetzen( i, t1->getText(), t2 ); // ersetzen
  347. t1 = t1->release(); // Übergabe loslassen
  348. }
  349. void Text::ersetzen( int i, const char *t1, Text *t2 )
  350. {
  351. if( t2->getLänge() >= 0 ) // Auf unsinnige übergabe prüfen
  352. ersetzen( i, t1, t2->getText() ); // ersetzen
  353. t2 = t2->release(); // Übergabe loslassen
  354. }
  355. void Text::ersetzen( int i, Text *t1, Text *t2 )
  356. {
  357. if( t1->getLänge() > 0 || t2->getLänge() >= 0 ) // Auf unsinnige übergabe prüfen
  358. ersetzen( i, t1->getText(), t2->getText() ); // ersetzen
  359. t1 = t1->release(); // Übergaben loslassen
  360. t2 = t2->release();
  361. }
  362. void Text::füllText( char c, int län ) // setzt den Text zu so vielen c wie län groß ist
  363. {
  364. char *res = new char[ län + 1 ];
  365. for( int i = 0; i < län; ++i )
  366. res[ i ] = c;
  367. res[ län ] = '\0';
  368. setText( res );
  369. delete[] res;
  370. }
  371. void Text::löschen( int p ) // löscht p
  372. {
  373. int l = getLänge(); // Text Länge
  374. if( p < 0 || p >= l ) // Auf unsinnige übergabe prüfen
  375. return;
  376. char *res = new char[ l ]; // neuen Text anlegen
  377. for( int i = 0; i < p && i < l; ++i ) // Text befüllen
  378. res[ i ] = txt[ i ];
  379. for( int i = p + 1; i < l; ++i )
  380. res[ i - 1 ] = txt[ i ];
  381. res[ l - 1 ] = 0;
  382. setText( res ); // Text setzen
  383. delete[] res; // Speicher freigeben
  384. }
  385. void Text::löschen( int p1, int p2 ) // löscht von p1 zu p2 ( p2 bleibt )
  386. {
  387. if( p1 > p2 ) // p1 und p2 tauschen
  388. {
  389. int x = p1;
  390. p1 = p2;
  391. p2 = x;
  392. }
  393. int l = getLänge(); // Länge des Testes
  394. if( p1 < 0 || p2 > l ) // Auf unsinnige übergabe prüfen
  395. return;
  396. int resl = l - ( p2 - p1 ); // Länge vom Ergebnis
  397. char *res = new char[ resl + 1 ]; // Neuen Text erstellen
  398. for( int i = 0; i < p1; ++i ) // Text füllen
  399. res[ i ] = txt[ i ];
  400. for( int i = p2; i < l; ++i )
  401. res[ i - ( p2 - p1 ) ] = txt[ i ];
  402. res[ resl ] = '\0'; // Testende festlegen
  403. setText( res ); // Text setzen
  404. delete[] res; // Speicher freigeben
  405. }
  406. void Text::löschen( char c ) // löscht jetes c
  407. {
  408. if( !hat( c ) ) // prüfen ob c vorhanden
  409. return;
  410. int l = getLänge(); // Länge des Textes
  411. int anz = anzahlVon( c ); // Anzahl von c
  412. char *res = new char[ l - anz + 1 ]; // neuen Text erstellen
  413. int anz2 = 0;
  414. int suchGCount = 0;
  415. for( int i = 0; i < l; ++i ) // Text befüllen
  416. {
  417. bool b = suchGCount != 0;
  418. if( txt[ i ] == c && !suchGCount )
  419. ++anz2;
  420. else
  421. res[ i - anz2 ] = txt[ i ];
  422. if( txt[ i ] == suchGBeg )
  423. ++suchGCount;
  424. if( txt[ i ] == suchGEnd )
  425. --suchGCount;
  426. if( b )
  427. {
  428. if( txt[ i ] == c && !suchGCount )
  429. ++anz2;
  430. else
  431. res[ i - anz2 ] = txt[ i ];
  432. }
  433. }
  434. res[ l - anz ] = '\0'; // Textende festlegen
  435. setText( res ); // Text setzen
  436. delete[] res; // Speicher freigeben
  437. }
  438. void Text::löschen( const char *t ) // löscht jetes t
  439. {
  440. int tl = (int)strlen( t ); // Länge der Übergabe
  441. int txl = getLänge(); // Länge des Textes
  442. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  443. return;
  444. if( !hat( t ) ) // prüfen ob Text ein t enthält
  445. return;
  446. int anz = anzahlVon( t ); // anzahl von t
  447. int *begin = new int[ anz ];
  448. for( int i = 0; i < anz; ++i ) // begin aller t-s finden
  449. begin[ i ] = positionVon( t, i );
  450. int resl = txl - ( anz * tl ); // Länge vom Ergebnes
  451. char *res = new char[ resl + 1 ]; // neuen Text erzeugen
  452. int del = 0;
  453. for( int i = 0; i < txl; ++i ) // Text befüllen
  454. {
  455. if( del < anz && i == begin[ del ] ) // Text auslassen
  456. {
  457. i += tl - 1;
  458. ++del;
  459. }
  460. else
  461. res[ i - ( del * tl ) ] = txt[ i ]; // Text befüllen
  462. }
  463. res[ resl ] = '\0'; // Text ende festlegen
  464. setText( res ); // Text setzen
  465. delete[]begin;
  466. delete[] res; // Speicher freigeben
  467. }
  468. void Text::löschen( Text *t )
  469. {
  470. if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
  471. löschen( t->getText() ); // löschen
  472. t = t->release(); // Übergabe loslassen
  473. }
  474. void Text::löschen( int index, char c )
  475. {
  476. if( index < 0 || !hat( c ) ) // Auf unsinnige übergabe prüfen
  477. return;
  478. int anz = anzahlVon( c ); // anzahl der i-s
  479. if( index >= anz ) // prüfen ob ein i-tes c vorhanden ist
  480. return;
  481. int pos = positionVon( c, index ); // Position vom i-ten c
  482. if( pos < 0 )
  483. return;
  484. int l = getLänge(); // Länge des Textes
  485. if( !l )
  486. return;
  487. char *res = new char[ l ]; // neuen Text erzeugen
  488. for( int i = 0; i < pos && i < l; ++i ) // Text befüllen
  489. res[ i ] = txt[ i ];
  490. for( int i = pos + 1; i < l; ++i )
  491. res[ i - 1 ] = txt[ i ];
  492. res[ l - 1 ] = '\0'; // Text ende festlegen
  493. setText( res ); // Text setzen
  494. delete[] res; // Speicher freigeben
  495. }
  496. void Text::löschen( int index, const char *t ) // löscht das i-te t
  497. {
  498. int tl = (int)strlen( t ); // Länge der Übergabe
  499. if( index < 0 || !hat( t ) || tl <= 0 ) // Auf unsinnige übergabe prüfen
  500. return;
  501. int anz = anzahlVon( t ); // anzahl der i-s
  502. if( index >= anz ) // prüfen ob ein i-tes c vorhanden ist
  503. return;
  504. int pos = positionVon( t, index ); // Position vom i-ten c
  505. if( pos < 0 )
  506. return;
  507. int l = getLänge(); // Länge des Textes
  508. if( !l )
  509. return;
  510. char *res = new char[ l - tl + 1 ]; // neuen Text erzeugen
  511. for( int i = 0; i < pos && i < l - tl + 1; ++i ) // Text befüllen
  512. res[ i ] = txt[ i ];
  513. for( int i = pos + tl; i < l; ++i )
  514. res[ i - tl ] = txt[ i ];
  515. res[ l - tl ] = '\0'; // Text ende festlegen
  516. setText( res ); // Text setzen
  517. delete[] res; // Speicher freigeben
  518. }
  519. void Text::löschen( int i, Text *t )
  520. {
  521. if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
  522. löschen( i, t->getText() ); // löschen
  523. t = t->release(); // Übergabe loslassen
  524. }
  525. void Text::setPräzision( int p ) // setzt die Anzahl der Nachkommastellen bei doubles
  526. {
  527. präzision = p;
  528. }
  529. // constant
  530. int Text::getLänge() const // gibt die Text länge zurück
  531. {
  532. if( !txt )
  533. return -1;
  534. int ret = 0;
  535. for( ; txt[ ret ] != '\0'; ++ret ); // zählen
  536. return ret;
  537. }
  538. int Text::getLKick( int pos ) const
  539. {
  540. if( txt[ pos - 1 ] == ' ' )
  541. {
  542. int ret = 1;
  543. for( ; ret < pos && txt[ pos - ret - 1 ] == ' ' && txt[ pos - ret - 1 ] != '\n'; ++ret );
  544. return pos - ret;
  545. }
  546. else
  547. {
  548. int ret = 1;
  549. for( ; ret < pos && txt[ pos - ret - 1 ] != ' ' && txt[ pos - ret - 1 ] != '\n'; ++ret );
  550. return pos - ret;
  551. }
  552. }
  553. int Text::getOKick( int pos ) const
  554. {
  555. if( !hat( '\n' ) )
  556. return 0;
  557. int lpos = 0;
  558. while( pos - lpos - 1 > 0 && txt[ pos - lpos - 1 ] != '\n' )
  559. ++lpos;
  560. int vllän = 1;
  561. while( pos - lpos - vllän - 1 >= 0 && txt[ pos - lpos - vllän - 1 ] != '\n' )
  562. ++vllän;
  563. if( vllän > lpos )
  564. return pos - vllän;
  565. else
  566. return pos - lpos - 1;
  567. }
  568. int Text::getRKick( int pos ) const
  569. {
  570. int tl = getLänge();
  571. if( txt[ pos ] == ' ' )
  572. {
  573. int ret = 1;
  574. for( ; ret + pos < tl && txt[ pos + ret ] == ' ' && txt[ pos + ret ] != '\n'; ++ret );
  575. return pos + ret;
  576. }
  577. else
  578. {
  579. int ret = 1;
  580. for( ; ret + pos < tl && txt[ pos + ret ] != ' '&& txt[ pos + ret ] != '\n'; ++ret );
  581. return pos + ret;
  582. }
  583. }
  584. int Text::getUKick( int pos ) const
  585. {
  586. if( !hat( '\n' ) )
  587. return getLänge();
  588. int lpos = 0;
  589. while( pos - lpos > 0 && txt[ pos - lpos - 1 ] != '\n' )
  590. ++lpos;
  591. int llän = 1;
  592. while( pos + llän - 1 < getLänge() && txt[ pos + llän - 1 ] != '\n' )
  593. ++llän;
  594. int vllän = 1;
  595. while( pos + llän + vllän - 1 < getLänge() && txt[ pos + llän + vllän - 1 ] != '\n' )
  596. ++vllän;
  597. if( vllän == 1 )
  598. return pos + llän < getLänge() ? pos + llän : getLänge();
  599. if( vllän < lpos )
  600. return pos + llän + vllän - 1;
  601. return pos + llän + lpos;
  602. }
  603. bool Text::hat( Text *t ) const // enthält der Text t
  604. {
  605. bool ret = 0;
  606. if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
  607. ret = hat( t->getText() ); // prüfen
  608. t = t->release(); // Übergabe loslassen
  609. return ret;
  610. }
  611. bool Text::hat( const char *t ) const
  612. {
  613. int tl = (int)strlen( t ); // Länge der Übergabe
  614. int txl = getLänge(); // Länge des Textes
  615. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  616. return 0;
  617. int suchGCount = 0;
  618. for( int i = 0; i + tl <= txl; ++i ) // Text durchsuchen
  619. {
  620. if( !suchGCount )
  621. {
  622. bool b = 1;
  623. for( int ii = 0; ii < tl; ++ii ) // Text überprüfen
  624. b &= txt[ i + ii ] == t[ ii ];
  625. if( b )
  626. return 1;
  627. }
  628. if( txt[ i ] == suchGBeg )
  629. ++suchGCount;
  630. if( txt[ i ] == suchGEnd )
  631. --suchGCount;
  632. if( !suchGCount )
  633. {
  634. bool b = 1;
  635. for( int ii = 0; ii < tl; ++ii ) // Text überprüfen
  636. b &= txt[ i + ii ] == t[ ii ];
  637. if( b )
  638. return 1;
  639. }
  640. }
  641. return 0;
  642. }
  643. bool Text::hat( char c ) const // enthält c
  644. {
  645. int l = getLänge(); // Text Länge
  646. bool ret = 0;
  647. int suchGCount = 0;
  648. for( int i = 0; i < l; ++i ) // suchen
  649. {
  650. bool b = suchGCount != 0;
  651. if( !suchGCount ) // überprüfen
  652. ret |= txt[ i ] == c;
  653. if( txt[ i ] == suchGBeg )
  654. ++suchGCount;
  655. if( txt[ i ] == suchGEnd )
  656. --suchGCount;
  657. if( !suchGCount && b ) // überprüfen
  658. ret |= txt[ i ] == c;
  659. }
  660. return ret;
  661. }
  662. bool Text::istGleich( const char *t ) const // prüft ob det Text gleich t ist
  663. {
  664. int txl = getLänge(); // Text Länge
  665. int tl = (int)strlen( t ); // Länge der Übergabe
  666. if( txl != tl ) // Auf unsinniege Übergabe prüfen
  667. return 0;
  668. if( txl == -1 )
  669. return 1;
  670. bool ret = true;
  671. for( int i = 0; i < tl; ++i ) // prüfen
  672. ret &= txt[ i ] == t[ i ];
  673. return ret;
  674. }
  675. bool Text::istGleich( Text *t ) const
  676. {
  677. bool ret = istGleich( t->getText() ); // prüfen
  678. t->release(); // Übergabe loslassen
  679. return ret;
  680. }
  681. char *Text::getText() const // gibt Text zurück
  682. {
  683. return txt;
  684. }
  685. int Text::anzahlVon( char c ) const // gibt die Anzahl von c im Text zurück
  686. {
  687. int ret = 0;
  688. int l = getLänge(); // Text Länge
  689. int suchGCount = 0;
  690. for( int i = 0; i < l; ++i ) // suchen
  691. {
  692. bool b = suchGCount != 0;
  693. ret += txt[ i ] == c && !suchGCount; // zählen
  694. if( txt[ i ] == suchGBeg )
  695. ++suchGCount;
  696. if( txt[ i ] == suchGEnd )
  697. --suchGCount;
  698. ret += txt[ i ] == c && !suchGCount && b; // zählen
  699. }
  700. return ret;
  701. }
  702. int Text::anzahlVon( const char *t ) const // gibt die Anzahl von t im Text zurück
  703. {
  704. int tl = (int)strlen( t ); // Länge der Übergabe
  705. int txl = getLänge(); // Länge des Textes
  706. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  707. return 0;
  708. int ret = 0;
  709. int suchGCount = 0;
  710. for( int i = 0; i + tl <= txl; ++i ) // suchen
  711. {
  712. bool b = suchGCount != 0;
  713. if( !suchGCount )
  714. {
  715. bool b = 1;
  716. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  717. b &= txt[ i + ii ] == t[ ii ];
  718. if( b )
  719. ++ret; // zählen
  720. }
  721. if( txt[ i ] == suchGBeg )
  722. ++suchGCount;
  723. if( txt[ i ] == suchGEnd )
  724. --suchGCount;
  725. if( !suchGCount && b )
  726. {
  727. bool b = 1;
  728. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  729. b &= txt[ i + ii ] == t[ ii ];
  730. if( b )
  731. ++ret; // zählen
  732. }
  733. }
  734. return ret;
  735. }
  736. int Text::anzahlVon( Text *t ) const
  737. {
  738. int ret = 0;
  739. if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
  740. ret = anzahlVon( t->getText() ); // zählen
  741. t = t->release(); // Übergabe loslassen
  742. return ret;
  743. }
  744. int Text::positionVon( char c ) const // gibt die Position des ersten c zurück
  745. {
  746. int l = getLänge(); // Text Länge
  747. int suchGCount = 0;
  748. for( int i = 0; i < l; ++i ) // suchen
  749. {
  750. bool b = suchGCount != 0;
  751. if( txt[ i ] == c && !suchGCount ) // überprüfen
  752. return i;
  753. if( txt[ i ] == suchGBeg )
  754. ++suchGCount;
  755. if( txt[ i ] == suchGEnd )
  756. --suchGCount;
  757. if( txt[ i ] == c && !suchGCount && b ) // überprüfen
  758. return i;
  759. }
  760. return -1;
  761. }
  762. int Text::positionVon( const char *t ) const // gibt die Position des ersten t zurück
  763. {
  764. int tl = (int)strlen( t ); // Länge der Übergabe
  765. int txl = getLänge(); // Länge des Textes
  766. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  767. return -1;
  768. int suchGCount = 0;
  769. for( int i = 0; i + tl <= txl; ++i ) // suchen
  770. {
  771. bool b = suchGCount != 0;
  772. if( !suchGCount )
  773. {
  774. bool b = 1;
  775. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  776. b &= txt[ i + ii ] == t[ ii ];
  777. if( b )
  778. return i;
  779. }
  780. if( txt[ i ] == suchGBeg )
  781. ++suchGCount;
  782. if( txt[ i ] == suchGEnd )
  783. --suchGCount;
  784. if( !suchGCount && b )
  785. {
  786. bool b = 1;
  787. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  788. b &= txt[ i + ii ] == t[ ii ];
  789. if( b )
  790. return i;
  791. }
  792. }
  793. return -1;
  794. }
  795. int Text::positionVon( Text *t ) const
  796. {
  797. int ret = 0;
  798. if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
  799. ret = positionVon( t->getText() ); // position ermitteln
  800. t = t->release(); // Übergabe loslassen
  801. return ret;
  802. }
  803. int Text::positionVon( char c, int index ) const // gibt die Position des i-ten c zurück
  804. {
  805. int l = getLänge(); // Text Länge
  806. int ii = 0;
  807. int suchGCount = 0;
  808. for( int i = 0; i < l; ++i ) // suchen
  809. {
  810. bool b = suchGCount != 0;
  811. if( txt[ i ] == c && !suchGCount ) // überprüfen
  812. {
  813. if( ii == index )
  814. return i;
  815. else
  816. ++ii;
  817. }
  818. if( txt[ i ] == suchGBeg )
  819. ++suchGCount;
  820. if( txt[ i ] == suchGEnd )
  821. --suchGCount;
  822. if( txt[ i ] == c && !suchGCount && b ) // überprüfen
  823. {
  824. if( ii == index )
  825. return i;
  826. else
  827. ++ii;
  828. }
  829. }
  830. return -1;
  831. }
  832. int Text::positionVon( const char *t, int index ) const // gibt die Position des i-ten t zurück
  833. {
  834. int tl = (int)strlen( t ); // Länge der Übergabe
  835. int txl = getLänge(); // Länge des Textes
  836. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  837. return 0;
  838. int i2 = 0;
  839. int suchGCount = 0;
  840. for( int i = 0; i + tl <= txl; ++i ) // suchen
  841. {
  842. bool b = suchGCount != 0;
  843. if( !suchGCount )
  844. {
  845. bool b = 1;
  846. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  847. b &= txt[ i + ii ] == t[ ii ];
  848. if( b )
  849. {
  850. if( i2 == index )
  851. return i;
  852. else
  853. ++i2;
  854. }
  855. }
  856. if( txt[ i ] == suchGBeg )
  857. ++suchGCount;
  858. if( txt[ i ] == suchGEnd )
  859. --suchGCount;
  860. if( !suchGCount && b )
  861. {
  862. bool b = 1;
  863. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  864. b &= txt[ i + ii ] == t[ ii ];
  865. if( b )
  866. {
  867. if( i2 == index )
  868. return i;
  869. else
  870. ++i2;
  871. }
  872. }
  873. }
  874. return -1;
  875. }
  876. int Text::positionVon( Text *t, int i ) const
  877. {
  878. int ret = 0;
  879. if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
  880. ret = positionVon( t->getText(), i ); // position ermitteln
  881. t = t->release(); // Übergabe loslassen
  882. return ret;
  883. }
  884. Text *Text::getTeilText( int p1, int p2 ) const // gibt den Text von p1 bis p2 zurück
  885. {
  886. if( p1 > p2 ) // p1 und p2 tauschen
  887. {
  888. int x = p1;
  889. p1 = p2;
  890. p2 = x;
  891. }
  892. int l = getLänge(); // Text Länge
  893. if( p1 < 0 || p2 > l ) // Auf unsinnige übergabe prüfen
  894. return new Text( "" );
  895. char *cp = new char[ p2 - p1 + 1 ]; // neuen Text erstellen
  896. for( int i = p1; i < p2; ++i ) // Text befüllen
  897. {
  898. cp[ i - p1 ] = txt[ i ];
  899. }
  900. cp[ p2 - p1 ] = '\0';
  901. Text *t = new Text( cp ); // Text zurückgeben
  902. delete[]cp;
  903. return t;
  904. }
  905. Text *Text::getTeilText( int p ) const // gibt den Text von p bis zum Ende zurück
  906. {
  907. return getTeilText( p, getLänge() ); // Text zurückgeben
  908. }
  909. // Reference Counting
  910. Text *Text::getThis()
  911. {
  912. ++ref;
  913. return this;
  914. }
  915. Text *Text::release()
  916. {
  917. --ref;
  918. if( ref < 1 )
  919. delete this;
  920. return 0;
  921. }
  922. // Operatoren
  923. Text &Text::operator+=( const int num )
  924. {
  925. anhängen( num );
  926. return *this;
  927. }
  928. Text &Text::operator+=( const double num )
  929. {
  930. anhängen( num );
  931. return *this;
  932. }
  933. Text &Text::operator+=( const char *txt )
  934. {
  935. anhängen( txt );
  936. return *this;
  937. }
  938. Text &Text::operator+=( const Text &txt )
  939. {
  940. anhängen( txt.getText() );
  941. return *this;
  942. }
  943. Text &Text::operator=( const int num )
  944. {
  945. setText( "" );
  946. anhängen( num );
  947. return *this;
  948. }
  949. Text &Text::operator=( const double num )
  950. {
  951. setText( "" );
  952. anhängen( num );
  953. return *this;
  954. }
  955. Text &Text::operator=( const char *txt )
  956. {
  957. setText( txt );
  958. return *this;
  959. }
  960. Text &Text::operator=( const Text &txt )
  961. {
  962. setText( txt.getText() );
  963. return *this;
  964. }
  965. Text::operator char*( ) const
  966. {
  967. return txt;
  968. }
  969. Text::operator int() const
  970. {
  971. if( txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
  972. return TextZuInt( ( txt + 2 ), 16 );
  973. return TextZuInt( txt, 10 );
  974. }
  975. Text::operator double() const
  976. {
  977. if( txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
  978. return TextZuInt( ( txt + 2 ), 16 );
  979. return TextZuDouble( txt );
  980. }
  981. bool Text::operator>( Text &t ) const
  982. {
  983. int län1 = getLänge();
  984. int län2 = t.getLänge();
  985. char *txt2 = t;
  986. for( int i = 0; i < län1 && i < län2; ++i )
  987. {
  988. if( txt[ i ] > txt2[ i ] )
  989. return 1;
  990. if( txt[ i ] < txt2[ i ] )
  991. return 0;
  992. }
  993. if( län1 > län2 )
  994. return 1;
  995. return 0;
  996. }
  997. bool Text::operator<( Text &t ) const
  998. {
  999. int län1 = getLänge();
  1000. int län2 = t.getLänge();
  1001. char *txt2 = t;
  1002. for( int i = 0; i < län1 && i < län2; ++i )
  1003. {
  1004. if( txt[ i ] < txt2[ i ] )
  1005. return 1;
  1006. if( txt[ i ] > txt2[ i ] )
  1007. return 0;
  1008. }
  1009. if( län1 < län2 )
  1010. return 1;
  1011. return 0;
  1012. }
  1013. // char* operationen
  1014. int Framework::stringPositionVonChar( char *string, char c, int num ) // sucht die position des num-ten c-s in string, -1 bei nicht gefunden
  1015. {
  1016. int gef = 0;
  1017. int p = 0;
  1018. for( char cc = *string; *string; ++string )
  1019. {
  1020. if( cc == c )
  1021. {
  1022. if( gef == num )
  1023. return p;
  1024. else
  1025. ++gef;
  1026. }
  1027. ++p;
  1028. }
  1029. return -1;
  1030. }
  1031. int Framework::stringPositionVonString( char *string, char *suche, int sBegPos ) // sucht die position von 'suche' in 'string' ab der Position 'sBegPos', -1 bei nicht gefunden
  1032. {
  1033. for( int i = 0; i < sBegPos; ++i )
  1034. {
  1035. if( !*string )
  1036. return -1;
  1037. ++string;
  1038. }
  1039. int tl = textLänge( suche ); // Länge der Übergabe
  1040. int txl = textLänge( string ); // Länge des Textes
  1041. if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
  1042. return -1;
  1043. for( int i = 0; i + tl <= txl; ++i ) // suchen
  1044. {
  1045. bool b = 1;
  1046. for( int ii = 0; ii < tl; ++ii ) // überprüfen
  1047. if( b )
  1048. b = string[ i + ii ] == suche[ ii ];
  1049. if( b )
  1050. return i + sBegPos;
  1051. }
  1052. return -1;
  1053. }
  1054. //---Andere Funktionen---
  1055. void Framework::TextKopieren( const char *txt ) // kopiert den Text in den Zwischenspeicher
  1056. {
  1057. #ifdef WIN32
  1058. int län = textLänge( txt ) + 1;
  1059. if( län == 1 )
  1060. return;
  1061. HGLOBAL hMem = GlobalAlloc( GMEM_MOVEABLE, län );
  1062. if( !hMem )
  1063. return;
  1064. memcpy( GlobalLock( hMem ), txt, län );
  1065. GlobalUnlock( hMem );
  1066. OpenClipboard( 0 );
  1067. EmptyClipboard();
  1068. SetClipboardData( CF_TEXT, hMem );
  1069. CloseClipboard();
  1070. #endif
  1071. }
  1072. char *Framework::TextEinfügen() // gibt den Text aus der Zwischenablage zurück
  1073. {
  1074. #ifdef WIN32
  1075. if( !OpenClipboard( 0 ) )
  1076. return "";
  1077. HANDLE hClipData = GetClipboardData( CF_TEXT );
  1078. char *cBuffer = (char*)GlobalLock( hClipData );
  1079. GlobalUnlock( hClipData );
  1080. CloseClipboard();
  1081. return cBuffer;
  1082. #else
  1083. return 0;
  1084. #endif
  1085. }
  1086. char Framework::KleinOrGroß( char c, bool gr )
  1087. {
  1088. int ret = c;
  1089. if( gr )
  1090. {
  1091. if( c >= 'a' && c <= 'z' )
  1092. ret -= 32;
  1093. else
  1094. {
  1095. switch( c )
  1096. {
  1097. case '^':
  1098. return '°';
  1099. case '1':
  1100. return '!';
  1101. case '<':
  1102. return '>';
  1103. case '2':
  1104. return '\"';
  1105. case '3':
  1106. return '§';
  1107. case '4':
  1108. return '$';
  1109. case '5':
  1110. return '%';
  1111. case '6':
  1112. return '&';
  1113. case '7':
  1114. return '/';
  1115. case '8':
  1116. return '(';
  1117. case '9':
  1118. return ')';
  1119. case '0':
  1120. return '=';
  1121. case ',':
  1122. return ';';
  1123. case '.':
  1124. return ':';
  1125. case 'ß':
  1126. return '?';
  1127. case '-':
  1128. return '_';
  1129. case '´':
  1130. return '`';
  1131. case '+':
  1132. return '*';
  1133. case '#':
  1134. return '\'';
  1135. case 'ü':
  1136. return 'Ü';
  1137. case 'ö':
  1138. return 'Ö';
  1139. case 'ä':
  1140. return 'Ä';
  1141. }
  1142. }
  1143. }
  1144. else
  1145. {
  1146. if( c >= 'A' && c <= 'Z' )
  1147. ret += 32;
  1148. else
  1149. {
  1150. switch( c )
  1151. {
  1152. case '°':
  1153. return '^';
  1154. case '!':
  1155. return '1';
  1156. case '>':
  1157. return '<';
  1158. case '\"':
  1159. return '2';
  1160. case '§':
  1161. return '3';
  1162. case '$':
  1163. return '4';
  1164. case '%':
  1165. return '5';
  1166. case '&':
  1167. return '6';
  1168. case '/':
  1169. return '7';
  1170. case '(':
  1171. return '8';
  1172. case ')':
  1173. return '9';
  1174. case '=':
  1175. return '0';
  1176. case ';':
  1177. return ',';
  1178. case ':':
  1179. return '.';
  1180. case '?':
  1181. return 'ß';
  1182. case '_':
  1183. return '-';
  1184. case '`':
  1185. return '´';
  1186. case '*':
  1187. return '+';
  1188. case '\'':
  1189. return '#';
  1190. case 'Ü':
  1191. return 'ü';
  1192. case 'Ö':
  1193. return 'ö';
  1194. case 'Ä':
  1195. return 'ä';
  1196. }
  1197. }
  1198. }
  1199. return ret;
  1200. }
  1201. bool Framework::istSchreibbar( unsigned char zeichen ) // prüft, ob zeichen ein Schreibbarer Buchstabe ist
  1202. {
  1203. if( zeichen > 32 && zeichen < 127 )
  1204. return 1;
  1205. if( zeichen == 128 || zeichen == 181 || zeichen == 178 || zeichen == 179 )
  1206. return 1;
  1207. if( zeichen > 191 && zeichen < 198 )
  1208. return 1;
  1209. if( zeichen > 199 && zeichen < 208 )
  1210. return 1;
  1211. if( zeichen > 209 && zeichen < 215 )
  1212. return 1;
  1213. if( zeichen > 216 && zeichen < 221 )
  1214. return 1;
  1215. if( zeichen > 222 && zeichen < 230 )
  1216. return 1;
  1217. if( zeichen > 231 && zeichen < 240 )
  1218. return 1;
  1219. if( zeichen > 241 && zeichen < 247 )
  1220. return 1;
  1221. if( zeichen > 248 && zeichen < 253 )
  1222. return 1;
  1223. if( zeichen == ' ' || zeichen == '\t' )
  1224. return 1;
  1225. return 0;
  1226. }
  1227. unsigned int Framework::TextZuInt( char *c, int system ) // Konvertiert c zu int
  1228. {
  1229. if( system == 16 )
  1230. return strtoul( c, 0, system );
  1231. return strtol( c, 0, system );
  1232. }
  1233. unsigned int Framework::TextZuInt( char *c, char **c_ende, int system )
  1234. {
  1235. if( system == 16 )
  1236. return strtoul( c, c_ende, system );
  1237. return strtol( c, c_ende, system );
  1238. }
  1239. double Framework::TextZuDouble( char *c ) // Konvertiert c zu double
  1240. {
  1241. return strtod( c, 0 );
  1242. }
  1243. double Framework::TextZuDouble( char *c, char **c_ende )
  1244. {
  1245. return strtod( c, c_ende );
  1246. }
  1247. int Framework::textLänge( const char *txt ) // gibt die Länge von txt zurück
  1248. {
  1249. if( !txt )
  1250. return 0;
  1251. int ret = 0;
  1252. for( ; txt[ ret ] != 0; ++ret );
  1253. return ret;
  1254. }