DateiSystem.cpp 101 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199
  1. //---Include---
  2. #include "DateiSystem.h"
  3. #include <iostream>
  4. #include "Bild.h"
  5. #include "Text.h"
  6. #ifdef WIN32
  7. # include "Fenster.h"
  8. # include "Fortschritt.h"
  9. # include "Globals.h"
  10. # include "Schrift.h"
  11. #endif
  12. #include "Datei.h"
  13. using namespace Framework;
  14. // LTDB Dateivormat
  15. // Inhalt der LTDBPixel Klasse aus Dateisystem.h
  16. // Konstruktor
  17. LTDBPixel::LTDBPixel(LTDBPixel* davor)
  18. : ReferenceCounter(),
  19. davor(davor),
  20. index(0),
  21. iR(0),
  22. iG(0),
  23. iB(0),
  24. iA(0),
  25. miR(8),
  26. miG(8),
  27. miB(8),
  28. miA(8),
  29. maxIndex(1),
  30. change(0),
  31. changeR(0),
  32. changeG(0),
  33. changeB(0),
  34. changeA(0),
  35. komp(0),
  36. R(0),
  37. G(0),
  38. B(0),
  39. A(0)
  40. {}
  41. // Destruktor
  42. LTDBPixel::~LTDBPixel()
  43. {
  44. if (davor) davor->release();
  45. }
  46. // nicht constant
  47. bool LTDBPixel::addBitZuFarbe(
  48. unsigned char bit) // Fügt den Farbwerten ein Bit hinzu
  49. {
  50. if (changeR && iR != miR) // Das Bit gehört zu Rot
  51. {
  52. R = (unsigned char)(R | ((bit & 0x1) << (7 - komp - iR)));
  53. ++iR;
  54. }
  55. else if (changeG && iG != miG) // Das Bit gehört zu Grün
  56. {
  57. G = (unsigned char)(G | ((bit & 0x1) << (7 - komp - iG)));
  58. ++iG;
  59. }
  60. else if (changeB && iB != miB) // Das Bit gehört zu Blau
  61. {
  62. B = (unsigned char)(B | ((bit & 0x1) << (7 - komp - iB)));
  63. ++iB;
  64. }
  65. else if (changeA && iA != miA) // Das Bit gehört zu Alpha
  66. {
  67. A = (unsigned char)(A | ((bit & 0x1) << (7 - komp - iA)));
  68. ++iA;
  69. }
  70. else // Das Bit gehört zum nächsten Pixel
  71. return false;
  72. return true;
  73. }
  74. char LTDBPixel::addByte(
  75. char byte, char begin) // gibt ende des Pixels zurück, -1 wenn nicht zu ende
  76. {
  77. if (begin >= 8 || begin < 0) return -1;
  78. for (int i = begin; i < 8; ++i)
  79. {
  80. switch (index)
  81. {
  82. case 0:
  83. // Das erste Bit eines Pixels speichert, ob sich an der
  84. // Komprimierung etwas änderte
  85. change = (bool)((byte >> (7 - i)) & 0x1);
  86. if (!change) // Ändert sich nichts an der Komprimierung, so werden
  87. // die Werte vom vorherigen Pixel übernommen
  88. {
  89. if (!davor) // Die Datei ist beschädigt ( Der erste Pixel kann
  90. // nicht von dem davor Übernemen )
  91. {
  92. #ifdef WIN32
  93. MessageBox(NULL,
  94. "Fehler, die Bilddatei ist beschädigt",
  95. "Fehler",
  96. MB_ICONERROR);
  97. #endif
  98. exit(0);
  99. }
  100. changeR = davor->getChangeR();
  101. changeG = davor->getChangeG();
  102. changeB = davor->getChangeB();
  103. changeA = davor->getChangeA();
  104. komp = davor->getKomp() & 7;
  105. miR = (char)(miR - komp), miG = (char)(miG - komp),
  106. miB = (char)(miB - komp), miA = (char)(miA - komp);
  107. if (!changeR) R = davor->getR();
  108. if (!changeG) G = davor->getG();
  109. if (!changeB) B = davor->getB();
  110. if (!changeA) A = davor->getA();
  111. maxIndex = (char)(maxIndex
  112. + (changeR + changeG + changeB + changeA)
  113. * (8 - komp)); // Bestimmung der Länge
  114. // des Pixels in Bits. Jede Farbe hat von grund auf 8 Bits,
  115. // durch komprimierung kanns kleiner sein
  116. }
  117. else
  118. maxIndex = (char)(maxIndex + 7); // Da der Pixel nicht die Werte
  119. // des vorherigen übernimmt,
  120. // wird er um 7 Bits größer
  121. break;
  122. case 1: // Das zweite Bit eines Pixels speichert entweder die
  123. // Komprimierungsart, oder schon die Farbe
  124. if (change) // Das Bit gehört zu den 7 Komprimierungsbits
  125. changeR = (bool)((byte >> (7 - i)) & 0x1);
  126. else
  127. {
  128. if (!addBitZuFarbe((
  129. unsigned char)(byte
  130. >> (7 - i)))) // Das Bit gehört zur Farbe
  131. return (unsigned char)i;
  132. }
  133. break;
  134. case 2: // Das dritte Bit eines Pixels speichert entweder die
  135. // Komprimierungsart, oder schon die Farbe
  136. if (change) // Das Bit gehört zu den 7 Komprimierungsbits
  137. changeG = (bool)((byte >> (7 - i)) & 0x1);
  138. else
  139. {
  140. if (!addBitZuFarbe((
  141. unsigned char)(byte
  142. >> (7 - i)))) // Das Bit gehört zur Farbe
  143. return (unsigned char)i;
  144. }
  145. break;
  146. case 3: // Das vierte Bit eines Pixels speichert entweder die
  147. // Komprimierungsart, oder schon die Farbe
  148. if (change) // Das Bit gehört zu den 7 Komprimierungsbits
  149. changeB = (bool)((byte >> (7 - i)) & 0x1);
  150. else
  151. {
  152. if (!addBitZuFarbe((
  153. unsigned char)(byte
  154. >> (7 - i)))) // Das Bit gehört zur Farbe
  155. return (unsigned char)i;
  156. }
  157. break;
  158. case 4: // Das fünfte Bit eines Pixels speichert entweder die
  159. // Komprimierungsart, oder schon die Farbe
  160. if (change) // Das Bit gehört zu den 7 Komprimierungsbits
  161. changeA = (bool)((byte >> (7 - i)) & 0x1);
  162. else
  163. {
  164. if (!addBitZuFarbe((
  165. unsigned char)(byte
  166. >> (7 - i)))) // Das Bit gehört zur Farbe
  167. return (unsigned char)i;
  168. }
  169. break;
  170. case 5: // Das sechste Bit eines Pixels speichert entweder die
  171. // Komprimierungsart, oder schon die Farbe
  172. if (change) // Das Bit gehört zu den 7 Komprimierungsbits
  173. komp = (unsigned char)(komp
  174. | ((unsigned char)((byte >> (7 - i))
  175. & 0x1)
  176. << 2))
  177. & 7;
  178. else
  179. {
  180. if (!addBitZuFarbe((
  181. unsigned char)(byte
  182. >> (7 - i)))) // Das Bit gehört zur Farbe
  183. return (unsigned char)i;
  184. }
  185. break;
  186. case 6: // Das siebte Bit eines Pixels speichert entweder die
  187. // Komprimierungsart, oder schon die Farbe
  188. if (change) // Das Bit gehört zu den 7 Komprimierungsbits
  189. komp = (unsigned char)(komp
  190. | ((unsigned char)((byte >> (7 - i))
  191. & 0x1)
  192. << 1))
  193. & 7;
  194. else
  195. {
  196. if (!addBitZuFarbe((
  197. unsigned char)(byte
  198. >> (7 - i)))) // Das Bit gehört zur Farbe
  199. return (unsigned char)i;
  200. }
  201. break;
  202. case 7: // Das achte Bit eines Pixels speichert entweder die
  203. // Komprimierungsart, oder schon die Farbe
  204. if (change) // Das Bit gehört zu den 7 Komprimierungsbits
  205. {
  206. komp = (unsigned char)(komp | ((byte >> (7 - i)) & 0x1)) & 7;
  207. // Das war das letzte Komprimierungsbit
  208. // Komprimierung auswerten
  209. miR = (char)(miR - komp), miG = (char)(miG - komp),
  210. miB = (char)(miB - komp), miA = (char)(miA - komp);
  211. if (!changeR) R = davor->getR();
  212. if (!changeG) G = davor->getG();
  213. if (!changeB) B = davor->getB();
  214. if (!changeA) A = davor->getA();
  215. maxIndex = (char)(maxIndex
  216. + (changeR + changeG + changeB + changeA)
  217. * (8 - komp)); // Bitlänge des Pixels
  218. }
  219. else
  220. {
  221. if (!addBitZuFarbe((
  222. unsigned char)(byte
  223. >> (7 - i)))) // Das Bit gehört zur Farbe
  224. return (unsigned char)i;
  225. }
  226. break;
  227. default: // Die restlichen Bits speichern alle die Farbwerte des Pixels
  228. if (!addBitZuFarbe(
  229. (unsigned char)(byte
  230. >> (7 - i)))) // Das Bit gehört zur Farbe
  231. return (unsigned char)i;
  232. break;
  233. }
  234. ++index;
  235. if (index >= maxIndex)
  236. {
  237. if (davor)
  238. {
  239. if (changeR) R = (unsigned char)(davor->getR() + R);
  240. if (changeG) G = (unsigned char)(davor->getG() + G);
  241. if (changeB) B = (unsigned char)(davor->getB() + B);
  242. if (changeA) A = (unsigned char)(davor->getA() + A);
  243. davor = (LTDBPixel*)davor->release();
  244. }
  245. return (char)(i + 1);
  246. }
  247. }
  248. return -1;
  249. }
  250. void LTDBPixel::setFarbe(int f) // setzt die Farbe des Pixels
  251. { // Da diese Funktion aufgerufen wird, möchte man die Klasse nun zum speichern
  252. // verwenden
  253. // Werte zurücksetzen, fals mit der Klasse schon geladen oder gespeichert
  254. // wurde
  255. index = 0, maxIndex = 1;
  256. change = 0, changeR = 0, changeG = 0, changeB = 0, changeA = 0, komp = 0;
  257. iR = 0, iG = 0, iB = 0, iA = 0;
  258. miR = 8, miG = 8, miB = 8, miA = 8;
  259. // Farbwerte setzen
  260. R = (unsigned char)(f >> 16);
  261. G = (unsigned char)(f >> 8);
  262. B = (unsigned char)f;
  263. A = (unsigned char)(f >> 24);
  264. }
  265. void LTDBPixel::komprimieren() // Komprimiert den Pixel
  266. {
  267. maxIndex = 1;
  268. if (!davor)
  269. { // Das ist der erste Pixel
  270. change = 1;
  271. changeR = 1;
  272. changeG = 1;
  273. changeB = 1;
  274. changeA = 1;
  275. maxIndex = (char)(maxIndex + 7);
  276. miR = (char)getBits(R);
  277. miG = (char)getBits(G);
  278. miB = (char)getBits(B);
  279. miA = (char)getBits(A);
  280. }
  281. else
  282. { // Es wird die differenz zum vorrigen Pixel gespeichert
  283. miR = (char)getBits((char)(R - davor->getR()));
  284. miG = (char)getBits((char)(G - davor->getG()));
  285. miB = (char)getBits((char)(B - davor->getB()));
  286. miA = (char)getBits((char)(A - davor->getA()));
  287. changeR = R != davor->getR();
  288. changeG = G != davor->getG();
  289. changeB = B != davor->getB();
  290. changeA = A != davor->getA();
  291. } // Prüfen ob sich etwas ändert
  292. if (!miR && changeR) ++miR;
  293. if (!miG && changeG) ++miG;
  294. if (!miB && changeB) ++miB;
  295. if (!miA && changeA) ++miA;
  296. int k = (miR > miG ? miR : miG);
  297. k = (k > miB ? k : miB);
  298. k = (k > miA ? k : miA);
  299. miR = (char)k, miG = (char)k, miB = (char)k, miA = (char)k;
  300. komp = (unsigned char)(8 - k) & 7;
  301. maxIndex = (char)(maxIndex + (changeR + changeG + changeB + changeA) * k);
  302. if (davor)
  303. {
  304. if (changeR != davor->getChangeR() || changeG != davor->getChangeG()
  305. || changeB != davor->getChangeB() || changeA != davor->getChangeA()
  306. || komp != davor->getKomp())
  307. { // Es ändert sich etwas
  308. change = 1;
  309. maxIndex = (char)(maxIndex + 7);
  310. }
  311. else
  312. { // Es ändert sich nichts
  313. change = 0;
  314. }
  315. }
  316. }
  317. bool LTDBPixel::getNextFarbeBit(
  318. char& byte, int i) // Speichert das nächste Farbbit in byte
  319. {
  320. unsigned char RR = R;
  321. unsigned char GG = G;
  322. unsigned char BB = B;
  323. unsigned char AA = A;
  324. if (davor)
  325. {
  326. RR = (unsigned char)(RR - davor->getR());
  327. GG = (unsigned char)(GG - davor->getG());
  328. BB = (unsigned char)(BB - davor->getB());
  329. AA = (unsigned char)(AA - davor->getA());
  330. }
  331. if (changeR && iR != miR) // Das Bit gehört zu Rot
  332. {
  333. byte |= (char)(((RR >> (7 - komp - iR)) & 0x1) << (7 - i));
  334. ++iR;
  335. }
  336. else if (changeG && iG != miG) // Das Bit gehört zu Grün
  337. {
  338. byte |= (char)(((GG >> (7 - komp - iG)) & 0x1) << (7 - i));
  339. ++iG;
  340. }
  341. else if (changeB && iB != miB) // Das Bit gehört zu Blau
  342. {
  343. byte |= (char)(((BB >> (7 - komp - iB)) & 0x1) << (7 - i));
  344. ++iB;
  345. }
  346. else if (changeA && iA != miA) // Das Bit gehört zu Alpha
  347. {
  348. byte |= (char)(((AA >> (7 - komp - iA)) & 0x1) << (7 - i));
  349. ++iA;
  350. }
  351. else // Der Pixel ist bereits zu ende
  352. return false;
  353. return true;
  354. }
  355. char LTDBPixel::getNextByte(
  356. char& byte, int begin) // Gibt die nächsten Bits Zurück, -1 wenn der Pixel
  357. // nicht zu ende ist
  358. {
  359. // bbegin gibt an wohin in die byte-variable geschrieben werden soll
  360. // die Funktion gibt das ende des Pixels in der byte-variable zurück
  361. // -1 heißt, dass der Pixel nicht zu ende ist
  362. for (int i = begin; i < 8; ++i)
  363. {
  364. switch (index)
  365. {
  366. case 0: // Das erste Bit des Pixels speichert, ob sich etwas an der
  367. // Komprimierung ändert
  368. byte |= (char)(((int)change & 0x1) << (7 - i));
  369. break;
  370. case 1: // Das zweite Bit des Pixels speichert entweder schon die Farbe
  371. // oder die Komprimierung
  372. if (change) // Komprimierung
  373. byte |= (char)(((int)changeR & 0x1) << (7 - i));
  374. else // Farbe
  375. {
  376. if (!getNextFarbeBit(byte, i)) return (char)i;
  377. }
  378. break;
  379. case 2: // Das dritte Bit des Pixels speichert entweder schon die Farbe
  380. // oder die Komprimierung
  381. if (change) // Komprimierung
  382. byte |= (char)(((int)changeG & 0x1) << (7 - i));
  383. else // Farbe
  384. {
  385. if (!getNextFarbeBit(byte, i)) return (char)i;
  386. }
  387. break;
  388. case 3: // Das vierte Bit des Pixels speichert entweder schon die Farbe
  389. // oder die Komprimierung
  390. if (change) // Komprimierung
  391. byte |= (char)(((int)changeB & 0x1) << (7 - i));
  392. else // Farbe
  393. {
  394. if (!getNextFarbeBit(byte, i)) return (char)i;
  395. }
  396. break;
  397. case 4: // Das fünfte Bit des Pixels speichert entweder schon die Farbe
  398. // oder die Komprimierung
  399. if (change) // Komprimierung
  400. byte |= (char)(((int)changeA & 0x1) << (7 - i));
  401. else // Farbe
  402. {
  403. if (!getNextFarbeBit(byte, i)) return (char)i;
  404. }
  405. break;
  406. case 5: // Das sechste Bit des Pixels speichert entweder schon die Farbe
  407. // oder die Komprimierung
  408. if (change) // Komprimierung
  409. byte |= (char)(((komp >> 2) & 0x1) << (7 - i));
  410. else // Farbe
  411. {
  412. if (!getNextFarbeBit(byte, i)) return (char)i;
  413. }
  414. break;
  415. case 6: // Das siebte Bit des Pixels speichert entweder schon die Farbe
  416. // oder die Komprimierung
  417. if (change) // Komprimierung
  418. byte |= (char)(((komp >> 1) & 0x1) << (7 - i));
  419. else // Farbe
  420. {
  421. if (!getNextFarbeBit(byte, i)) return (char)i;
  422. }
  423. break;
  424. case 7: // Das sechste Bit des Pixels speichert entweder schon die Farbe
  425. // oder die Komprimierung
  426. if (change) // Komprimierung
  427. byte |= (char)((komp & 0x1) << (7 - i));
  428. else // Farbe
  429. {
  430. if (!getNextFarbeBit(byte, i)) return (char)i;
  431. }
  432. break;
  433. default: // Die restlichen Bits speichern die Farbe des Pixels
  434. if (!getNextFarbeBit(byte, i)) return (char)i;
  435. break;
  436. }
  437. ++index;
  438. if (index >= maxIndex)
  439. {
  440. if (davor) davor = (LTDBPixel*)davor->release();
  441. return (char)(i + 1);
  442. }
  443. }
  444. return -1;
  445. }
  446. // constant
  447. int LTDBPixel::zuFarbe() const // gibt den Pixel als Farbe zurück
  448. {
  449. return (((int)R << 16) | ((int)G << 8) | (int)B | ((int)A << 24));
  450. }
  451. bool LTDBPixel::getChangeR() const
  452. {
  453. return changeR;
  454. }
  455. bool LTDBPixel::getChangeG() const
  456. {
  457. return changeG;
  458. }
  459. bool LTDBPixel::getChangeB() const
  460. {
  461. return changeB;
  462. }
  463. bool LTDBPixel::getChangeA() const
  464. {
  465. return changeA;
  466. }
  467. unsigned char LTDBPixel::getKomp() const
  468. {
  469. return komp;
  470. }
  471. unsigned char LTDBPixel::getR() const // gibt Rot zurück
  472. {
  473. return R;
  474. }
  475. unsigned char LTDBPixel::getG() const // gibt Grün zurück
  476. {
  477. return G;
  478. }
  479. unsigned char LTDBPixel::getB() const // gibt Blau zurück
  480. {
  481. return B;
  482. }
  483. unsigned char LTDBPixel::getA() const // gibt Alpha zurück
  484. {
  485. return A;
  486. }
  487. // Inhalt der LTDBDateiKopf Klasse aus Dateisystem.h
  488. // konstructor
  489. LTDBDateiKopf::LTDBDateiKopf()
  490. : ReferenceCounter(),
  491. bilder(new RCArray<Text>()),
  492. pos(new Array<__int64>()),
  493. bAnzahl(0)
  494. {}
  495. // destructor
  496. LTDBDateiKopf::~LTDBDateiKopf()
  497. {
  498. bilder->release();
  499. pos->release();
  500. }
  501. // nicht constant
  502. void LTDBDateiKopf::removeBild(int i)
  503. {
  504. if (i >= bAnzahl) return;
  505. bilder->remove(i);
  506. pos->remove(i);
  507. --bAnzahl;
  508. }
  509. void LTDBDateiKopf::removeBild(Text* txt)
  510. {
  511. int i = -1;
  512. for (int ii = 0; ii < bAnzahl; ++ii)
  513. {
  514. Text* b = bilder->z(ii);
  515. if (b->istGleich(txt->getText()))
  516. {
  517. i = ii;
  518. break;
  519. }
  520. }
  521. txt->release();
  522. if (i == -1) return;
  523. bilder->remove(i);
  524. pos->remove(i);
  525. --bAnzahl;
  526. }
  527. void LTDBDateiKopf::addBild(Text* txt)
  528. {
  529. bilder->add(txt, bAnzahl);
  530. pos->add(0, bAnzahl);
  531. ++bAnzahl;
  532. }
  533. void LTDBDateiKopf::setBildPos(int i, __int64 pos)
  534. {
  535. this->pos->set(pos, i);
  536. }
  537. void LTDBDateiKopf::setBildPos(Text* txt, __int64 pos)
  538. {
  539. int i = -1;
  540. for (int ii = 0; ii < bAnzahl; ++ii)
  541. {
  542. Text* b = bilder->z(ii);
  543. if (b->istGleich(txt->getText()))
  544. {
  545. i = ii;
  546. break;
  547. }
  548. }
  549. txt->release();
  550. if (i == -1) return;
  551. this->pos->set(pos, i);
  552. }
  553. void LTDBDateiKopf::laden(FBalken* f, std::ifstream* inF)
  554. {
  555. if (inF->is_open() && inF->good())
  556. {
  557. char b = 0;
  558. inF->read(&b, 1);
  559. bAnzahl = b << 8;
  560. inF->read(&b, 1);
  561. bAnzahl |= b & 0xFF;
  562. #ifdef WIN32
  563. if (f)
  564. {
  565. f->reset();
  566. f->setAktionAnzahl(bAnzahl);
  567. }
  568. #endif
  569. bilder->leeren();
  570. pos->leeren();
  571. for (int i = 0; i < bAnzahl; ++i)
  572. {
  573. LTDBKopf* kpf = new LTDBKopf();
  574. kpf->laden(inF); // bildname und halbe datei position
  575. bilder->add(kpf->getTitel()); // setzt titel
  576. Punkt gr = kpf->getSize();
  577. kpf->release();
  578. char p[5];
  579. inF->read((char*)p, 5); // andere hälfte der Dateiposition
  580. unsigned __int64 position
  581. = (((__int64)gr.x << 52) & 0xFFF0000000000000)
  582. | (((__int64)gr.y << 40) & 0xFFF0000000000)
  583. | (((__int64)p[0] << 32) & 0xFF00000000)
  584. | (((__int64)p[1] << 24) & 0xFF000000)
  585. | (((__int64)p[2] << 16) & 0xFF0000)
  586. | (((__int64)p[3] << 8) & 0xFF00) | ((__int64)p[4] & 0xFF);
  587. pos->add(position, i); // setzt position
  588. #ifdef WIN32
  589. if (f) f->aktionPlus();
  590. #endif
  591. }
  592. }
  593. }
  594. // constant
  595. void LTDBDateiKopf::speichern(std::ofstream* outF) const
  596. {
  597. if (outF->is_open() && outF->good())
  598. {
  599. char b = (char)(bAnzahl >> 8);
  600. outF->write(&b, 1);
  601. b = (char)bAnzahl;
  602. outF->write(&b, 1);
  603. for (int i = 0; i < bAnzahl; ++i)
  604. {
  605. LTDBKopf* kpf = new LTDBKopf();
  606. __int64 position = pos->get(i);
  607. kpf->Init(bilder->get(i),
  608. Punkt((int)(position >> 52), (int)(position >> 40)));
  609. kpf->speichern(outF);
  610. kpf->release();
  611. char p[] = {(char)(position >> 32),
  612. (char)(position >> 24),
  613. (char)(position >> 16),
  614. (char)(position >> 8),
  615. (char)(position)};
  616. outF->write((char*)p, 5);
  617. }
  618. }
  619. }
  620. Text* LTDBDateiKopf::getBild(int i) const
  621. {
  622. return bilder->get(i);
  623. }
  624. Text* LTDBDateiKopf::zBild(int i) const
  625. {
  626. return bilder->z(i);
  627. }
  628. __int64 LTDBDateiKopf::getBildPosition(Text* txt) const
  629. {
  630. int i = -1;
  631. for (int ii = 0; ii < bAnzahl; ++ii)
  632. {
  633. Text* b = bilder->z(ii);
  634. if (b->istGleich(txt->getText()))
  635. {
  636. i = ii;
  637. break;
  638. }
  639. }
  640. txt->release();
  641. if (i == -1) return -1;
  642. return pos->get(i);
  643. }
  644. __int64 LTDBDateiKopf::getBildPosition(int index) const
  645. {
  646. return pos->get(index);
  647. }
  648. int LTDBDateiKopf::getBildIndex(Text* txt) const
  649. {
  650. int i = -1;
  651. for (int ii = 0; ii < bAnzahl; ++ii)
  652. {
  653. Text* b = bilder->z(ii);
  654. if (b->istGleich(txt->getText()))
  655. {
  656. i = ii;
  657. break;
  658. }
  659. }
  660. txt->release();
  661. return i;
  662. }
  663. int LTDBDateiKopf::getbAnzahl() const
  664. {
  665. return bAnzahl;
  666. }
  667. RCArray<Text>* LTDBDateiKopf::zBildListe() const
  668. {
  669. return bilder;
  670. }
  671. // Inhalt der LTDBKopf Klasse aus DateiSystem.h
  672. // Konstruktor
  673. LTDBKopf::LTDBKopf()
  674. : ReferenceCounter()
  675. {}
  676. // nicht constant
  677. void LTDBKopf::laden(std::ifstream* f) // Lät die Daten aus einer Datei
  678. {
  679. if (f->is_open())
  680. {
  681. a = 0;
  682. b = 0;
  683. c = 0;
  684. char aa = 0;
  685. f->read(&aa, 1);
  686. int tl = (aa >> 4) & Bits(4);
  687. int BitAnzahl = 4 + tl * 5 + 24;
  688. f->seekg(-1, std::ios::cur);
  689. int Bytes = BitAnzahl / 8;
  690. if (((float)BitAnzahl / 8.0f) != (float)Bytes) ++Bytes;
  691. char byte = 0;
  692. for (int i = 0; i < Bytes; ++i)
  693. {
  694. f->read(&byte, 1);
  695. setBits(i * 8, i * 8 + 8, byte);
  696. }
  697. }
  698. }
  699. int LTDBKopf::Init(Text* t, const Punkt& g) // Befüllt die Daten
  700. {
  701. a = 0;
  702. b = 0;
  703. c = 0;
  704. int tl = t->getLength();
  705. if (tl > 15) tl = 15;
  706. char* titel = new char[tl];
  707. int skipped = 0;
  708. for (int i = 0; i < tl; ++i)
  709. {
  710. titel[i - skipped] = t->getText()[i];
  711. if (titel[i - skipped] > 96 && titel[i - skipped] < 123)
  712. titel[i - skipped] = (char)(titel[i - skipped] - 96);
  713. else if (titel[i - skipped] > 64 && titel[i - skipped] < 91)
  714. titel[i - skipped] = (char)(titel[i - skipped] - 64);
  715. else if (titel[i - skipped] == 'ü' || titel[i - skipped] == 'Ü')
  716. titel[i - skipped] = 27;
  717. else if (titel[i - skipped] == 'ö' || titel[i - skipped] == 'Ö')
  718. titel[i - skipped] = 28;
  719. else if (titel[i - skipped] == 'ä' || titel[i - skipped] == 'Ä')
  720. titel[i - skipped] = 29;
  721. else if (titel[i - skipped] == 'ß')
  722. titel[i - skipped] = 30;
  723. else if (titel[i - skipped] == '.')
  724. titel[i - skipped] = 31;
  725. else
  726. ++skipped;
  727. }
  728. a = (__int64)((tl - skipped) & Bits(4)) << 60;
  729. int BeginBit = 4;
  730. for (int i = 0; i < tl - skipped; ++i)
  731. {
  732. BeginBit += 5;
  733. switch (i)
  734. {
  735. case 0:
  736. a |= (__int64)(titel[i] & 31) << 55; // ersten Buchstaben speichern
  737. break;
  738. case 1:
  739. a |= (__int64)(titel[i] & 31) << 50; // zweiten Buchstaben speichern
  740. break;
  741. case 2:
  742. a |= (__int64)(titel[i] & 31) << 45; // dritten Buchstaben speichern
  743. break;
  744. case 3:
  745. a |= (__int64)(titel[i] & 31) << 40; // vierten Buchstaben speichern
  746. break;
  747. case 4:
  748. a |= (__int64)(titel[i] & 31) << 35; // fünften Buchstaben speichern
  749. break;
  750. case 5:
  751. a |= (__int64)(titel[i] & 31)
  752. << 30; // sechsten Buchstaben speichern
  753. break;
  754. case 6:
  755. a |= (__int64)(titel[i] & 31) << 25; // siebten Buchstaben speichern
  756. break;
  757. case 7:
  758. a |= (__int64)(titel[i] & 31) << 20; // achten Buchstaben speichern
  759. break;
  760. case 8:
  761. a |= (__int64)(titel[i] & 31) << 15; // neunten Buchstaben speichern
  762. break;
  763. case 9:
  764. a |= (__int64)(titel[i] & 31) << 10; // zenten Buchstaben speichern
  765. break;
  766. case 10:
  767. a |= (__int64)(titel[i] & 31) << 5; // elften Buchstaben speichern
  768. break;
  769. case 11:
  770. a |= (__int64)(titel[i] & 31); // zwölften Buchstaben speichern
  771. break;
  772. case 12:
  773. b |= (__int32)(titel[i] & 31)
  774. << 27; // dreizenten Buchstaben speichern
  775. break;
  776. case 13:
  777. b |= (__int32)(titel[i] & 31)
  778. << 22; // vierzenten Buchstaben speichern
  779. break;
  780. case 14:
  781. b |= (__int32)(titel[i] & 31)
  782. << 17; // fünfzenten Buchstaben speichern
  783. break;
  784. }
  785. }
  786. __int16 grx = (short)(g.x & Bits(12));
  787. __int16 gry = (short)(g.y & Bits(12));
  788. int EndBit = BeginBit + 24;
  789. setBits(BeginBit, EndBit - 12, grx);
  790. setBits(BeginBit + 12, EndBit, gry);
  791. t->release();
  792. delete[] titel;
  793. return skipped;
  794. }
  795. void LTDBKopf::setBits(int BeginBit, int EndBit, __int16 bits)
  796. {
  797. if (EndBit - BeginBit > 16) EndBit = BeginBit + 16;
  798. if (BeginBit < 64)
  799. {
  800. if (EndBit < 64)
  801. {
  802. a |= ((__int64)bits & Bits(EndBit - BeginBit))
  803. << ((64 - BeginBit) - (EndBit - BeginBit));
  804. }
  805. else
  806. {
  807. a |= (((__int64)bits >> (EndBit - 64)) & Bits(64 - BeginBit));
  808. b |= ((__int32)bits & Bits(EndBit - 64)) << (32 - (EndBit - 64));
  809. }
  810. }
  811. else
  812. {
  813. if (BeginBit < 96)
  814. {
  815. if (EndBit < 96)
  816. {
  817. b |= ((__int32)bits & Bits(EndBit - BeginBit))
  818. << ((96 - BeginBit) - (EndBit - BeginBit));
  819. }
  820. else
  821. {
  822. b |= (((__int32)bits >> (EndBit - 96)) & Bits(96 - BeginBit));
  823. c = (char)(c
  824. | (((__int8)bits & Bits(EndBit - 96))
  825. << (8 - (EndBit - 96))));
  826. }
  827. }
  828. else
  829. {
  830. c = (char)(c
  831. | (((__int8)bits & Bits(EndBit - BeginBit))
  832. << (8 - (EndBit - BeginBit))));
  833. }
  834. }
  835. }
  836. // constant
  837. void LTDBKopf::speichern(
  838. std::ofstream* f) const // Speichert die Daten in eine Datei
  839. {
  840. if (f->is_open())
  841. {
  842. int bits = 4 /*Titellänge*/ + getTitelLength() * 5 /*Titel*/
  843. + 24 /*Bildgröße*/;
  844. int bytes = bits / 8; // Bytelänge des Dateikopfes
  845. if (((float)bits / 8.0f) != (float)bytes) ++bytes;
  846. char c = 0;
  847. for (int i = 0; i < bytes; ++i)
  848. {
  849. c = (char)getBits(i * 8, i * 8 + 8);
  850. f->write(&c, 1);
  851. }
  852. }
  853. }
  854. int LTDBKopf::getTitelLength() const // gibt die länge des Bildnamens zurück
  855. {
  856. return (int)(a >> 60 & Bits(4)); // Die Länge des Titels wird in den ersten
  857. // 4 Bits der Tatei gespeichert
  858. }
  859. Text* LTDBKopf::getTitel() const // gibt den Namen des Bildes zurück
  860. {
  861. Text* ret = new Text("");
  862. char c[2];
  863. c[1] = '\0';
  864. int l = getTitelLength();
  865. for (int i = 0; i < l; ++i)
  866. {
  867. c[0] = 0;
  868. switch (i)
  869. {
  870. case 0:
  871. c[0] = (a >> 55) & 31; // ersten Buchstaben holen
  872. break;
  873. case 1:
  874. c[0] = (a >> 50) & 31; // zweiten Buchstaben holen
  875. break;
  876. case 2:
  877. c[0] = (a >> 45) & 31; // dritten Buchstaben holen
  878. break;
  879. case 3:
  880. c[0] = (a >> 40) & 31; // vierten Buchstaben holen
  881. break;
  882. case 4:
  883. c[0] = (a >> 35) & 31; // fünften Buchstaben holen
  884. break;
  885. case 5:
  886. c[0] = (a >> 30) & 31; // sechsten Buchstaben holen
  887. break;
  888. case 6:
  889. c[0] = (a >> 25) & 31; // siebten Buchstaben holen
  890. break;
  891. case 7:
  892. c[0] = (a >> 20) & 31; // achten Buchstaben holen
  893. break;
  894. case 8:
  895. c[0] = (a >> 15) & 31; // neunten Buchstaben holen
  896. break;
  897. case 9:
  898. c[0] = (a >> 10) & 31; // zenten Buchstaben holen
  899. break;
  900. case 10:
  901. c[0] = (a >> 5) & 31; // elften Buchstaben holen
  902. break;
  903. case 11:
  904. c[0] = a & 31; // zwölften Buchstaben holen
  905. break;
  906. case 12:
  907. c[0] = (char)((b >> 27) & 31); // dreizenten Buchstaben holen
  908. break;
  909. case 13:
  910. c[0] = (char)((b >> 22) & 31); // vierzenten Buchstaben holen
  911. break;
  912. case 14:
  913. c[0] = (char)((b >> 17) & 31); // fünfzenten Buchstaben holen
  914. break;
  915. }
  916. if (c[0] == 27)
  917. c[0] = 'ü';
  918. else if (c[0] == 28)
  919. c[0] = 'ö';
  920. else if (c[0] == 29)
  921. c[0] = 'ä';
  922. else if (c[0] == 30)
  923. c[0] = 'ß';
  924. else if (c[0] == 31)
  925. c[0] = '.';
  926. else
  927. c[0] = (char)(c[0] + 96);
  928. ret->append(c);
  929. }
  930. return ret;
  931. }
  932. Punkt LTDBKopf::getSize() const // gibt die Größe des Bildes zurück
  933. {
  934. int BeginBit = 4 /*Titellänge*/ + getTitelLength() * 5 /*Titel*/;
  935. int EndBit = BeginBit + 24;
  936. __int16 grx = getBits(BeginBit, EndBit - 12);
  937. __int16 gry = getBits(BeginBit + 12, EndBit);
  938. return Punkt((int)(grx & Bits(12)), (int)(gry & Bits(12)));
  939. }
  940. __int16 LTDBKopf::getBits(int begin,
  941. int ende) const // gibt die Bits von begin bis ende zurück( ohne ende );
  942. {
  943. if (ende < begin) return 0;
  944. if (ende - begin > 16) ende = begin + 16;
  945. __int16 ret = 0;
  946. if (begin < 64)
  947. {
  948. if (ende < 64)
  949. {
  950. ret = (__int16)(a >> ((64 - begin) - (ende - begin))
  951. & Bits(ende - begin));
  952. }
  953. else
  954. {
  955. ret = (__int16)((a & Bits(64 - begin)) << (ende - 64));
  956. ret = (__int16)(ret
  957. | ((b >> (32 - (ende - 64))) & Bits(ende - 64)));
  958. }
  959. }
  960. else
  961. {
  962. if (begin < 96)
  963. {
  964. if (ende < 96)
  965. {
  966. ret = (__int16)(b >> ((96 - begin) - (ende - begin))
  967. & Bits(ende - begin));
  968. }
  969. else
  970. {
  971. ret = (__int16)((b & Bits(96 - begin)) << (ende - 96));
  972. ret = (__int16)(ret
  973. | ((c >> (8 - (ende - 96))) & Bits(ende - 96)));
  974. }
  975. }
  976. else
  977. {
  978. ret = (__int16)(c >> ((104 - begin) - (ende - begin))
  979. & Bits(ende - begin));
  980. }
  981. }
  982. return ret;
  983. }
  984. // Inhalt der LTDBKörper Klasse aus Dateisystem.h
  985. // Konstruktor
  986. LTDBBody::LTDBBody()
  987. : ReferenceCounter(),
  988. gr(0, 0),
  989. b(new Bild())
  990. {}
  991. LTDBBody::LTDBBody(LTDBKopf* k) // ruft Init auf
  992. : ReferenceCounter(),
  993. gr(0, 0),
  994. b(new Bild())
  995. {
  996. init(k);
  997. }
  998. // Destruktor
  999. LTDBBody::~LTDBBody()
  1000. {
  1001. b->release();
  1002. }
  1003. // nicht constant
  1004. void LTDBBody::init(LTDBKopf k) // Initialisiert, wird vor dem laden benötigt
  1005. {
  1006. gr = k.getSize();
  1007. int l = k.getTitelLength();
  1008. l = 4 + l * 5 + 24;
  1009. dateiSize = (l / 8.0 == l) ? (l / 8) : (l / 8 + 1);
  1010. }
  1011. void LTDBBody::init(LTDBKopf* k) // Initialisiert, wird vor dem laden benötigt
  1012. {
  1013. gr = k->getSize();
  1014. int l = k->getTitelLength();
  1015. l = 4 + l * 5 + 24;
  1016. dateiSize = (l / 8.0 == l) ? (l / 8) : (l / 8 + 1);
  1017. k->release();
  1018. }
  1019. void LTDBBody::laden(FBalken* zF, std::ifstream* inF) // läd das Bild
  1020. {
  1021. b->neuBild(gr.x, gr.y, 0xFF000000); // neues Bild erstellen
  1022. int* buff = b->getBuffer();
  1023. int breite = b->getBreite();
  1024. char byte = 0;
  1025. int index = 0;
  1026. LTDBPixel* davor = 0; // zuletzt geladener Pixel
  1027. LTDBPixel* dieser = new LTDBPixel(0); // momentan zu ladener Pixel
  1028. int begin = 0; // Pixelbegin, endposition in der byte variable
  1029. #ifdef WIN32
  1030. if (zF)
  1031. {
  1032. zF->reset();
  1033. zF->setAktionAnzahl(gr.x * gr.y);
  1034. }
  1035. #endif
  1036. while (index < gr.x * gr.y) // für jeden Pixel
  1037. {
  1038. if (!dieser) // wenn es nicht der erste Pixel ist
  1039. dieser = new LTDBPixel(dynamic_cast<LTDBPixel*>(davor->getThis()));
  1040. int ende = -1;
  1041. while (ende < 0) // Pixel laden
  1042. {
  1043. if (begin == 0) inF->read(&byte, 1);
  1044. ende = dieser->addByte(byte, (char)begin); // byte auswerten
  1045. begin = 0;
  1046. }
  1047. begin = ende;
  1048. if (begin == 8) begin = 0;
  1049. buff[(index % gr.x) + (index / gr.x) * breite] = dieser->zuFarbe();
  1050. if (davor) davor = (LTDBPixel*)davor->release();
  1051. davor = dynamic_cast<LTDBPixel*>(dieser->getThis());
  1052. dieser = (LTDBPixel*)dieser->release();
  1053. ++index;
  1054. #ifdef WIN32
  1055. if (zF) zF->aktionPlus();
  1056. #endif
  1057. }
  1058. if (davor) davor = (LTDBPixel*)davor->release();
  1059. }
  1060. void LTDBBody::setBild(Bild* b) // setzt das zu speichernde Bild
  1061. {
  1062. this->b->release();
  1063. this->b = b;
  1064. }
  1065. // constant
  1066. void LTDBBody::speichern(
  1067. FBalken* zF, std::ofstream* outF) const // speichert Bild
  1068. {
  1069. if (outF->is_open())
  1070. {
  1071. LTDBPixel* letzter = 0; // Letzter gespeicherter Pixel
  1072. LTDBPixel* dieser
  1073. = new LTDBPixel(0); // Der momentan zu speichernde Pixel
  1074. int begin = 0,
  1075. ende = 0; // Pixelbeginn, endposition in der byte variable
  1076. char byte = 0; // Der nächste byte der Datei
  1077. bool w = 0;
  1078. #ifdef WIN32
  1079. if (zF)
  1080. {
  1081. zF->reset();
  1082. zF->setAktionAnzahl(gr.x * gr.y);
  1083. }
  1084. #endif
  1085. int* pBuff = b->getBuffer();
  1086. for (int i = 0; i < gr.x * gr.y; ++i) // für jeden Pixel
  1087. {
  1088. if (!dieser) // wenn es nicht der erste Pixel ist
  1089. dieser = new LTDBPixel(
  1090. dynamic_cast<LTDBPixel*>(letzter->getThis()));
  1091. dieser->setFarbe(pBuff[i]); // Farbe des Pixels setzen
  1092. dieser->komprimieren(); // Pixel komprimieren
  1093. ende = -1;
  1094. while (ende < 0) // byte befüllen
  1095. {
  1096. ende = dieser->getNextByte(byte, begin);
  1097. begin = 0;
  1098. w = 0;
  1099. if (ende == -1 || ende == 8) // byte speichern
  1100. {
  1101. outF->write(&byte, 1);
  1102. w = 1;
  1103. byte = 0;
  1104. }
  1105. } // Pixel fertig
  1106. begin = ende;
  1107. if (begin == 8) begin = 0;
  1108. if (letzter) letzter->release();
  1109. letzter = dynamic_cast<LTDBPixel*>(
  1110. dieser->getThis()); // dieser wird zu letzter
  1111. dieser = (LTDBPixel*)dieser->release();
  1112. #ifdef WIN32
  1113. if (zF) zF->aktionPlus();
  1114. #endif
  1115. }
  1116. if (letzter) letzter = (LTDBPixel*)letzter->release();
  1117. if (!w)
  1118. {
  1119. outF->write(&byte, 1); // Das letzte byte speichern
  1120. }
  1121. outF->flush(); // dateistream speichern
  1122. }
  1123. }
  1124. Bild* LTDBBody::getBild() const // gibt das geladene Bild zurück
  1125. {
  1126. return dynamic_cast<Bild*>(b->getThis());
  1127. }
  1128. const Punkt& LTDBBody::getSize() const // gibt die größe des Bildes zurück
  1129. {
  1130. return gr;
  1131. }
  1132. // Inhalt det LTDBDatei Klasse aus Dateisystem.h
  1133. // Konstruktor
  1134. LTDBDatei::LTDBDatei()
  1135. : ReferenceCounter(),
  1136. pfad(new Text()),
  1137. datKpf(0)
  1138. {}
  1139. // Destruktor
  1140. LTDBDatei::~LTDBDatei()
  1141. {
  1142. if (pfad) pfad->release();
  1143. if (datKpf) datKpf->release();
  1144. }
  1145. // nicht constant
  1146. void LTDBDatei::setDatei(Text* pfad) // Setzt den Pfad zur Datei
  1147. { // Werte der eventuellen vorherigen Datei löschen
  1148. if (datKpf) datKpf = (LTDBDateiKopf*)datKpf->release();
  1149. // Pfad setzen
  1150. this->pfad->setText(dynamic_cast<Text*>(pfad->getThis()));
  1151. pfad->release();
  1152. }
  1153. void LTDBDatei::erstellen() // Erstellt die Datei
  1154. {
  1155. DateiPfadErstellen(dynamic_cast<Text*>(pfad->getThis()));
  1156. std::ofstream* outF = new std::ofstream(pfad->getText(), std::ios::binary);
  1157. int i = 0;
  1158. outF->write((char*)&i, 2);
  1159. delete outF;
  1160. }
  1161. void LTDBDatei::leseDaten(
  1162. FBalken* f) // Die Klasse ließt alle Bilder kurz ein, und merkt sich, an
  1163. // welcher stelle in der Datei was ist
  1164. { // Diese Funktion wird ein wenig Zeit in Anspruch nemen, dafüraber danach die
  1165. // anderen schneller machen
  1166. if (DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
  1167. {
  1168. if (datKpf) datKpf->release();
  1169. datKpf = new LTDBDateiKopf();
  1170. std::ifstream* inF
  1171. = new std::ifstream(pfad->getText(), std::ios::binary);
  1172. datKpf->laden(f, inF);
  1173. delete inF;
  1174. }
  1175. }
  1176. void LTDBDatei::remove() // Löscht die Datei
  1177. {
  1178. if (DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
  1179. {
  1180. DateiRemove(dynamic_cast<Text*>(pfad->getThis()));
  1181. if (datKpf) datKpf->release();
  1182. }
  1183. }
  1184. void LTDBDatei::remove(FBalken* f, Text* name) // Löscht ein Bild aus der Datei
  1185. {
  1186. if (DateiExistiert(dynamic_cast<Text*>(pfad->getThis())) && name)
  1187. {
  1188. if (!datKpf) leseDaten(0); // Daten einlesen
  1189. // Prüfen, ob Datei nicht vorhanden
  1190. if (!datKpf)
  1191. {
  1192. name->release();
  1193. return;
  1194. }
  1195. int index = datKpf->getBildIndex(dynamic_cast<Text*>(name->getThis()));
  1196. if (index == -1) // das bild existiert nicht
  1197. {
  1198. name->release();
  1199. return;
  1200. }
  1201. // Zwischenspeicherpfad ermitteln
  1202. Text* pf_tmp = new Text(pfad->getText());
  1203. char c = '0';
  1204. pf_tmp->append("0");
  1205. for (int i = 0; DateiExistiert(dynamic_cast<Text*>(pf_tmp->getThis()));
  1206. ++i)
  1207. {
  1208. c = (char)('0' + (i % 10));
  1209. if ((i % 10) == 0) pf_tmp->append("$");
  1210. pf_tmp->ersetzen(
  1211. pf_tmp->anzahlVon((char)('0' - ((i - 1) % 10))) - 1,
  1212. (char)('0' - ((i - 1) % 10)),
  1213. c);
  1214. }
  1215. std::ifstream* inF = new std::ifstream(
  1216. pfad->getText(), std::ios::binary); // Alte Datei öffnen
  1217. inF->seekg(0, std::ios::end);
  1218. __int64 datlen = inF->tellg();
  1219. inF->seekg(0, std::ios::beg);
  1220. std::ofstream* outF = new std::ofstream(
  1221. pf_tmp->getText(), std::ios::binary); // Neue Datei öffnen
  1222. if (inF->is_open() && outF->is_open())
  1223. {
  1224. __int64 position = datKpf->getBildPosition(index);
  1225. datKpf->removeBild(index);
  1226. datKpf->speichern(outF);
  1227. LTDBDateiKopf* kpf_tmp = new LTDBDateiKopf();
  1228. kpf_tmp->laden(0, inF);
  1229. kpf_tmp->release();
  1230. char byte = 0;
  1231. __int64 pos_minus = inF->tellg() - outF->tellp();
  1232. for (int i = 0; i < index; ++i)
  1233. datKpf->setBildPos(i, datKpf->getBildPosition(i) - pos_minus);
  1234. // Bytes bis zur Datei kopieren
  1235. for (__int64 i = inF->tellg(); i < position; ++i)
  1236. {
  1237. inF->read(&byte, 1);
  1238. outF->write(&byte, 1);
  1239. } // zu löschendes Bild überspringen
  1240. LTDBKopf* delkpf = new LTDBKopf();
  1241. delkpf->laden(inF);
  1242. LTDBBody* delkpr
  1243. = new LTDBBody(dynamic_cast<LTDBKopf*>(delkpf->getThis()));
  1244. delkpr->laden(f, inF);
  1245. delkpf = (LTDBKopf*)delkpf->release();
  1246. delkpr = (LTDBBody*)delkpr->release(); // restliche bytes kopieren
  1247. pos_minus = inF->tellg() - outF->tellp();
  1248. for (__int64 i = (__int64)inF->tellg(); i < datlen; ++i)
  1249. {
  1250. inF->read(&byte, 1);
  1251. outF->write(&byte, 1);
  1252. }
  1253. for (int i = index; i < datKpf->getbAnzahl(); ++i)
  1254. datKpf->setBildPos(i, datKpf->getBildPosition(i) - pos_minus);
  1255. outF->seekp(0, std::ios::beg);
  1256. datKpf->speichern(outF);
  1257. inF->close();
  1258. outF->close();
  1259. DateiRemove(dynamic_cast<Text*>(pfad->getThis()));
  1260. DateiUmbenennen(dynamic_cast<Text*>(pf_tmp->getThis()),
  1261. dynamic_cast<Text*>(pfad->getThis()));
  1262. }
  1263. delete inF;
  1264. delete outF;
  1265. pf_tmp = (Text*)pf_tmp->release();
  1266. }
  1267. if (name) name = (Text*)name->release();
  1268. }
  1269. Bild* LTDBDatei::laden(FBalken* f, Text* name) // Läd ein Bild aus der Datei
  1270. {
  1271. if (name)
  1272. {
  1273. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
  1274. {
  1275. name->release();
  1276. return 0;
  1277. }
  1278. if (!datKpf) leseDaten(0);
  1279. LTDBKopf* k_tmp = new LTDBKopf();
  1280. k_tmp->Init(dynamic_cast<Text*>(name->getThis()), Punkt(0, 0));
  1281. int index = datKpf->getBildIndex(k_tmp->getTitel());
  1282. k_tmp->release();
  1283. if (index == -1)
  1284. { // Fehlermeldung
  1285. Text* fehler = new Text("Das Bild ");
  1286. fehler->append(name);
  1287. fehler->append(" wurde nicht in der Datei\n");
  1288. fehler->append(dynamic_cast<Text*>(pfad->getThis()));
  1289. fehler->append(" gefunden!");
  1290. std::cout << fehler << "\n";
  1291. return 0;
  1292. }
  1293. std::ifstream* inF
  1294. = new std::ifstream(pfad->getText(), std::ios::binary);
  1295. // Begin der zu ladenden Datei ermitteln
  1296. __int64 position = datKpf->getBildPosition(index);
  1297. inF->seekg(position, std::ios::beg);
  1298. LTDBKopf* kpf = new LTDBKopf();
  1299. kpf->laden(inF);
  1300. Text* t = kpf->getTitel();
  1301. if (!t->istGleich(dynamic_cast<Text*>(name->getThis())))
  1302. { // Fehlermeldung
  1303. t->release();
  1304. kpf->release();
  1305. inF->close();
  1306. delete inF;
  1307. Text* fehler = new Text("Die Datei ");
  1308. fehler->append(pfad);
  1309. fehler->append(" ist ist keine gültige LTDB Datei!");
  1310. #ifdef WIN32
  1311. WMessageBox(0, new Text("Fehler"), fehler, MB_ICONERROR);
  1312. #endif
  1313. name->release();
  1314. return 0;
  1315. }
  1316. t->release();
  1317. LTDBBody* kpr = new LTDBBody(dynamic_cast<LTDBKopf*>(kpf->getThis()));
  1318. kpr->laden(f, inF); // Bild laden
  1319. Bild* ret = kpr->getBild();
  1320. kpr->release();
  1321. kpf->release();
  1322. inF->close();
  1323. delete inF;
  1324. name->release();
  1325. return ret;
  1326. }
  1327. return 0;
  1328. }
  1329. int LTDBDatei::speichern(
  1330. FBalken* f, Bild* bild, Text* name) // Speichert ein Bild in die Datei
  1331. {
  1332. int warn = -1;
  1333. if (name && bild)
  1334. {
  1335. if (DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
  1336. {
  1337. if (!datKpf) leseDaten(0);
  1338. int index
  1339. = datKpf->getBildIndex(dynamic_cast<Text*>(name->getThis()));
  1340. if (index == -1)
  1341. {
  1342. warn = 0;
  1343. LTDBKopf* kpf = new LTDBKopf();
  1344. warn = kpf->Init(
  1345. dynamic_cast<Text*>(name->getThis()), bild->getSize());
  1346. if (datKpf->getBildIndex(kpf->getTitel()) != -1)
  1347. {
  1348. std::cout
  1349. << "Es existiert bereits ein Bild mit diesem Namen!\n";
  1350. bild->release();
  1351. name->release();
  1352. kpf->release();
  1353. return -1;
  1354. }
  1355. // zwischendateipfad suchen
  1356. Text* pf_tmp = new Text(pfad->getText());
  1357. char c = '0';
  1358. pf_tmp->append("0");
  1359. for (int i = 0;
  1360. DateiExistiert(dynamic_cast<Text*>(pf_tmp->getThis()));
  1361. ++i)
  1362. {
  1363. c = (char)('0' + (i % 10));
  1364. if ((i % 10) == 0) pf_tmp->append("$");
  1365. pf_tmp->ersetzen(
  1366. pf_tmp->anzahlVon((char)('0' - ((i - 1) % 10))) - 1,
  1367. (char)('0' - ((i - 1) % 10)),
  1368. c);
  1369. }
  1370. std::ifstream* inF
  1371. = new std::ifstream(pfad->getText(), std::ios::binary);
  1372. inF->seekg(0, std::ios::end);
  1373. __int64 datLen = inF->tellg();
  1374. inF->seekg(0, std::ios::beg);
  1375. std::ofstream* outF
  1376. = new std::ofstream(pf_tmp->getText(), std::ios::binary);
  1377. datKpf->addBild(kpf->getTitel());
  1378. index = datKpf->getBildIndex(kpf->getTitel());
  1379. datKpf->speichern(outF);
  1380. LTDBDateiKopf* kpf_tmp = new LTDBDateiKopf();
  1381. kpf_tmp->laden(0, inF);
  1382. kpf_tmp->release();
  1383. __int64 pos_plus = outF->tellp() - inF->tellg();
  1384. for (int i = 0; i < index; ++i)
  1385. datKpf->setBildPos(
  1386. i, datKpf->getBildPosition(i) + pos_plus);
  1387. datKpf->setBildPos(index, datLen + pos_plus);
  1388. outF->seekp(0, std::ios::beg);
  1389. datKpf->speichern(outF);
  1390. char byte = 0;
  1391. for (__int64 i = inF->tellg(); i < datLen; ++i)
  1392. {
  1393. inF->read(&byte, 1);
  1394. outF->write(&byte, 1);
  1395. }
  1396. kpf->speichern(outF); // Bild Kopf speichern
  1397. LTDBBody* kpr
  1398. = new LTDBBody(dynamic_cast<LTDBKopf*>(kpf->getThis()));
  1399. kpr->setBild(dynamic_cast<Bild*>(bild->getThis()));
  1400. kpr->speichern(f, outF); // Bild speichern
  1401. kpf->release();
  1402. kpr->release();
  1403. inF->close();
  1404. outF->close();
  1405. delete inF;
  1406. delete outF;
  1407. DateiRemove(dynamic_cast<Text*>(pfad->getThis()));
  1408. DateiUmbenennen(
  1409. (Text*)pf_tmp, dynamic_cast<Text*>(pfad->getThis()));
  1410. }
  1411. }
  1412. }
  1413. if (name) name->release();
  1414. if (bild) bild->release();
  1415. return warn;
  1416. }
  1417. RCArray<Text>* LTDBDatei::zBildListe() // Listet alle Bilder in der datei auf
  1418. {
  1419. if (!datKpf) leseDaten(0);
  1420. if (datKpf) return datKpf->zBildListe();
  1421. return 0;
  1422. }
  1423. // constant
  1424. Text* LTDBDatei::getPfad() const // Gibt den Pfad zur Datei zurück
  1425. {
  1426. return dynamic_cast<Text*>(pfad->getThis());
  1427. }
  1428. int LTDBDatei::getBildAnzahl() const
  1429. {
  1430. if (!datKpf) return 0;
  1431. return datKpf->getbAnzahl();
  1432. }
  1433. bool LTDBDatei::istOffen() const // Prüft, ob die Datei geöffnet ist
  1434. {
  1435. if (!pfad) return 0;
  1436. return DateiExistiert(dynamic_cast<Text*>(pfad->getThis()));
  1437. }
  1438. #ifdef WIN32
  1439. // LTDS Dateivormat
  1440. // Inhalt der LTDSPixel Klasse aus DateiSystem.h
  1441. // Konstruktor
  1442. LTDSPixel::LTDSPixel(LTDSPixel* davor)
  1443. : ReferenceCounter(),
  1444. index(0),
  1445. iA(0),
  1446. miA(8),
  1447. maxIndex(1),
  1448. änder(0),
  1449. änderA(0),
  1450. komp(0),
  1451. alpha(0),
  1452. davor(davor)
  1453. {}
  1454. // Destruktor
  1455. LTDSPixel::~LTDSPixel()
  1456. {
  1457. if (davor) davor->release();
  1458. }
  1459. // nicht constant
  1460. // zum Laden gedacht
  1461. bool LTDSPixel::addBitZuFarbe(unsigned char bit)
  1462. {
  1463. if ( änderA && iA != miA) // Das Bit gehört zu Alpha
  1464. {
  1465. alpha |= ((bit & Bits(1))) << (7 - komp - iA);
  1466. ++iA;
  1467. }
  1468. else // Das Bit gehört zum nächsten Pixel
  1469. return false;
  1470. return true;
  1471. }
  1472. char LTDSPixel::addByte(
  1473. char byte, char begin) // gibt ende des Pixels zurück, -1 wenn nicht zu ende
  1474. {
  1475. if (begin >= 8 || begin < 0) return -1;
  1476. for (int i = begin; i < 8; ++i)
  1477. {
  1478. switch (index)
  1479. {
  1480. case 0:
  1481. // Das erste Bit eines Pixels speichert, ob sich an der
  1482. // Komprimierung etwas änderte
  1483. änder = ((byte >> (7 - i)) & Bits(1)) == 1;
  1484. if (!änder) // Ändert sich nichts an der Komprimierung, so werden
  1485. // die Werte vom vorherigen Pixel übernommen
  1486. {
  1487. if (!davor) // Die Datei ist beschädigt ( Der erste Pixel kann
  1488. // nicht von dem davor Übernemen )
  1489. {
  1490. MessageBox(NULL,
  1491. "Fehler, die Bilddatei ist beschädigt",
  1492. "Fehler",
  1493. MB_ICONERROR);
  1494. exit(0);
  1495. }
  1496. änderA = davor->getÄnderA();
  1497. komp = davor->getKomp();
  1498. miA -= komp;
  1499. if (!änderA) alpha = davor->getA();
  1500. maxIndex += änderA * (8 - komp); // Bestimmung der Länge
  1501. // des Pixels in Bits. Jede Farbe hat von grund auf 8 Bits,
  1502. // durch komprimierung kanns kleiner sein
  1503. }
  1504. else
  1505. maxIndex += 4; // Da der Pixel nicht die Werte des vorherigen
  1506. // übernimmt, wird er um 4 Bits größer
  1507. break;
  1508. case 1: // Das zweite Bit eines Pixels speichert entweder die
  1509. // Komprimierungsart, oder schon die Farbe
  1510. if ( änder) // Das Bit gehört zu den 4 Komprimierungsbits
  1511. änderA = ((byte >> (7 - i)) & Bits(1)) == 1;
  1512. else
  1513. {
  1514. if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
  1515. return i;
  1516. }
  1517. break;
  1518. case 2: // Das sechste Bit eines Pixels speichert entweder die
  1519. // Komprimierungsart, oder schon die Farbe
  1520. if ( änder) // Das Bit gehört zu den 4 Komprimierungsbits
  1521. komp |= (unsigned char)((byte >> (7 - i)) & Bits(1)) << 2;
  1522. else
  1523. {
  1524. if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
  1525. return i;
  1526. }
  1527. break;
  1528. case 3: // Das siebte Bit eines Pixels speichert entweder die
  1529. // Komprimierungsart, oder schon die Farbe
  1530. if ( änder) // Das Bit gehört zu den 4 Komprimierungsbits
  1531. komp |= (unsigned char)((byte >> (7 - i)) & Bits(1)) << 1;
  1532. else
  1533. {
  1534. if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
  1535. return i;
  1536. }
  1537. break;
  1538. case 4: // Das achte Bit eines Pixels speichert entweder die
  1539. // Komprimierungsart, oder schon die Farbe
  1540. if ( änder) // Das Bit gehört zu den 4 Komprimierungsbits
  1541. {
  1542. komp |= (unsigned char)((byte >> (7 - i)) & Bits(1));
  1543. // Das war das letzte Komprimierungsbit
  1544. // Komprimierung auswerten
  1545. miA -= komp;
  1546. if (!änderA) alpha = davor->getA();
  1547. maxIndex += änderA * (8 - komp); // Bitlänge des Pixels
  1548. }
  1549. else
  1550. {
  1551. if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
  1552. return i;
  1553. }
  1554. break;
  1555. default: // Die restlichen Bits speichern alle die Farbwerte des Pixels
  1556. if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
  1557. return i;
  1558. break;
  1559. }
  1560. ++index;
  1561. if (index >= maxIndex)
  1562. {
  1563. if (davor)
  1564. {
  1565. if ( änderA) alpha = davor->getA() + alpha;
  1566. davor = (LTDSPixel*)davor->release();
  1567. }
  1568. return i + 1;
  1569. }
  1570. }
  1571. return -1;
  1572. }
  1573. // zum speichern gedacht
  1574. void LTDSPixel::setAlpha(unsigned char alpha) // setzt die Farbe des Pixels
  1575. {
  1576. this->alpha = alpha;
  1577. }
  1578. void LTDSPixel::Komp() // Komprimiert den Pixel
  1579. {
  1580. maxIndex = 1;
  1581. if (!davor)
  1582. { // Das ist der erste Pixel
  1583. änder = 1;
  1584. änderA = 1;
  1585. maxIndex += 4;
  1586. miA = getBits(alpha);
  1587. }
  1588. else
  1589. { // Es wird die differenz zum vorrigen Pixel gespeichert
  1590. miA = getBits(alpha - davor->getA());
  1591. if (alpha != davor->getA())
  1592. änderA = 1;
  1593. else
  1594. änderA = 0;
  1595. } // Prüfen ob sich etwas ändert
  1596. if (!miA && änderA) ++miA;
  1597. komp = 8 - miA;
  1598. maxIndex += änderA * miA;
  1599. if (davor)
  1600. {
  1601. if ( änderA != davor->getÄnderA() || komp != davor->getKomp())
  1602. { // Es ändert sich etwas
  1603. änder = 1;
  1604. maxIndex += 4;
  1605. }
  1606. else
  1607. { // Es ändert sich nichts
  1608. änder = 0;
  1609. }
  1610. }
  1611. }
  1612. bool LTDSPixel::getNextFarbeBit(char& byte, int i)
  1613. {
  1614. unsigned char AA = alpha;
  1615. if (davor)
  1616. {
  1617. AA -= davor->getA();
  1618. }
  1619. if ( änderA && iA != miA) // Das Bit gehört zu Alpha
  1620. {
  1621. byte |= ((AA >> (7 - komp - iA)) & Bits(1)) << (7 - i);
  1622. ++iA;
  1623. }
  1624. else // Der Pixel ist bereits zu ende
  1625. return false;
  1626. return true;
  1627. }
  1628. char LTDSPixel::getNextByte(
  1629. char& byte, int bbegin) // Gibt die nächsten Bits Zurück, -1 wenn der Pixel
  1630. // nicht zu ende ist
  1631. {
  1632. // bbegin gibt an wohin in die byte-variable geschrieben werden soll
  1633. // die Funktion gibt das ende des Pixels in der byte-variable zurück
  1634. // -1 heißt, dass der Pixel nicht zu ende ist
  1635. for (int i = bbegin; i < 8; ++i)
  1636. {
  1637. switch (index)
  1638. {
  1639. case 0: // Das erste Bit des Pixels speichert, ob sich etwas an der
  1640. // Komprimierung ändert
  1641. byte |= ((int)änder & Bits(1)) << (7 - i);
  1642. break;
  1643. case 1: // Das zweite Bit des Pixels speichert entweder schon die Farbe
  1644. // oder die Komprimierung
  1645. if ( änder) // Komprimierung
  1646. byte |= ((int)änderA & Bits(1)) << (7 - i);
  1647. else // Farbe
  1648. {
  1649. if (!getNextFarbeBit(byte, i)) return i;
  1650. }
  1651. break;
  1652. case 2: // Das zweite Bit des Pixels speichert entweder schon die Farbe
  1653. // oder die Komprimierung
  1654. if ( änder) // Komprimierung
  1655. byte |= ((komp >> 2) & Bits(1)) << (7 - i);
  1656. else // Farbe
  1657. {
  1658. if (!getNextFarbeBit(byte, i)) return i;
  1659. }
  1660. break;
  1661. case 3: // Das dritte Bit des Pixels speichert entweder schon die Farbe
  1662. // oder die Komprimierung
  1663. if ( änder) // Komprimierung
  1664. byte |= ((komp >> 1) & Bits(1)) << (7 - i);
  1665. else // Farbe
  1666. {
  1667. if (!getNextFarbeBit(byte, i)) return i;
  1668. }
  1669. break;
  1670. case 4: // Das vierte Bit des Pixels speichert entweder schon die Farbe
  1671. // oder die Komprimierung
  1672. if ( änder) // Komprimierung
  1673. byte |= (komp & Bits(1)) << (7 - i);
  1674. else // Farbe
  1675. {
  1676. if (!getNextFarbeBit(byte, i)) return i;
  1677. }
  1678. break;
  1679. default: // Die restlichen Bits speichern die Farbe des Pixels
  1680. if (!getNextFarbeBit(byte, i)) return i;
  1681. break;
  1682. }
  1683. ++index;
  1684. if (index >= maxIndex)
  1685. {
  1686. if (davor) davor = (LTDSPixel*)davor->release();
  1687. return i + 1;
  1688. }
  1689. }
  1690. return -1;
  1691. }
  1692. // constant
  1693. unsigned char LTDSPixel::getKomp() const // hat sich die Komprimierung geändert
  1694. {
  1695. return komp;
  1696. }
  1697. bool LTDSPixel::getÄnderA() const // gibt zurück, ob sich der alphawert ändert
  1698. {
  1699. return änderA;
  1700. }
  1701. unsigned char LTDSPixel::getA() const // gibt Alpha zurück
  1702. {
  1703. return alpha;
  1704. }
  1705. // Inhalt der LTDSDateiKopf Klasse aus Dateisystem.h
  1706. // Konstruktor
  1707. LTDSDateiKopf::LTDSDateiKopf()
  1708. : ReferenceCounter(),
  1709. sganzahl(0),
  1710. gr(0),
  1711. pos(0)
  1712. {}
  1713. // Destruktor
  1714. LTDSDateiKopf::~LTDSDateiKopf()
  1715. {
  1716. delete[] gr;
  1717. delete[] pos;
  1718. }
  1719. // nicht constant
  1720. void LTDSDateiKopf::laden(std::ifstream* inF) // Lät aus inF
  1721. {
  1722. if (inF->good() && inF->is_open())
  1723. {
  1724. inF->read((char*)&sganzahl, 1);
  1725. delete[] gr;
  1726. delete[] pos;
  1727. gr = new unsigned char[sganzahl + 1];
  1728. pos = new int[sganzahl + 1];
  1729. gr[sganzahl] = 0;
  1730. pos[sganzahl] = 0;
  1731. for (int i = 0; i < sganzahl; ++i)
  1732. {
  1733. inF->read((char*)&gr[i], 1);
  1734. inF->read((char*)&pos[i], 4);
  1735. }
  1736. }
  1737. }
  1738. void LTDSDateiKopf::addSG(char sg) // Schriftgröße hinzufügen
  1739. {
  1740. ++sganzahl;
  1741. unsigned char* gr_tmp = gr;
  1742. int* pos_tmp = pos;
  1743. gr = new unsigned char[sganzahl + 1];
  1744. pos = new int[sganzahl + 1];
  1745. gr[sganzahl] = 0;
  1746. pos[sganzahl] = 0;
  1747. if (sganzahl - 1 > 0)
  1748. {
  1749. memcpy(gr, gr_tmp, 1 * (sganzahl - 1));
  1750. memcpy(pos, pos_tmp, 4 * (sganzahl - 1));
  1751. }
  1752. delete[] gr_tmp;
  1753. delete[] pos_tmp;
  1754. pos[sganzahl - 1] = 0;
  1755. gr[sganzahl - 1] = sg;
  1756. }
  1757. void LTDSDateiKopf::removeSG(char sg) // Schriftgröße entfernen
  1758. {
  1759. bool hatsg = 0;
  1760. int sgpos = 0;
  1761. for (int i = 0; i < sganzahl; ++i)
  1762. {
  1763. hatsg = gr[i] == sg;
  1764. sgpos = i;
  1765. if (hatsg) break;
  1766. }
  1767. if (hatsg)
  1768. {
  1769. --sganzahl;
  1770. unsigned char* gr_tmp = gr;
  1771. int* pos_tmp = pos;
  1772. gr = new unsigned char[sganzahl + 1];
  1773. pos = new int[sganzahl + 1];
  1774. gr[sganzahl] = 0;
  1775. pos[sganzahl] = 0;
  1776. for (int i = 0; i < sgpos; ++i)
  1777. {
  1778. gr[i] = gr_tmp[i];
  1779. pos[i] = pos_tmp[i];
  1780. }
  1781. for (int i = sgpos + 1; i < sganzahl; ++i)
  1782. {
  1783. gr[i - 1] = gr_tmp[i];
  1784. pos[i - 1] = pos_tmp[i];
  1785. }
  1786. delete[] gr_tmp;
  1787. delete[] pos_tmp;
  1788. }
  1789. }
  1790. // constant
  1791. void LTDSDateiKopf::speichern(std::ofstream* outF) const // Speichert nach outF
  1792. {
  1793. if (outF->is_open() && outF->good())
  1794. {
  1795. outF->write((char*)&sganzahl, 1);
  1796. for (int i = 0; i < sganzahl; ++i)
  1797. {
  1798. outF->write((char*)&gr[i], 1);
  1799. outF->write((char*)&pos[i], 4);
  1800. }
  1801. }
  1802. }
  1803. unsigned char* LTDSDateiKopf::getSchriftGrößeList()
  1804. const // gibt eine Liste mit gespeicherten Schriftgrößen zurück
  1805. {
  1806. return gr;
  1807. }
  1808. int* LTDSDateiKopf::getPositionList()
  1809. const // gibt eine Positionsliste der gespeicherten Schriftgrößen zurück
  1810. {
  1811. return pos;
  1812. }
  1813. int LTDSDateiKopf::getSchriftGrößeAnzahl()
  1814. const // gibt die Anzahl der gespeicherten Schriftgrößen zurück
  1815. {
  1816. return sganzahl;
  1817. }
  1818. // Inhalt der LTDSSchriftKopf Klasse aus Dateisystem.h
  1819. // Konstruktor
  1820. LTDSSchriftKopf::LTDSSchriftKopf()
  1821. : ReferenceCounter(),
  1822. schriftSize(0),
  1823. zeichen(0),
  1824. pos(0),
  1825. zeichenAnzahl(0)
  1826. {}
  1827. // Destruktor
  1828. LTDSSchriftKopf::~LTDSSchriftKopf()
  1829. {
  1830. delete[] pos;
  1831. delete[] zeichen;
  1832. }
  1833. // nicht constant
  1834. void LTDSSchriftKopf::laden(std::ifstream* inF) // läht von inF
  1835. {
  1836. if (inF->good() && inF->is_open())
  1837. {
  1838. inF->read((char*)&schriftSize, 1);
  1839. inF->read((char*)&zeichenAnzahl, 1);
  1840. delete[] pos;
  1841. delete[] zeichen;
  1842. zeichen = new unsigned char[zeichenAnzahl];
  1843. pos = new int[zeichenAnzahl + 1];
  1844. for (int i = 0; i < zeichenAnzahl; ++i)
  1845. {
  1846. inF->read((char*)&zeichen[i], 1);
  1847. inF->read((char*)&pos[i], 4);
  1848. }
  1849. pos[zeichenAnzahl] = 0;
  1850. }
  1851. }
  1852. void LTDSSchriftKopf::setSchriftgröße(unsigned char gr) // setze schriftgröße
  1853. {
  1854. schriftSize = gr;
  1855. }
  1856. void LTDSSchriftKopf::setZeichenAlphabet(
  1857. Alphabet* alphabet) // setzt die Zeichen von alphabet
  1858. {
  1859. int count = 0;
  1860. for (int i = 0; i < 256; ++i)
  1861. {
  1862. Buchstabe* zeich = alphabet->zBuchstabe(i);
  1863. if (zeich) ++count;
  1864. }
  1865. delete[] zeichen;
  1866. delete[] pos;
  1867. zeichen = new unsigned char[count];
  1868. pos = new int[count + 1];
  1869. pos[count] = 0;
  1870. zeichenAnzahl = count;
  1871. count = 0;
  1872. for (int i = 0; i < 256; ++i)
  1873. {
  1874. Buchstabe* zeich = alphabet->getBuchstabe(i);
  1875. if (zeich)
  1876. {
  1877. zeichen[count] = i;
  1878. pos[count] = 0;
  1879. ++count;
  1880. zeich->release();
  1881. }
  1882. }
  1883. schriftSize = alphabet->getSchriftSize();
  1884. alphabet->release();
  1885. }
  1886. void LTDSSchriftKopf::addZeichen(unsigned char zeichen) // Zeichen hinzufügen
  1887. {
  1888. ++zeichenAnzahl;
  1889. unsigned char* zeichen_tmp = this->zeichen;
  1890. int* pos_tmp = pos;
  1891. this->zeichen = new unsigned char[zeichenAnzahl];
  1892. pos = new int[zeichenAnzahl + 1];
  1893. if (zeichenAnzahl - 1 > 0)
  1894. {
  1895. memcpy(this->zeichen, zeichen_tmp, 1 * (zeichenAnzahl - 1));
  1896. memcpy(pos, pos_tmp, 4 * (zeichenAnzahl - 1));
  1897. }
  1898. delete[] zeichen_tmp;
  1899. delete[] pos_tmp;
  1900. this->zeichen[zeichenAnzahl - 1] = zeichen;
  1901. pos[zeichenAnzahl - 1] = 0;
  1902. pos[zeichenAnzahl] = 0;
  1903. }
  1904. void LTDSSchriftKopf::removeZeichen(unsigned char zeich) // Zeichen entfernen
  1905. {
  1906. bool hatZ = 0;
  1907. int zPos = 0;
  1908. for (int i = 0; i < zeichenAnzahl; ++i)
  1909. {
  1910. hatZ = zeichen[i] == zeich;
  1911. zPos = i;
  1912. if (hatZ) break;
  1913. }
  1914. if (hatZ)
  1915. {
  1916. --zeichenAnzahl;
  1917. unsigned char* zeichen_tmp = zeichen;
  1918. int* pos_tmp = pos;
  1919. zeichen = new unsigned char[zeichenAnzahl];
  1920. pos = new int[zeichenAnzahl + 1];
  1921. for (int i = 0; i < zPos; ++i)
  1922. {
  1923. zeichen[i] = zeichen_tmp[i];
  1924. pos[i] = pos_tmp[i];
  1925. }
  1926. for (int i = zPos + 1; i <= zeichenAnzahl; ++i)
  1927. {
  1928. zeichen[i - 1] = zeichen_tmp[i];
  1929. pos[i - 1] = pos_tmp[i];
  1930. }
  1931. pos[zeichenAnzahl] = 0;
  1932. delete[] zeichen_tmp;
  1933. delete[] pos_tmp;
  1934. }
  1935. }
  1936. // constant
  1937. void LTDSSchriftKopf::speichern(
  1938. std::ofstream* outF) const // speichert nach outF
  1939. {
  1940. if (outF->good() && outF->is_open())
  1941. {
  1942. outF->write((char*)&schriftSize, 1);
  1943. outF->write((char*)&zeichenAnzahl, 1);
  1944. for (int i = 0; i < zeichenAnzahl; ++i)
  1945. {
  1946. outF->write((char*)&zeichen[i], 1);
  1947. outF->write((char*)&pos[i], 4);
  1948. }
  1949. }
  1950. }
  1951. unsigned char
  1952. LTDSSchriftKopf::getSchriftGröße() const // gibt die Schriftgröße zurück
  1953. {
  1954. return schriftSize;
  1955. }
  1956. unsigned char
  1957. LTDSSchriftKopf::getZeichenAnzahl() const // gibt die Zeichenanzahl zurück
  1958. {
  1959. return zeichenAnzahl;
  1960. }
  1961. int* LTDSSchriftKopf::getPositionen() const // gibt die Zeichenpositionen zurück
  1962. {
  1963. return pos;
  1964. }
  1965. unsigned char* LTDSSchriftKopf::getZeichen() const // gibt die zeichen zurück
  1966. {
  1967. return zeichen;
  1968. }
  1969. // Inhalt der LTDSBuchstabenKopf Klasse aus Dateisystem.h
  1970. // Konstruktor
  1971. LTDSBuchstabenKopf::LTDSBuchstabenKopf()
  1972. : ReferenceCounter(),
  1973. zeichen(0),
  1974. size(0, 0)
  1975. {}
  1976. // nicht constant
  1977. void LTDSBuchstabenKopf::laden(std::ifstream* inF) // lät aus inF
  1978. {
  1979. if (inF->good() && inF->is_open())
  1980. {
  1981. inF->read((char*)&zeichen, 1);
  1982. inF->read((char*)&size.x, 1);
  1983. inF->read((char*)&size.y, 1);
  1984. }
  1985. }
  1986. void LTDSBuchstabenKopf::init(unsigned char zeichen,
  1987. const Punkt& größe) // initialisierung( für speichern )
  1988. {
  1989. this->zeichen = zeichen;
  1990. this->size = größe;
  1991. }
  1992. void LTDSBuchstabenKopf::init(unsigned char zeichen, int br, int hö )
  1993. {
  1994. this->zeichen = zeichen;
  1995. size.x = br, size.y = hö;
  1996. }
  1997. // constant
  1998. void LTDSBuchstabenKopf::speichern(
  1999. std::ofstream* outF) const // speichertn nach outF
  2000. {
  2001. if (outF->good() && outF->is_open())
  2002. {
  2003. outF->write((char*)&zeichen, 1);
  2004. outF->write((char*)&size.x, 1);
  2005. outF->write((char*)&size.y, 1);
  2006. }
  2007. }
  2008. unsigned char LTDSBuchstabenKopf::getZeichen() const // gibt das Zeichen zurück
  2009. {
  2010. return zeichen;
  2011. }
  2012. int LTDSBuchstabenKopf::getBreite() const // gibt die Breite zurück
  2013. {
  2014. return size.x;
  2015. }
  2016. int LTDSBuchstabenKopf::getHöhe() const // gibt die höhe zurück
  2017. {
  2018. return size.y;
  2019. }
  2020. const Punkt& LTDSBuchstabenKopf::getGröße() const // gibt die Größe zurück
  2021. {
  2022. return size;
  2023. }
  2024. // Inhalt der LTDSBuchstabenKörper Klasse aus Dateisystem.h
  2025. // Konstruktor
  2026. LTDSBuchstabenKörper::LTDSBuchstabenKörper(LTDSBuchstabenKopf* kopf)
  2027. : ReferenceCounter(),
  2028. size(kopf->getGröße()),
  2029. zeichen(kopf->getZeichen()),
  2030. buchstabe(new Buchstabe())
  2031. {
  2032. buchstabe->NeuBuchstabe(size);
  2033. kopf->release();
  2034. }
  2035. // Destruktor
  2036. LTDSBuchstabenKörper::~LTDSBuchstabenKörper()
  2037. {
  2038. if (buchstabe) buchstabe->release();
  2039. }
  2040. // nicht constant
  2041. void LTDSBuchstabenKörper::setBuchstabe(
  2042. Buchstabe* zeichen) // setzt den Buchstaben
  2043. {
  2044. if (buchstabe) buchstabe->release();
  2045. buchstabe = zeichen;
  2046. }
  2047. void LTDSBuchstabenKörper::laden(std::ifstream* inF) // Läht aus inF
  2048. {
  2049. if (inF->good() && inF->is_open())
  2050. {
  2051. LTDSPixel* vorher = 0;
  2052. LTDSPixel* jetzt = new LTDSPixel(vorher);
  2053. char byte = 0;
  2054. int beg = 0;
  2055. int ende = -1;
  2056. for (int i = 0; i < size.x * size.y; ++i)
  2057. {
  2058. if (!jetzt) // wenn es nicht der erste Pixel ist
  2059. jetzt = new LTDSPixel(
  2060. dynamic_cast<LTDSPixel*>(vorher->getThis()));
  2061. int ende = -1;
  2062. while (ende < 0) // Pixel laden
  2063. {
  2064. if (beg == 0) inF->read(&byte, 1);
  2065. ende = jetzt->addByte(byte, beg); // byte auswerten
  2066. beg = 0;
  2067. }
  2068. beg = ende;
  2069. if (beg == 8) beg = 0;
  2070. if (buchstabe) buchstabe->setPixel(i, jetzt->getA());
  2071. if (vorher) vorher = (LTDSPixel*)vorher->release();
  2072. vorher = dynamic_cast<LTDSPixel*>(jetzt->getThis());
  2073. jetzt = (LTDSPixel*)jetzt->release();
  2074. }
  2075. if (vorher) vorher->release();
  2076. if (jetzt) jetzt->release();
  2077. }
  2078. }
  2079. // constant
  2080. void LTDSBuchstabenKörper::speichern(
  2081. std::ofstream* outF) const // speichert nach outF
  2082. {
  2083. if (outF->good() && outF->is_open())
  2084. {
  2085. LTDSPixel* vorher = 0; // Letzter gespeicherter Pixel
  2086. LTDSPixel* jetzt
  2087. = new LTDSPixel(0); // Der momentan zu speichernde Pixel
  2088. int begin = 0,
  2089. ende = 0; // Pixelbeginn, endposition in der byte variable
  2090. char byte = 0; // Der nächste byte der Datei
  2091. bool w = 0;
  2092. unsigned char* alphaBuff = buchstabe->getBuff();
  2093. for (int i = 0; i < size.x * size.y; ++i) // für jeden Pixel
  2094. {
  2095. if (!jetzt) // wenn es nicht der erste Pixel ist
  2096. jetzt = new LTDSPixel(
  2097. dynamic_cast<LTDSPixel*>(vorher->getThis()));
  2098. jetzt->setAlpha(alphaBuff[i]); // Farbe des Pixels setzen
  2099. jetzt->Komp(); // Pixel komprimieren
  2100. ende = -1;
  2101. while (ende < 0) // byte befüllen
  2102. {
  2103. ende = jetzt->getNextByte(byte, begin);
  2104. begin = 0;
  2105. w = 0;
  2106. if (ende == -1 || ende == 8) // byte speichern
  2107. {
  2108. outF->write(&byte, 1);
  2109. w = 1;
  2110. byte = 0;
  2111. }
  2112. } // Pixel fertig
  2113. begin = ende;
  2114. if (begin == 8) begin = 0;
  2115. if (vorher) vorher->release();
  2116. vorher = dynamic_cast<LTDSPixel*>(
  2117. jetzt->getThis()); // dieser wird zu letzter
  2118. jetzt = (LTDSPixel*)jetzt->release();
  2119. }
  2120. if (vorher) vorher = (LTDSPixel*)vorher->release();
  2121. if (!w)
  2122. {
  2123. outF->write(&byte, 1); // Das letzte byte speichern
  2124. }
  2125. outF->flush(); // dateistream speichern
  2126. }
  2127. }
  2128. Buchstabe*
  2129. LTDSBuchstabenKörper::getBuchstabe() const // gibt den Buchstaben zurück
  2130. {
  2131. return dynamic_cast<Buchstabe*>(buchstabe->getThis());
  2132. }
  2133. unsigned char
  2134. LTDSBuchstabenKörper::getZeichen() const // gibt das Zeichen zurück
  2135. {
  2136. return zeichen;
  2137. }
  2138. // Inhalt der LTDSDatei Klasse aus DAteisystem.h
  2139. // Konstruktor
  2140. LTDSDatei::LTDSDatei()
  2141. : ReferenceCounter(),
  2142. pfad(new Text()),
  2143. dateiKopf(0)
  2144. {}
  2145. // Destruktor
  2146. LTDSDatei::~LTDSDatei()
  2147. {
  2148. if (dateiKopf) dateiKopf->release();
  2149. pfad->release();
  2150. }
  2151. // nicht constant
  2152. void LTDSDatei::setPfad(Text* txt) // setzt den Pfad zur Datei
  2153. {
  2154. if (dateiKopf) dateiKopf = (LTDSDateiKopf*)dateiKopf->release();
  2155. pfad->setText(txt->getText());
  2156. txt->release();
  2157. }
  2158. void LTDSDatei::leseDaten() // ließt den Dateikopf
  2159. {
  2160. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return;
  2161. if (dateiKopf) dateiKopf->release();
  2162. dateiKopf = new LTDSDateiKopf();
  2163. std::ifstream* inF = new std::ifstream(pfad->getText(), std::ios::binary);
  2164. dateiKopf->laden(inF);
  2165. inF->close();
  2166. delete inF;
  2167. }
  2168. void LTDSDatei::addSchriftgröße(
  2169. Alphabet* alphabet) // fügt eine Schriftgröße hinzu
  2170. {
  2171. if (!DateiExistiert(dynamic_cast<Text*>(
  2172. pfad->getThis()))) // prüfen, ob die Datei existiert
  2173. return;
  2174. if (!dateiKopf) // prüfen, ob der Dateikopf schon gelesen wurde
  2175. leseDaten();
  2176. int sgröße
  2177. = alphabet
  2178. ->getSchriftSize(); // Schriftgröße die hinzugefügt werden soll
  2179. unsigned char* sglist
  2180. = dateiKopf->getSchriftGrößeList(); // Liste von bereits vorhandenen
  2181. // Schriftgrößen
  2182. unsigned char sganzahl
  2183. = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der bereits vorhandenen
  2184. // Schriftgrößen
  2185. for (int i = 0; i < sganzahl;
  2186. ++i) // prüfen, ob die Schriftgröße bereits existiert
  2187. {
  2188. if (sglist[i] == sgröße)
  2189. {
  2190. alphabet->release();
  2191. return;
  2192. }
  2193. }
  2194. dateiKopf->addSG(sgröße); // Schriftgröße dem Dateikopf hinzufügen
  2195. int* sgPosList
  2196. = dateiKopf
  2197. ->getPositionList(); // Liste mit positionen der Schriftgrößen
  2198. sglist = dateiKopf->getSchriftGrößeList(); // Liste von bereits vorhandenen
  2199. // Schriftgrößen
  2200. std::ifstream* inF
  2201. = new std::ifstream(pfad->getText(), std::ios::binary); // alte Datei
  2202. pfad->append("0");
  2203. std::ofstream* outF
  2204. = new std::ofstream(pfad->getText(), std::ios::binary); // neue Datei
  2205. dateiKopf->speichern(outF); // Dateikopf in neue datei speichern
  2206. inF->seekg(1 + 5 * sganzahl,
  2207. std::ios::beg); // Position der ersten Schriftgröße in der alten Datei
  2208. for (int i = 0; i < sganzahl;
  2209. ++i) // Buchstabenpositionen aller Schriftgrößen aktualisieren
  2210. {
  2211. LTDSSchriftKopf* sgKpf_tmp
  2212. = new LTDSSchriftKopf(); // Schriftgrößen Kopf
  2213. sgKpf_tmp->laden(inF); // aus alter Datei laden
  2214. int* zeichP_tmp
  2215. = sgKpf_tmp->getPositionen(); // Zeichenpositionen der Schriftgröße
  2216. unsigned char zeichA_tmp
  2217. = sgKpf_tmp
  2218. ->getZeichenAnzahl(); // Anzahl von Zeichen der Schriftgröße
  2219. for (int i1 = 0; i1 < zeichA_tmp; ++i1)
  2220. zeichP_tmp[i1] += 5; // Buchstabenpositionen aktualisieren
  2221. sgKpf_tmp->speichern(outF); // Schriftgröße Kopf in neue Datei speichern
  2222. int beginByte
  2223. = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten
  2224. // Schriftgröße in neue Datei kopieren
  2225. int endByte = sgPosList[i + 1];
  2226. if (!endByte)
  2227. {
  2228. inF->seekg(0, std::ios::end);
  2229. endByte = (int)inF->tellg();
  2230. inF->seekg(beginByte, std::ios::beg);
  2231. }
  2232. char byte;
  2233. for (int i1 = beginByte; i1 < endByte; ++i1) // Kopiervorgang
  2234. {
  2235. inF->read(&byte, 1);
  2236. outF->write(&byte, 1);
  2237. }
  2238. sgKpf_tmp->release();
  2239. }
  2240. inF->close(); // Alte datei schließen
  2241. sgPosList[sganzahl] = (int)outF->tellp();
  2242. outF->seekp(0, std::ios::beg);
  2243. for (int i = 0; i < sganzahl; ++i) // Positionen im Dateikopf aktualisieren
  2244. sgPosList[i] += 5;
  2245. dateiKopf->speichern(outF); // aktualisierter Dateikopf speichern
  2246. outF->seekp(sgPosList[sganzahl], std::ios::beg);
  2247. LTDSSchriftKopf* sgkopf
  2248. = new LTDSSchriftKopf(); // Kopf der neuen Schriftgröße
  2249. sgkopf->setZeichenAlphabet(dynamic_cast<Alphabet*>(
  2250. alphabet->getThis())); // Kopf der Schriftgröße initialisieren
  2251. sgkopf->speichern(outF); // Kopf der Schriftgröße speichern
  2252. int* BuchstabenPosList
  2253. = sgkopf->getPositionen(); // positionen der verschiedenen Zeichen in
  2254. // der Datei( nuch 0 )
  2255. int count = 0;
  2256. for (int i = 0; i < 256; ++i)
  2257. {
  2258. Buchstabe* zeich = alphabet->getBuchstabe(i);
  2259. if (zeich)
  2260. {
  2261. BuchstabenPosList[count]
  2262. = (int)outF->tellp(); // position des Zeichens setzen
  2263. LTDSBuchstabenKopf* zeichKpf
  2264. = new LTDSBuchstabenKopf(); // Zeichenkopf
  2265. zeichKpf->init(i, zeich->getBreite(), zeich->getHeight());
  2266. zeichKpf->speichern(outF); // Zeichenkopf speichern
  2267. LTDSBuchstabenKörper* zeichKörp
  2268. = new LTDSBuchstabenKörper(dynamic_cast<LTDSBuchstabenKopf*>(
  2269. zeichKpf->getThis())); // Zeichenkörper
  2270. zeichKpf->release();
  2271. zeichKörp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
  2272. zeichKörp->speichern(outF); // Zeichenkörper speichern
  2273. zeich->release();
  2274. ++count;
  2275. }
  2276. }
  2277. outF->seekp(sgPosList[sganzahl], std::ios::beg);
  2278. sgkopf->speichern(outF); // aktualisierter Schriftgrößen Kopf speichern
  2279. outF->close();
  2280. Text* pfad2 = new Text();
  2281. pfad2->setText(pfad->getText());
  2282. pfad->remove(pfad->getLength() - 1, pfad->getLength());
  2283. DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // Alte datei Löschen
  2284. DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
  2285. dynamic_cast<Text*>(
  2286. pfad->getThis())); // neue Datei nach alte umbenennen
  2287. pfad2->release(); // Speicher freigeben
  2288. sgkopf->release();
  2289. delete inF;
  2290. delete outF;
  2291. alphabet->release();
  2292. }
  2293. void LTDSDatei::addBuchstabe(int gr,
  2294. Buchstabe* zeich,
  2295. unsigned char zeichen) // Fügt einer Schriftgröße einen Buchstaben hinzu
  2296. {
  2297. if (!DateiExistiert(
  2298. dynamic_cast<Text*>(pfad->getThis()))) // prüfen ob Datei existiert
  2299. {
  2300. zeich->release();
  2301. return;
  2302. }
  2303. if (!dateiKopf) // prüfen, ob der DAteikopf geladen wurde
  2304. leseDaten();
  2305. unsigned char* sgList
  2306. = dateiKopf
  2307. ->getSchriftGrößeList(); // Liste mit Schriftgrößen aus der Datei
  2308. int* sgPosList = dateiKopf->getPositionList(); // Liste mit Schriftgrößen
  2309. // positionen aus Datei
  2310. unsigned char sgAnzahl
  2311. = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl von Schriftgrößen aus
  2312. // der Datei
  2313. int sgNum = -1;
  2314. for (int i = 0; i < sgAnzahl;
  2315. ++i) // Position der richtigen Schriftgröße ermitteln
  2316. {
  2317. if (sgList[i] == gr)
  2318. {
  2319. sgNum = i;
  2320. break;
  2321. }
  2322. }
  2323. std::ifstream* inF
  2324. = new std::ifstream(pfad->getText(), std::ios::binary); // Alte Datei
  2325. pfad->append("0");
  2326. std::ofstream* outF
  2327. = new std::ofstream(pfad->getText(), std::ios::binary); // Neue Datei
  2328. inF->seekg(1 + 5 * sgAnzahl, std::ios::beg);
  2329. if (sgNum == -1) // Die Schriftgröße existiert noch nicht und wird erstellt
  2330. {
  2331. dateiKopf->addSG(gr); // Schriftgröße dem Dateikopf hinzufügen
  2332. sgPosList = dateiKopf->getPositionList();
  2333. sgList = dateiKopf->getSchriftGrößeList();
  2334. dateiKopf->speichern(outF); // Dateikopf speichern
  2335. inF->seekg(
  2336. 1 + 5 * sgAnzahl, std::ios::beg); // Position der ersten
  2337. // Schriftgröße in der alten Datei
  2338. for (int i = 0; i < sgAnzahl;
  2339. ++i) // Buchstabenpositionen aller Schriftgrößen aktualisieren
  2340. {
  2341. LTDSSchriftKopf* sgKpf_tmp
  2342. = new LTDSSchriftKopf(); // Schriftgrößen Kopf
  2343. sgKpf_tmp->laden(inF); // aus alter Datei laden
  2344. int* zeichP_tmp
  2345. = sgKpf_tmp
  2346. ->getPositionen(); // Zeichenpositionen der Schriftgröße
  2347. unsigned char zeichA_tmp
  2348. = sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der
  2349. // Schriftgröße
  2350. for (int i1 = 0; i1 < zeichA_tmp; ++i1)
  2351. zeichP_tmp[i1] += 5; // Buchstabenpositionen aktualisieren
  2352. sgKpf_tmp->speichern(
  2353. outF); // Schriftgröße Kopf in neue Datei speichern
  2354. int beginByte
  2355. = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten
  2356. // Schriftgröße in neue Datei kopieren
  2357. int endByte = sgPosList[i + 1];
  2358. if (i + 1 >= sgAnzahl)
  2359. {
  2360. inF->seekg(0, std::ios::end);
  2361. endByte = (int)inF->tellg();
  2362. inF->seekg(beginByte, std::ios::beg);
  2363. }
  2364. char byte;
  2365. for (int i1 = beginByte; i1 < endByte; ++i1) // Kopiervorgang
  2366. {
  2367. inF->read(&byte, 1);
  2368. outF->write(&byte, 1);
  2369. }
  2370. sgKpf_tmp->release();
  2371. }
  2372. sgPosList[sgAnzahl] = (int)outF->tellp();
  2373. outF->seekp(0, std::ios::beg);
  2374. for (int i = 0; i < sgAnzahl;
  2375. ++i) // Positionen im Dateikopf aktualisieren
  2376. sgPosList[i] += 5;
  2377. dateiKopf->speichern(outF); // aktualisierter Dateikopf speichern
  2378. outF->seekp(sgPosList[sgAnzahl], std::ios::beg);
  2379. LTDSSchriftKopf* sgKpf
  2380. = new LTDSSchriftKopf(); // Schriftgröße Kopf initialisiern
  2381. sgKpf->setSchriftgröße(gr);
  2382. sgKpf->addZeichen(zeichen);
  2383. sgKpf->getPositionen()[0] = (int)outF->tellp() + 7;
  2384. sgKpf->speichern(outF); // Schriftgröße Kopf speichern
  2385. sgKpf->release();
  2386. LTDSBuchstabenKopf* zeichKpf
  2387. = new LTDSBuchstabenKopf(); // Buchstabenkopf
  2388. zeichKpf->init(zeichen, zeich->getSize());
  2389. zeichKpf->speichern(outF); // Buchstabenkopf speichern
  2390. LTDSBuchstabenKörper* zeichKörp
  2391. = new LTDSBuchstabenKörper(dynamic_cast<LTDSBuchstabenKopf*>(
  2392. zeichKpf->getThis())); // Buchstabenkörper
  2393. zeichKpf->release();
  2394. zeichKörp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
  2395. zeichKörp->speichern(outF); // Buchstabenkörper speichern
  2396. zeichKörp->release();
  2397. }
  2398. else
  2399. {
  2400. dateiKopf->speichern(outF); // Dateikopf speichern
  2401. int beginByte
  2402. = 1 + 5 * sgAnzahl; // Die restlichen bytes bis zur nächsten
  2403. // Schriftgröße in neue Datei kopieren
  2404. int endByte = sgPosList[sgNum];
  2405. char byte;
  2406. for (int i1 = beginByte; i1 < endByte;
  2407. ++i1) // Kopiervorgang bis zur angegebenen größe
  2408. {
  2409. inF->read(&byte, 1);
  2410. outF->write(&byte, 1);
  2411. }
  2412. LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf(); // Schriftgröße Kopf
  2413. sgKpf->laden(inF);
  2414. for (int i = 0; i < sgKpf->getZeichenAnzahl(); ++i)
  2415. sgKpf->getPositionen()[i] += 5;
  2416. sgKpf->addZeichen(zeichen);
  2417. int indexPlus = 5;
  2418. int zeichenPos = sgPosList[sgNum + 1]; // position des neuen Zeichens
  2419. if (sgNum + 1 >= sgAnzahl)
  2420. {
  2421. int tmp = (int)inF->tellg();
  2422. inF->seekg(0, std::ios::end);
  2423. zeichenPos = (int)inF->tellg();
  2424. inF->seekg(tmp, std::ios::beg);
  2425. }
  2426. zeichenPos += indexPlus;
  2427. sgKpf->getPositionen()[sgKpf->getZeichenAnzahl() - 1] = zeichenPos;
  2428. sgKpf->speichern(outF); // Schriftgröße Kopf speichern
  2429. sgKpf->release();
  2430. for (int i = (int)inF->tellg() + indexPlus; i < zeichenPos;
  2431. ++i) // Kopiervorgang bis zum Zeichenbeginn
  2432. {
  2433. inF->read(&byte, 1);
  2434. outF->write(&byte, 1);
  2435. }
  2436. LTDSBuchstabenKopf* zeichKpf = new LTDSBuchstabenKopf(); // Zeichenkopf
  2437. zeichKpf->init(zeichen, zeich->getSize());
  2438. zeichKpf->speichern(outF); // Zeichenkopf speichern
  2439. LTDSBuchstabenKörper* zeichKörp
  2440. = new LTDSBuchstabenKörper(dynamic_cast<LTDSBuchstabenKopf*>(
  2441. zeichKpf->getThis())); // Zeichenkörper
  2442. zeichKpf->release();
  2443. zeichKörp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
  2444. zeichKörp->speichern(outF); // Zeichenkörper speichern
  2445. zeichKörp->release();
  2446. int nowPos = (int)outF->tellp();
  2447. indexPlus += nowPos - zeichenPos;
  2448. for (int i = sgNum + 1; i < sgAnzahl; ++i) // Dateikopf aktualisieren
  2449. sgPosList[i] += indexPlus;
  2450. outF->seekp(0, std::ios::beg);
  2451. dateiKopf->speichern(outF); // Dateikopf speichern
  2452. outF->seekp(nowPos, std::ios::beg);
  2453. for (int i = sgNum + 1; i < sgAnzahl;
  2454. ++i) // Restliche Schriftgrößen aktualisieren
  2455. {
  2456. LTDSSchriftKopf* sgKpf_tmp
  2457. = new LTDSSchriftKopf(); // Schriftgrößen Kopf
  2458. sgKpf_tmp->laden(inF); // aus alter Datei laden
  2459. int* zeichP_tmp
  2460. = sgKpf_tmp
  2461. ->getPositionen(); // Zeichenpositionen der Schriftgröße
  2462. unsigned char zeichA_tmp
  2463. = sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der
  2464. // Schriftgröße
  2465. for (int i1 = 0; i1 < zeichA_tmp; ++i1)
  2466. zeichP_tmp[i1]
  2467. += indexPlus; // Buchstabenpositionen aktualisieren
  2468. sgKpf_tmp->speichern(
  2469. outF); // Schriftgröße Kopf in neue Datei speichern
  2470. int beginByte
  2471. = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten
  2472. // Schriftgröße in neue Datei kopieren
  2473. int endByte = sgPosList[i + 1];
  2474. if (i + 1 >= sgAnzahl)
  2475. {
  2476. inF->seekg(0, std::ios::end);
  2477. endByte = (int)inF->tellg();
  2478. inF->seekg(beginByte, std::ios::beg);
  2479. }
  2480. char byte;
  2481. for (int i1 = beginByte; i1 < endByte; ++i1) // Kopiervorgang
  2482. {
  2483. inF->read(&byte, 1);
  2484. outF->write(&byte, 1);
  2485. }
  2486. sgKpf_tmp->release();
  2487. }
  2488. }
  2489. inF->close();
  2490. outF->close();
  2491. Text* pfad2 = new Text(pfad->getText());
  2492. pfad->remove(pfad->getLength() - 1, pfad->getLength());
  2493. DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // Alte Datei löschen
  2494. DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
  2495. dynamic_cast<Text*>(pfad->getThis())); // Neue Datei in alte umbenennen
  2496. pfad2->release(); // Speicher freigeben
  2497. delete inF;
  2498. delete outF;
  2499. zeich->release();
  2500. }
  2501. void LTDSDatei::löscheSchrifrGröße(
  2502. int gr) // Löscht eine Schriftgröße aus der Datei
  2503. {
  2504. if (!DateiExistiert(
  2505. dynamic_cast<Text*>(pfad->getThis()))) // prüfen, ob Datei existiert
  2506. return;
  2507. if (!dateiKopf) // prüfen, ob der Dateikopf geladen wurde
  2508. leseDaten();
  2509. unsigned char* sgList
  2510. = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen
  2511. unsigned char sgAnzahl
  2512. = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der Schriftgrößen
  2513. int sgNum = -1;
  2514. for (int i = 0; i < sgAnzahl; ++i) // zu löschende Schriftgröße suchen
  2515. {
  2516. if (sgList[i] == gr)
  2517. {
  2518. sgNum = i;
  2519. break;
  2520. }
  2521. }
  2522. if (sgNum == -1) // Die Schriftgröße ist nicht vorhanden
  2523. return;
  2524. int* sgPosList
  2525. = dateiKopf
  2526. ->getPositionList(); // Liste von Positionen der Schriftgrößen
  2527. std::ifstream* inF
  2528. = new std::ifstream(pfad->getText(), std::ios::binary); // alte Datei
  2529. pfad->append("0");
  2530. std::ofstream* outF
  2531. = new std::ofstream(pfad->getText(), std::ios::binary); // neue Datei
  2532. outF->seekp(1 + 5 * (sgAnzahl - 1), std::ios::beg);
  2533. inF->seekg(1 + 5 * sgAnzahl, std::ios::beg);
  2534. for (int i = 0; i < sgNum;
  2535. ++i) // Schriftgrößen vor der zu löschenden Schriftgröße aktualisieren
  2536. {
  2537. LTDSSchriftKopf* sgKpf_tmp
  2538. = new LTDSSchriftKopf(); // Schriftgrößen Kopf
  2539. sgKpf_tmp->laden(inF); // Schriftgrößen Kopf laden
  2540. int* zeichPosLTmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen
  2541. unsigned char zeichATmp
  2542. = sgKpf_tmp->getZeichenAnzahl(); // Zeichenanzahl
  2543. for (int i1 = 0; i1 < zeichATmp;
  2544. ++i1) // Position der Zeichen um 5 bytes zurücksetzen
  2545. zeichPosLTmp[i1] -= 5;
  2546. sgKpf_tmp->speichern(outF); // speichern in Neue Datei
  2547. char byte = 0;
  2548. for (int i1 = (int)inF->tellg(); i1 < sgPosList[i + 1];
  2549. ++i1) // Den Körper des Zeichens Kopieren
  2550. {
  2551. inF->read(&byte, 1);
  2552. outF->write(&byte, 1);
  2553. }
  2554. sgKpf_tmp->release();
  2555. }
  2556. int indexMinus = 5 + sgPosList[sgNum + 1] - (int)inF->tellg();
  2557. inF->seekg(sgPosList[sgNum + 1], std::ios::beg);
  2558. for (int i = sgNum + 1; i < sgAnzahl;
  2559. ++i) // Die Schriftgröße nach der zu löschenden Schriftgröße
  2560. {
  2561. LTDSSchriftKopf* sgKpf_tmp
  2562. = new LTDSSchriftKopf(); // Schriftgrößen Kopf
  2563. sgKpf_tmp->laden(inF); // Schriftgrößen Kopf laden
  2564. int* zeichPosLTmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen
  2565. unsigned char zeichATmp
  2566. = sgKpf_tmp->getZeichenAnzahl(); // Zeichenanzahl
  2567. for (int i1 = 0; i1 < zeichATmp;
  2568. ++i1) // Position der Zeichen aktualisieren
  2569. zeichPosLTmp[i1] -= indexMinus;
  2570. sgKpf_tmp->speichern(outF); // speichern in Neue Datei
  2571. char byte = 0;
  2572. int BeginByte = (int)inF->tellg();
  2573. int EndByte = sgPosList[i + 1];
  2574. if (!EndByte)
  2575. {
  2576. inF->seekg(0, std::ios::end);
  2577. EndByte = (int)inF->tellg();
  2578. inF->seekg(BeginByte, std::ios::beg);
  2579. }
  2580. for (int i1 = BeginByte; i1 < EndByte;
  2581. ++i1) // Den Körper des Zeichens Kopieren
  2582. {
  2583. inF->read(&byte, 1);
  2584. outF->write(&byte, 1);
  2585. }
  2586. }
  2587. for (int i = 0; i < sgNum; ++i) // Dateikopf aktualisieren
  2588. sgPosList[i] -= 5;
  2589. for (int i = sgNum + 1; i < sgAnzahl; ++i)
  2590. sgPosList[i] -= indexMinus;
  2591. dateiKopf->removeSG(gr);
  2592. outF->seekp(0, std::ios::beg);
  2593. dateiKopf->speichern(outF); // Dateikopf speichern
  2594. inF->close();
  2595. outF->close();
  2596. Text* pfad2 = new Text(pfad->getText());
  2597. pfad->remove(pfad->getLength() - 1, pfad->getLength());
  2598. DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // alte Datei löschen
  2599. DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
  2600. dynamic_cast<Text*>(pfad->getThis())); // neue Datei zu alter umbenennen
  2601. pfad2->release();
  2602. delete inF;
  2603. delete outF;
  2604. }
  2605. void LTDSDatei::löscheBuchstabe(
  2606. int gr, unsigned char zeichen) // Löscht einen Buchstaben aus der Datei
  2607. {
  2608. if (!DateiExistiert(dynamic_cast<Text*>(
  2609. pfad->getThis()))) // prüfen, ob die Datei existiert
  2610. return;
  2611. if (!dateiKopf) // prüfen, ob der Dateikopf gelesen wurde
  2612. leseDaten();
  2613. unsigned char* sgList
  2614. = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen
  2615. unsigned char sgAnzahl
  2616. = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der Schriftgrößen
  2617. int* sgPosList
  2618. = dateiKopf
  2619. ->getPositionList(); // Liste mit Positionen der Schriftgrößen
  2620. int sgNum = -1;
  2621. for (int i = 0; i < sgAnzahl; ++i) // Schriftgröße suchen
  2622. {
  2623. if (sgList[i] == gr)
  2624. {
  2625. sgNum = i;
  2626. break;
  2627. }
  2628. }
  2629. if (sgNum == -1) // Schriftgröße nicht gefunden
  2630. return;
  2631. std::ifstream* inF
  2632. = new std::ifstream(pfad->getText(), std::ios::binary); // alte Datei
  2633. pfad->append("0");
  2634. std::ofstream* outF
  2635. = new std::ofstream(pfad->getText(), std::ios::binary); // neue Datei
  2636. int indexMinus = 0;
  2637. inF->seekg(1 + 5 * sgAnzahl, std::ios::beg);
  2638. dateiKopf->speichern(outF); // DateiKopf peichern
  2639. for (int i = 0; i < sgAnzahl; ++i)
  2640. {
  2641. LTDSSchriftKopf* sgKopf = new LTDSSchriftKopf(); // Schriftkopf
  2642. sgKopf->laden(inF); // Schriftkopf laden
  2643. unsigned char sgZeichAnzahl
  2644. = sgKopf->getZeichenAnzahl(); // Zeichenanzahl
  2645. unsigned char* sgZeichenList = sgKopf->getZeichen(); // Zeichen Liste
  2646. int* sgZPosList = sgKopf->getPositionen(); // Positions Liste
  2647. if (i == sgNum) // Zeichen befindet sich in dieser Schriftgröße
  2648. {
  2649. int sgZNum = -1;
  2650. for (int i1 = 0; i1 < sgZeichAnzahl; ++i1) // Zeichen suchen
  2651. {
  2652. if (sgZeichenList[i1] == zeichen)
  2653. {
  2654. sgZNum = i1;
  2655. break;
  2656. }
  2657. }
  2658. if (sgZNum == -1) // Zeichen nicht gefunden
  2659. {
  2660. sgKopf->release();
  2661. inF->close();
  2662. outF->close();
  2663. delete inF;
  2664. delete outF;
  2665. DateiRemove(dynamic_cast<Text*>(pfad->getThis()));
  2666. pfad->remove(pfad->getLength() - 1, pfad->getLength());
  2667. return; // abbruch
  2668. }
  2669. outF->seekp(2 + 5 * (sgZeichAnzahl - 1), std::ios::cur);
  2670. indexMinus += 5;
  2671. for (int i1 = 0; i1 < sgZNum;
  2672. ++i1) // Zeichen vor dem zu löschenden Zeichen
  2673. {
  2674. char byte = 0;
  2675. for (int i2 = sgZPosList[i1]; i2 < sgZPosList[i1 + 1];
  2676. ++i2) // Kopieren
  2677. {
  2678. inF->read(&byte, 1);
  2679. outF->write(&byte, 1);
  2680. }
  2681. sgZPosList[i1] -= indexMinus; // Schriftgröße Kopf aktualisieren
  2682. }
  2683. if (!sgZPosList[sgZNum + 1])
  2684. {
  2685. int endByte = sgPosList[i + 1];
  2686. if (!endByte)
  2687. {
  2688. int beginByte = (int)inF->tellg();
  2689. inF->seekg(0, std::ios::end);
  2690. endByte = (int)inF->tellg();
  2691. inF->seekg(beginByte, std::ios::beg);
  2692. }
  2693. indexMinus += endByte - sgZPosList[sgZNum];
  2694. }
  2695. else
  2696. indexMinus += sgZPosList[sgZNum + 1] - sgZPosList[sgZNum];
  2697. if (sgZNum + 1 < sgZeichAnzahl)
  2698. inF->seekg(sgZPosList[sgZNum + 1], std::ios::beg);
  2699. for (int i1 = sgZNum + 1; i1 < sgZeichAnzahl;
  2700. ++i1) // Zeichen nach dem gelöschten Zeichen
  2701. {
  2702. int beginByte = (int)inF->tellg();
  2703. int endByte = sgZPosList[i1 + 1];
  2704. if (!endByte)
  2705. {
  2706. inF->seekg(0, std::ios::end);
  2707. endByte = (int)inF->tellg();
  2708. inF->seekg(beginByte, std::ios::beg);
  2709. }
  2710. char byte = 0;
  2711. for (int i2 = beginByte; i2 < endByte; ++i2) // Kopieren
  2712. {
  2713. inF->read(&byte, 1);
  2714. outF->write(&byte, 1);
  2715. }
  2716. sgZPosList[i1] -= indexMinus; // Schriftgröße Kopf aktualisieren
  2717. }
  2718. sgKopf->removeZeichen(zeichen);
  2719. }
  2720. else
  2721. {
  2722. for (int i1 = 0; i1 < sgZeichAnzahl;
  2723. ++i1) // Schriftgröße Kopf aktualisieren
  2724. sgZPosList[i] -= indexMinus;
  2725. sgKopf->speichern(outF); // Schriftgröße Kopf speichern
  2726. int beginByte = (int)inF->tellg();
  2727. int endByte = sgPosList[i + 1];
  2728. if (!endByte)
  2729. {
  2730. inF->seekg(0, std::ios::end);
  2731. endByte = (int)inF->tellg();
  2732. inF->seekg(beginByte, std::ios::beg);
  2733. }
  2734. char byte;
  2735. for (int i1 = beginByte; i1 < endByte; ++i1) // Kopieren
  2736. {
  2737. inF->read(&byte, 1);
  2738. outF->write(&byte, 1);
  2739. }
  2740. sgPosList[i] -= indexMinus;
  2741. }
  2742. outF->seekp(sgPosList[i], std::ios::beg);
  2743. sgKopf->speichern(outF); // Schriftgröße Kopf speichern
  2744. outF->seekp(sgPosList[i + 1], std::ios::beg);
  2745. sgKopf->release();
  2746. }
  2747. inF->close();
  2748. outF->close();
  2749. Text* pfad2 = new Text(pfad->getText());
  2750. pfad->remove(pfad->getLength() - 1, pfad->getLength());
  2751. DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // alte Datei löschen
  2752. DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
  2753. dynamic_cast<Text*>(
  2754. pfad->getThis())); // neue Datei nach alte umbenennen
  2755. pfad2->release(); // Speicher freigeben
  2756. delete inF;
  2757. delete outF;
  2758. }
  2759. void LTDSDatei::löscheDatei() // Löscht die gesamte Datei
  2760. {
  2761. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return;
  2762. if (!dateiKopf) leseDaten();
  2763. DateiRemove(dynamic_cast<Text*>(pfad->getThis()));
  2764. }
  2765. void LTDSDatei::erstelleDatei() // erstellt die Datei
  2766. {
  2767. DateiPfadErstellen(dynamic_cast<Text*>(pfad->getThis()));
  2768. if (dateiKopf) dateiKopf->release();
  2769. dateiKopf = new LTDSDateiKopf();
  2770. std::ofstream* outF = new std::ofstream(pfad->getText(), std::ios::binary);
  2771. dateiKopf->speichern(outF);
  2772. outF->close();
  2773. delete outF;
  2774. }
  2775. void LTDSDatei::speicherSchrift(
  2776. Schrift* schrift) // Speichert die übergebene Schrift
  2777. {
  2778. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
  2779. {
  2780. schrift->release();
  2781. return;
  2782. }
  2783. löscheDatei();
  2784. if (dateiKopf) dateiKopf->release();
  2785. dateiKopf = new LTDSDateiKopf();
  2786. for (int i = 0; i < schrift->getAlphabetAnzahl(); ++i)
  2787. {
  2788. Alphabet* alp = schrift->getAlphabetI(i);
  2789. if (alp)
  2790. {
  2791. dateiKopf->addSG(alp->getSchriftSize());
  2792. alp->release();
  2793. }
  2794. }
  2795. std::ofstream* outF = new std::ofstream(pfad->getText(), std::ios::binary);
  2796. dateiKopf->speichern(outF);
  2797. for (int i = 0; i < schrift->getAlphabetAnzahl(); ++i)
  2798. {
  2799. dateiKopf->getPositionList()[i] = (int)outF->tellp();
  2800. LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf();
  2801. sgKpf->setZeichenAlphabet(schrift->getAlphabetI(i));
  2802. sgKpf->speichern(outF);
  2803. Alphabet* alp = schrift->getAlphabetI(i);
  2804. for (int i1 = 0; i1 < sgKpf->getZeichenAnzahl(); ++i1)
  2805. {
  2806. sgKpf->getPositionen()[i1] = (int)outF->tellp();
  2807. LTDSBuchstabenKopf* zeichKpf = new LTDSBuchstabenKopf();
  2808. Buchstabe* zeichen = alp->getBuchstabe(sgKpf->getZeichen()[i1]);
  2809. zeichKpf->init(sgKpf->getZeichen()[i1],
  2810. zeichen->getBreite(),
  2811. zeichen->getHeight());
  2812. zeichKpf->speichern(outF);
  2813. LTDSBuchstabenKörper* zeichKörp = new LTDSBuchstabenKörper(
  2814. dynamic_cast<LTDSBuchstabenKopf*>(zeichKpf->getThis()));
  2815. zeichKörp->setBuchstabe(
  2816. dynamic_cast<Buchstabe*>(zeichen->getThis()));
  2817. zeichKörp->speichern(outF);
  2818. zeichKörp->release();
  2819. zeichen->release();
  2820. zeichKpf->release();
  2821. }
  2822. alp->release();
  2823. int p = (int)outF->tellp();
  2824. outF->seekp(dateiKopf->getPositionList()[i], std::ios::beg);
  2825. sgKpf->speichern(outF);
  2826. outF->seekp(p, std::ios::beg);
  2827. sgKpf->release();
  2828. }
  2829. outF->seekp(0, std::ios::beg);
  2830. dateiKopf->speichern(outF);
  2831. outF->close();
  2832. delete outF;
  2833. schrift->release();
  2834. }
  2835. // constant
  2836. Schrift* LTDSDatei::ladeSchrift() // gibt die geladene Schrift zurück
  2837. {
  2838. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  2839. if (!dateiKopf) return 0;
  2840. Schrift* ret = new Schrift();
  2841. std::ifstream* inF = new std::ifstream(pfad->getText(), std::ios::binary);
  2842. inF->seekg(dateiKopf->getPositionList()[0], std::ios::beg);
  2843. for (int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i)
  2844. {
  2845. LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf();
  2846. sgKpf->laden(inF);
  2847. Alphabet* alphabet = new Alphabet();
  2848. alphabet->setSchriftSize(sgKpf->getSchriftGröße());
  2849. for (int i1 = 0; i1 < sgKpf->getZeichenAnzahl(); ++i1)
  2850. {
  2851. LTDSBuchstabenKopf* zeichKpf = new LTDSBuchstabenKopf();
  2852. zeichKpf->laden(inF);
  2853. LTDSBuchstabenKörper* zeichKörp = new LTDSBuchstabenKörper(
  2854. dynamic_cast<LTDSBuchstabenKopf*>(zeichKpf->getThis()));
  2855. zeichKörp->laden(inF);
  2856. alphabet->setBuchstabe(
  2857. zeichKpf->getZeichen(), zeichKörp->getBuchstabe());
  2858. zeichKörp->release();
  2859. zeichKpf->release();
  2860. }
  2861. ret->addAlphabet(dynamic_cast<Alphabet*>(alphabet->getThis()));
  2862. alphabet->release();
  2863. sgKpf->release();
  2864. }
  2865. inF->close();
  2866. delete inF;
  2867. return ret;
  2868. }
  2869. Alphabet* LTDSDatei::ladeAlphabet(
  2870. int schriftgröße) // gibt eine geladene Schrift nur mit der angegebenen
  2871. // Schriftgröße zurück
  2872. {
  2873. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  2874. if (!dateiKopf) return 0;
  2875. Alphabet* ret = 0;
  2876. int sgNum = -1;
  2877. for (int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i)
  2878. {
  2879. if (dateiKopf->getSchriftGrößeList()[i] == schriftgröße)
  2880. {
  2881. sgNum = i;
  2882. break;
  2883. }
  2884. }
  2885. if (sgNum == -1) return 0;
  2886. ret = new Alphabet();
  2887. ret->NeuAlphabet();
  2888. ret->setSchriftSize(schriftgröße);
  2889. std::ifstream* inF = new std::ifstream(pfad->getText(), std::ios::binary);
  2890. inF->seekg(dateiKopf->getPositionList()[sgNum], std::ios::beg);
  2891. LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf();
  2892. sgKpf->laden(inF);
  2893. for (int i = 0; i < sgKpf->getZeichenAnzahl(); ++i)
  2894. {
  2895. LTDSBuchstabenKopf* sgZKpf = new LTDSBuchstabenKopf();
  2896. sgZKpf->laden(inF);
  2897. LTDSBuchstabenKörper* sgZKörp = new LTDSBuchstabenKörper(
  2898. dynamic_cast<LTDSBuchstabenKopf*>(sgZKpf->getThis()));
  2899. sgZKörp->laden(inF);
  2900. ret->setBuchstabe(sgZKpf->getZeichen(), sgZKörp->getBuchstabe());
  2901. sgZKörp->release();
  2902. sgZKpf->release();
  2903. }
  2904. sgKpf->release();
  2905. inF->close();
  2906. delete inF;
  2907. return ret;
  2908. }
  2909. Buchstabe* LTDSDatei::ladeBuchstabe(
  2910. int schriftgröße, unsigned char zeichen) // Läd einen bestimmten Buchstaben
  2911. {
  2912. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  2913. if (!dateiKopf) return 0;
  2914. Buchstabe* ret = 0;
  2915. int sgNum = -1;
  2916. for (int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i)
  2917. {
  2918. if (dateiKopf->getSchriftGrößeList()[i] == schriftgröße)
  2919. {
  2920. sgNum = i;
  2921. break;
  2922. }
  2923. }
  2924. if (sgNum == -1) return 0;
  2925. std::ifstream* inF = new std::ifstream(pfad->getText(), std::ios::binary);
  2926. inF->seekg(dateiKopf->getPositionList()[sgNum], std::ios::beg);
  2927. LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf();
  2928. sgKpf->laden(inF);
  2929. int sgZNum = -1;
  2930. for (int i = 0; i < sgKpf->getZeichenAnzahl(); ++i)
  2931. {
  2932. if (sgKpf->getZeichen()[i] == zeichen)
  2933. {
  2934. sgZNum = i;
  2935. break;
  2936. }
  2937. }
  2938. if (sgZNum != -1)
  2939. {
  2940. inF->seekg(sgKpf->getPositionen()[sgZNum], std::ios::beg);
  2941. LTDSBuchstabenKopf* sgZKpf = new LTDSBuchstabenKopf();
  2942. sgZKpf->laden(inF);
  2943. LTDSBuchstabenKörper* sgZKörp = new LTDSBuchstabenKörper(
  2944. dynamic_cast<LTDSBuchstabenKopf*>(sgZKpf->getThis()));
  2945. sgZKörp->laden(inF);
  2946. ret = sgZKörp->getBuchstabe();
  2947. sgZKörp->release();
  2948. sgZKpf->release();
  2949. }
  2950. sgKpf->release();
  2951. inF->close();
  2952. delete inF;
  2953. if (ret)
  2954. {
  2955. ret->setSchriftSize(schriftgröße);
  2956. }
  2957. return ret;
  2958. }
  2959. Text* LTDSDatei::getPfad() const // gibt den Dateipfad zurück
  2960. {
  2961. return dynamic_cast<Text*>(pfad->getThis());
  2962. }
  2963. int LTDSDatei::getAnzahlSchriftgrößen()
  2964. const // gibt die Anzahl der Schriftgrößen aus der Datei zurück
  2965. {
  2966. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  2967. if (!dateiKopf) return 0;
  2968. return dateiKopf->getSchriftGrößeAnzahl();
  2969. }
  2970. unsigned char* LTDSDatei::getSchriftGrößen()
  2971. const // gibt einen Array von Schriftgrößen zurück
  2972. {
  2973. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  2974. if (!dateiKopf) return 0;
  2975. return dateiKopf->getSchriftGrößeList();
  2976. }
  2977. unsigned char LTDSDatei::getAnzahlBuchstaben(
  2978. int sg) // gibt die anzahl gespeicherter Buchstaben einer Schriftgröße
  2979. // zurück
  2980. {
  2981. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  2982. if (!dateiKopf) return 0;
  2983. int ret = 0;
  2984. unsigned char* größen = dateiKopf->getSchriftGrößeList();
  2985. unsigned char granzahl = dateiKopf->getSchriftGrößeAnzahl();
  2986. int grpos = -1;
  2987. for (int i = 0; i < granzahl; ++i)
  2988. {
  2989. if (größen[i] == sg)
  2990. {
  2991. grpos = i;
  2992. break;
  2993. }
  2994. }
  2995. if (grpos != -1)
  2996. {
  2997. int* grposlist = dateiKopf->getPositionList();
  2998. LTDSSchriftKopf* sgkpf = new LTDSSchriftKopf();
  2999. std::ifstream* inF
  3000. = new std::ifstream(pfad->getText(), std::ios::binary);
  3001. inF->seekg(grposlist[grpos], std::ios::beg);
  3002. sgkpf->laden(inF);
  3003. ret = sgkpf->getZeichenAnzahl();
  3004. sgkpf->release();
  3005. inF->close();
  3006. delete inF;
  3007. }
  3008. return ret;
  3009. }
  3010. unsigned char* LTDSDatei::getBuchstaben(
  3011. int sg) // gibt einen Array von Buchstaben einer Schriftgröße zurück
  3012. {
  3013. if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
  3014. if (!dateiKopf) return 0;
  3015. unsigned char* ret = 0;
  3016. unsigned char* größen = dateiKopf->getSchriftGrößeList();
  3017. unsigned char granzahl = dateiKopf->getSchriftGrößeAnzahl();
  3018. int grpos = -1;
  3019. for (int i = 0; i < granzahl; ++i)
  3020. {
  3021. if (größen[i] == sg)
  3022. {
  3023. grpos = i;
  3024. break;
  3025. }
  3026. }
  3027. if (grpos != -1)
  3028. {
  3029. int* grposlist = dateiKopf->getPositionList();
  3030. LTDSSchriftKopf* sgkpf = new LTDSSchriftKopf();
  3031. std::ifstream* inF
  3032. = new std::ifstream(pfad->getText(), std::ios::binary);
  3033. inF->seekg(grposlist[grpos], std::ios::beg);
  3034. sgkpf->laden(inF);
  3035. int anz = sgkpf->getZeichenAnzahl();
  3036. ret = new unsigned char[anz];
  3037. for (int i = 0; i < anz; ++i)
  3038. ret[i] = sgkpf->getZeichen()[i];
  3039. sgkpf->release();
  3040. inF->close();
  3041. delete inF;
  3042. }
  3043. return ret;
  3044. }
  3045. #endif
  3046. // Bit Funktionen
  3047. int Framework::Bits(int a) // gibt 1-bits in gewinschter anzahl zurück
  3048. {
  3049. int ret = 0;
  3050. for (int i = 0; i < a; ++i)
  3051. {
  3052. ret <<= 1;
  3053. ++ret;
  3054. }
  3055. return ret;
  3056. }
  3057. int Framework::getBits(char c) // gibt zurück, wie viele Bits c benötigt
  3058. {
  3059. int ret = 0;
  3060. for (int i = 0; (c & (char)Bits(i)) != c; ++i)
  3061. ++ret;
  3062. return ret;
  3063. }