diff --git a/README.md b/README.md index 9835cf2..20b575f 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ Nothing is planned for it at this time. ## 12.0 -Released: January 2025 +Released: Planned for some time between January and May 2025 minigui's `defaultEventHandler_*` functions take more specific objects. So if you see errors like: diff --git a/core.d b/core.d index 6a8b2bf..9d443b2 100644 --- a/core.d +++ b/core.d @@ -422,6 +422,46 @@ struct stringz { } } +/+ +/++ + A runtime tagged union, aka a sumtype. + + History: + Added February 15, 2025 ++/ +struct Union(T...) { + private uint contains_; + private union { + private T payload; + } + + static foreach(index, type; T) + @implicit public this(type t) { + contains_ = index; + payload[index] = t; + } + + bool contains(Part)() const { + static assert(indexFor!Part != -1); + return contains_ == indexFor!Part; + } + + inout(Part) get(Part)() inout { + if(!contains!Part) { + throw new ArsdException!"Dynamic type mismatch"(indexFor!Part, contains_); + } + return payload[indexFor!Part]; + } + + private int indexFor(Part)() { + foreach(idx, thing; T) + static if(is(T == Part)) + return idx; + return -1; + } +} ++/ + /+ DateTime year: 16 bits (-32k to +32k) diff --git a/database.d b/database.d index 7d21c75..0d2d16f 100644 --- a/database.d +++ b/database.d @@ -217,6 +217,7 @@ struct DatabaseDatum { alias toString this; /// ditto + version(D_OpenD) {} else // opend enables -preview=rvaluerefparam which makes this conflict with the rvalue toString in matching to!T stuff T opCast(T)() { import std.conv; return to!T(this.toString); diff --git a/docx.d b/docx.d new file mode 100644 index 0000000..d0480a7 --- /dev/null +++ b/docx.d @@ -0,0 +1,66 @@ +/++ + Bare minimum support for reading Microsoft Word files. + + History: + Added February 19, 2025 ++/ +module arsd.docx; + +import arsd.core; +import arsd.zip; +import arsd.dom; +import arsd.color; + +/++ + ++/ +class DocxFile { + private ZipFile zipFile; + private XmlDocument document; + + /++ + + +/ + this(FilePath file) { + this.zipFile = new ZipFile(file); + + load(); + } + + /// ditto + this(immutable(ubyte)[] rawData) { + this.zipFile = new ZipFile(rawData); + + load(); + } + + /++ + Converts the document to a plain text string that gives you + the jist of the document that you can view in a plain editor. + + Most formatting is stripped out. + +/ + string toPlainText() { + string ret; + foreach(paragraph; document.querySelectorAll("w\\:p")) { + if(ret.length) + ret ~= "\n\n"; + ret ~= paragraph.innerText; + } + return ret; + } + + // FIXME: to RTF, markdown, html, and terminal sequences might also be useful. + + private void load() { + loadXml("word/document.xml", (document) { + this.document = document; + }); + } + + private void loadXml(string filename, scope void delegate(XmlDocument document) handler) { + auto document = new XmlDocument(cast(string) zipFile.getContent(filename)); + handler(document); + } + +} diff --git a/ini.d b/ini.d index f4d83af..4d7c689 100644 --- a/ini.d +++ b/ini.d @@ -169,7 +169,7 @@ module arsd.ini; } /++ - Determines whether a type `T` is a string type compatible with this library. + Determines whether a type `T` is a string type compatible with this library. +/ enum isCompatibleString(T) = (is(T == immutable(char)[]) || is(T == const(char)[]) || is(T == char[])); diff --git a/minigui.d b/minigui.d index 366596f..30d68c8 100644 --- a/minigui.d +++ b/minigui.d @@ -13718,6 +13718,7 @@ class TextDisplayHelper : Widget { override void defaultEventHandler_dblclick(scope DoubleClickEvent dce) { if(dce.button == MouseButton.left) { with(l.selection()) { + // FIXME: for a url or file picker i might wanna use / as a separator intead scope dg = delegate const(char)[] (scope return const(char)[] ch) { if(ch == " " || ch == "\t" || ch == "\n" || ch == "\r") return ch; @@ -13912,7 +13913,8 @@ class TextDisplayHelper : Widget { return super.maxHeight(); } - void drawTextSegment(WidgetPainter painter, Point upperLeft, scope const(char)[] text) { + void drawTextSegment(MyTextStyle myStyle, WidgetPainter painter, Point upperLeft, scope const(char)[] text) { + painter.setFont(myStyle.font); painter.drawText(upperLeft, text); } @@ -13929,12 +13931,6 @@ class TextDisplayHelper : Widget { //writeln("Segment: ", txt); assert(style !is null); - auto myStyle = cast(MyTextStyle) style; - assert(myStyle !is null); - - painter.setFont(myStyle.font); - // defaultColor = myStyle.color; // FIXME: so wrong - if(info.selections && info.boundingBox.width > 0) { auto color = this.isFocused ? cs.selectionBackgroundColor : Color(128, 128, 128); // FIXME don't hardcode painter.fillColor = color; @@ -13957,7 +13953,11 @@ class TextDisplayHelper : Widget { } if(txt.stripInternal.length) { - drawTextSegment(painter, info.boundingBox.upperLeft - smw.position() + bounds.upperLeft, txt.stripRightInternal); + // defaultColor = myStyle.color; // FIXME: so wrong + if(auto myStyle = cast(MyTextStyle) style) + drawTextSegment(myStyle, painter, info.boundingBox.upperLeft - smw.position() + bounds.upperLeft, txt.stripRightInternal); + else if(auto myStyle = cast(MyImageStyle) style) + myStyle.draw(painter, info.boundingBox.upperLeft - smw.position() + bounds.upperLeft, txt.stripRightInternal); } if(info.boundingBox.upperLeft.y - smw.position().y > this.height) { @@ -13991,6 +13991,33 @@ class TextDisplayHelper : Widget { return font_; } } + + static class MyImageStyle : TextStyle, MeasurableFont { + MemoryImage image_; + Image converted; + this(MemoryImage image) { + this.image_ = image; + this.converted = Image.fromMemoryImage(image); + } + + bool isMonospace() { return false; } + int averageWidth() { return image_.width; } + int height() { return image_.height; } + int ascent() { return image_.height; } + int descent() { return 0; } + + int stringWidth(scope const(char)[] s, SimpleWindow window = null) { + return image_.width; + } + + override MeasurableFont font() { + return this; + } + + void draw(WidgetPainter painter, Point upperLeft, scope const(char)[] text) { + painter.drawImage(upperLeft, converted); + } + } } /+ @@ -14059,6 +14086,8 @@ abstract class EditableTextWidget : Widget { void wordWrapEnabled(bool enabled) { if(useCustomWidget) { wordWrapEnabled_ = enabled; + if(tdh) + tdh.wordWrapEnabled_ = true; textLayout.wordWrapWidth = enabled ? this.width : 0; // FIXME } else version(win32_widgets) { SendMessageW(hwnd, EM_FMTLINES, enabled ? 1 : 0, 0); @@ -14431,11 +14460,12 @@ class PasswordEdit : EditableTextWidget { super(textLayout, smw); } - override void drawTextSegment(WidgetPainter painter, Point upperLeft, scope const(char)[] text) { + override void drawTextSegment(MyTextStyle myStyle, WidgetPainter painter, Point upperLeft, scope const(char)[] text) { char[256] buffer = void; int bufferLength = 0; foreach(dchar ch; text) buffer[bufferLength++] = '*'; + painter.setFont(myStyle.font); painter.drawText(upperLeft, buffer[0..bufferLength]); } } diff --git a/pptx.d b/pptx.d new file mode 100644 index 0000000..0c4c595 --- /dev/null +++ b/pptx.d @@ -0,0 +1,93 @@ +/++ + Bare minimum support for reading Microsoft PowerPoint files. + + History: + Added February 19, 2025 ++/ +module arsd.pptx; + +// see ~/zip/ppt + +import arsd.core; +import arsd.zip; +import arsd.dom; +import arsd.color; + +/++ + ++/ +class PptxFile { + private ZipFile zipFile; + private XmlDocument document; + + /++ + + +/ + this(FilePath file) { + this.zipFile = new ZipFile(file); + + load(); + } + + /// ditto + this(immutable(ubyte)[] rawData) { + this.zipFile = new ZipFile(rawData); + + load(); + } + + /// public for now but idk forever. + PptxSlide[] slides; + + private string[string] contentTypes; + private struct Relationship { + string id; + string type; + string target; + } + private Relationship[string] relationships; + + private void load() { + loadXml("[Content_Types].xml", (document) { + foreach(element; document.querySelectorAll("Override")) + contentTypes[element.attrs.PartName] = element.attrs.ContentType; + }); + loadXml("ppt/_rels/presentation.xml.rels", (document) { + foreach(element; document.querySelectorAll("Relationship")) + relationships[element.attrs.Id] = Relationship(element.attrs.Id, element.attrs.Type, element.attrs.Target); + }); + + loadXml("ppt/presentation.xml", (document) { + this.document = document; + + foreach(element; document.querySelectorAll("p\\:sldIdLst p\\:sldId")) + loadXml("ppt/" ~ relationships[element.getAttribute("r:id")].target, (document) { + slides ~= new PptxSlide(this, document); + }); + }); + + // then there's slide masters and layouts and idk what that is yet + } + + private void loadXml(string filename, scope void delegate(XmlDocument document) handler) { + auto document = new XmlDocument(cast(string) zipFile.getContent(filename)); + handler(document); + } + +} + +class PptxSlide { + private PptxFile file; + private XmlDocument document; + private this(PptxFile file, XmlDocument document) { + this.file = file; + this.document = document; + } + + /++ + +/ + string toPlainText() { + // FIXME: need to handle at least some of the layout + return document.root.innerText; + } +} diff --git a/rtf.d b/rtf.d new file mode 100644 index 0000000..5016e67 --- /dev/null +++ b/rtf.d @@ -0,0 +1,390 @@ +/++ + Some support for the RTF file format - rich text format, like produced by Windows WordPad. + + History: + Added February 13, 2025 ++/ +module arsd.rtf; + +// https://www.biblioscape.com/rtf15_spec.htm +// https://latex2rtf.sourceforge.net/rtfspec_62.html +// https://en.wikipedia.org/wiki/Rich_Text_Format + +// spacing is in "twips" or 1/20 of a point (as in text size unit). aka 1/1440th of an inch. + +import arsd.core; +import arsd.color; + +/++ + ++/ +struct RtfDocument { + RtfGroup root; + + /++ + There are two helper functions to process a RTF file: one that does minimal processing + and sends you the data as it appears in the file, and one that sends you preprocessed + results upon significant state changes. + + The former makes you do more work, but also exposes (almost) the whole file to you (it is still partially processed). The latter lets you just get down to business processing the text, but is not a complete implementation. + +/ + void process(void delegate(RtfPiece piece, ref RtfState state) dg) { + recurseIntoGroup(root, RtfState.init, dg); + } + + private static void recurseIntoGroup(RtfGroup group, RtfState parentState, void delegate(RtfPiece piece, ref RtfState state) dg) { + // might need to copy... + RtfState state = parentState; + auto newDestination = group.destination; + if(newDestination.length) + state.currentDestination = newDestination; + + foreach(piece; group.pieces) { + if(piece.contains == RtfPiece.Contains.group) { + recurseIntoGroup(piece.group, state, dg); + } else { + dg(piece, state); + } + } + + } + + //Color[] colorTable; + //Object[] fontTable; +} + +/// ditto +RtfDocument readRtfFromString(const(char)[] s) { + return readRtfFromBytes(cast(const(ubyte)[]) s); +} + +/// ditto +RtfDocument readRtfFromBytes(const(ubyte)[] s) { + RtfDocument document; + + if(s.length < 7) + throw new ArsdException!"not a RTF file"("too short"); + if((cast(char[]) s[0..6]) != `{\rtf1`) + throw new ArsdException!"not a RTF file"("wrong magic number"); + + document.root = parseRtfGroup(s); + + return document; +} + +/// ditto +struct RtfState { + string currentDestination; +} + +unittest { + auto document = readRtfFromString("{\\rtf1Hello\nWorld}"); + //import std.file; auto document = readRtfFromString(readText("/home/me/test.rtf")); + document.process((piece, ref state) { + final switch(piece.contains) { + case RtfPiece.Contains.controlWord: + // writeln(state.currentDestination, ": ", piece.controlWord); + break; + case RtfPiece.Contains.text: + // writeln(state.currentDestination, ": ", piece.text); + break; + case RtfPiece.Contains.group: + assert(0); + } + }); + + // writeln(toPlainText(document)); +} + +string toPlainText(RtfDocument document) { + string ret; + document.process((piece, ref state) { + if(state.currentDestination.length) + return; + + final switch(piece.contains) { + case RtfPiece.Contains.controlWord: + if(piece.controlWord.letterSequence == "par") + ret ~= "\n\n"; + else if(piece.controlWord.toDchar != dchar.init) + ret ~= piece.controlWord.toDchar; + break; + case RtfPiece.Contains.text: + ret ~= piece.text; + break; + case RtfPiece.Contains.group: + assert(0); + } + }); + + return ret; +} + +private RtfGroup parseRtfGroup(ref const(ubyte)[] s) { + RtfGroup group; + + assert(s[0] == '{'); + s = s[1 .. $]; + if(s.length == 0) + throw new ArsdException!"bad RTF file"("premature end after {"); + while(s[0] != '}') { + group.pieces ~= parseRtfPiece(s); + if(s.length == 0) + throw new ArsdException!"bad RTF file"("premature end before {"); + } + s = s[1 .. $]; + return group; +} + +private RtfPiece parseRtfPiece(ref const(ubyte)[] s) { + while(true) + switch(s[0]) { + case '\\': + return RtfPiece(parseRtfControlWord(s)); + case '{': + return RtfPiece(parseRtfGroup(s)); + case '\t': + s = s[1 .. $]; + return RtfPiece(RtfControlWord.tab); + case '\r': + case '\n': + // skip irrelevant characters + s = s[1 .. $]; + continue; + default: + return RtfPiece(parseRtfText(s)); + } +} + +private RtfControlWord parseRtfControlWord(ref const(ubyte)[] s) { + assert(s[0] == '\\'); + s = s[1 .. $]; + + if(s.length == 0) + throw new ArsdException!"bad RTF file"("premature end after \\"); + + RtfControlWord ret; + + size_t pos; + do { + pos++; + } while(pos < s.length && isAlpha(cast(char) s[pos])); + + ret.letterSequence = (cast(const char[]) s)[0 .. pos].idup; + s = s[pos .. $]; + + if(isAlpha(ret.letterSequence[0])) { + if(s.length == 0) + throw new ArsdException!"bad RTF file"("premature end after control word"); + + int readNumber() { + if(s.length == 0) + throw new ArsdException!"bad RTF file"("premature end when reading number"); + int count; + while(s[count] >= '0' && s[count] <= '9') + count++; + if(count == 0) + throw new ArsdException!"bad RTF file"("expected negative number, got something else"); + + auto buffer = cast(const(char)[]) s[0 .. count]; + s = s[count .. $]; + + int accumulator; + foreach(ch; buffer) { + accumulator *= 10; + accumulator += ch - '0'; + } + + return accumulator; + } + + if(s[0] == '-') { + ret.hadNumber = true; + s = s[1 .. $]; + ret.number = - readNumber(); + + // negative number + } else if(s[0] >= '0' && s[0] <= '9') { + // non-negative number + ret.hadNumber = true; + ret.number = readNumber(); + } + + if(s[0] == ' ') { + ret.hadSpaceAtEnd = true; + s = s[1 .. $]; + } + + } else { + // it was a control symbol + if(ret.letterSequence == "\r" || ret.letterSequence == "\n") + ret.letterSequence = "par"; + } + + return ret; +} + +private string parseRtfText(ref const(ubyte)[] s) { + size_t end = s.length; + foreach(idx, ch; s) { + if(ch == '\\' || ch == '{' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '}') { + end = idx; + break; + } + } + auto ret = s[0 .. end]; + s = s[end .. $]; + + // FIXME: charset conversion? + return (cast(const char[]) ret).idup; +} + +// \r and \n chars w/o a \\ before them are ignored. but \ at the end of al ine is a \par +// \t is read but you should use \tab generally +// when reading, ima translate the ascii tab to \tab control word +// and ignore +struct RtfPiece { + /++ + +/ + Contains contains() { + return contains_; + } + /// ditto + enum Contains { + controlWord, + group, + text + } + + this(RtfControlWord cw) { + this.controlWord_ = cw; + this.contains_ = Contains.controlWord; + } + this(RtfGroup g) { + this.group_ = g; + this.contains_ = Contains.group; + } + this(string s) { + this.text_ = s; + this.contains_ = Contains.text; + } + + /++ + +/ + RtfControlWord controlWord() { + if(contains != Contains.controlWord) + throw ArsdException!"RtfPiece type mismatch"(contains); + return controlWord_; + } + /++ + +/ + RtfGroup group() { + if(contains != Contains.group) + throw ArsdException!"RtfPiece type mismatch"(contains); + return group_; + } + /++ + +/ + string text() { + if(contains != Contains.text) + throw ArsdException!"RtfPiece type mismatch"(contains); + return text_; + } + + private Contains contains_; + + private union { + RtfControlWord controlWord_; + RtfGroup group_; + string text_; + } +} + +// a \word thing +struct RtfControlWord { + bool hadSpaceAtEnd; + bool hadNumber; + string letterSequence; // what the word is + int number; + + bool isDestination() { + switch(letterSequence) { + case + "author", "comment", "subject", "title", + "buptim", "creatim", "printim", "revtim", + "doccomm", + "footer", "footerf", "footerl", "footerr", + "footnote", + "ftncn", "ftnsep", "ftnsepc", + "header", "headerf", "headerl", "headerr", + "info", "keywords", "operator", + "pict", + "private", + "rxe", + "stylesheet", + "tc", + "txe", + "xe": + return true; + case "colortbl": + return true; + case "fonttbl": + return true; + + default: return false; + } + } + + dchar toDchar() { + switch(letterSequence) { + case "{": return '{'; + case "}": return '}'; + case `\`: return '\\'; + case "~": return '\ '; + case "tab": return '\t'; + case "line": return '\n'; + default: return dchar.init; + } + } + + bool isTurnOn() { + return !hadNumber || number != 0; + } + + // take no delimiters + bool isControlSymbol() { + // if true, the letterSequence is the symbol + return letterSequence.length && !isAlpha(letterSequence[0]); + } + + // letterSequence == ~ is a non breaking space + + static RtfControlWord tab() { + RtfControlWord w; + w.letterSequence = "tab"; + return w; + } +} + +private bool isAlpha(char c) { + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); +} + +// a { ... } thing +struct RtfGroup { + RtfPiece[] pieces; + + string destination() { + return isStarred() ? + ((pieces.length > 1 && pieces[1].contains == RtfPiece.Contains.controlWord) ? pieces[1].controlWord.letterSequence : null) + : ((pieces.length && pieces[0].contains == RtfPiece.Contains.controlWord && pieces[0].controlWord.isDestination) ? pieces[0].controlWord.letterSequence : null); + } + + bool isStarred() { + return (pieces.length && pieces[0].contains == RtfPiece.Contains.controlWord && pieces[0].controlWord.letterSequence == "*"); + } +} + +/+ + \pard = paragraph defaults ++/ diff --git a/textlayouter.d b/textlayouter.d index 219a1f2..211495f 100644 --- a/textlayouter.d +++ b/textlayouter.d @@ -24,8 +24,26 @@ +/ module arsd.textlayouter; -// see: https://harfbuzz.github.io/a-simple-shaping-example.html +// FIXME: elastic tabstops https://nick-gravgaard.com/elastic-tabstops/ +/+ +Each cell ends with a tab character. A column block is a run of uninterrupted vertically adjacent cells. A column block is as wide as the widest piece of text in the cells it contains or a minimum width (plus padding). Text outside column blocks is ignored. ++/ +// opening tabs work as indentation just like they do now, but wrt the algorithm are just considered one unit. +// then groups of lines with more tabs than the opening ones are processed together but only if they all right next to each other +// FIXME: soft word wrap w/ indentation preserved +// FIXME: line number stuff? + +// want to support PS (new paragraph), LS (forced line break), FF (next page) +// and GS = RS = US =
FS =
maybe. + + +// FIXME: maybe i need another overlay of block style not just text style. list, alignment, heading, paragraph spacing, etc. should it nest? + +// FIXME: copy/paste preserving style. + + +// see: https://harfbuzz.github.io/a-simple-shaping-example.html // FIXME: unicode private use area could be delegated out but it might also be used by something else. // just really want an encoding scheme for replaced elements that punt it outside.. @@ -1188,6 +1206,8 @@ class TextLayouter { int length; int styleInformationIndex; + + bool isSpecialStyle; } /+ @@ -1274,9 +1294,11 @@ class TextLayouter { /++ - Appends text at the end, without disturbing user selection. + Appends text at the end, without disturbing user selection. If style is not specified, it reuses the most recent style. If it is, it switches to that style. + + If you put `isSpecialStyle` to `true`, the style will only apply to this text specifically and user edits will not inherit it. +/ - public void appendText(scope const(char)[] text, StyleHandle style = StyleHandle.init) { + public void appendText(scope const(char)[] text, StyleHandle style = StyleHandle.init, bool isSpecialStyle = false) { wasMutated_ = true; auto before = this.text; this.text.length += text.length; @@ -1290,8 +1312,15 @@ class TextLayouter { // otherwise, insert a new block for it styles[$-1].length -= 1; // it no longer covers the zero terminator - // but this does, hence the +1 - styles ~= StyleBlock(cast(int) before.length - 1, cast(int) text.length + 1, style.index); + if(isSpecialStyle) { + auto oldIndex = styles[$-1].styleInformationIndex; + styles ~= StyleBlock(cast(int) before.length - 1, cast(int) text.length, style.index, true); + // cover the zero terminator back in the old style + styles ~= StyleBlock(cast(int) this.text.length - 1, 1, oldIndex, false); + } else { + // but this does, hence the +1 + styles ~= StyleBlock(cast(int) before.length - 1, cast(int) text.length + 1, style.index, false); + } } invalidateLayout(cast(int) before.length - 1 /* zero terminator */, this.text.length, cast(int) text.length); @@ -1817,14 +1846,21 @@ class TextLayouter { offset--; // use the previous one } - return getStyleAt(offset); + return getStyleAt(offset, false); } - private StyleHandle getStyleAt(int offset) { + private StyleHandle getStyleAt(int offset, bool allowSpecialStyle = true) { // FIXME: binary search - foreach(style; styles) { - if(offset >= style.offset && offset < (style.offset + style.length)) + foreach(idx, style; styles) { + if(offset >= style.offset && offset < (style.offset + style.length)) { + if(style.isSpecialStyle && !allowSpecialStyle) { + // we need to find the next style that is not special... + foreach(s2; styles[idx + 1 .. $]) + if(!s2.isSpecialStyle) + return StyleHandle(s2.styleInformationIndex); + } return StyleHandle(style.styleInformationIndex); + } } assert(0); } @@ -1873,11 +1909,28 @@ class TextLayouter { Can override this to define if a char is a word splitter for word wrapping. +/ protected bool isWordwrapPoint(dchar c) { + // FIXME: assume private use characters are split points if(c == ' ') return true; return false; } + /+ + /++ + + +/ + protected ReplacedCharacter privateUseCharacterInfo(dchar c) { + return ReplacedCharacter.init; + } + + /// ditto + static struct ReplacedCharacter { + bool overrideFont; /// if false, it uses the font like any other character, if true, it uses info from this struct + int width; /// in device pixels + int height; /// in device pixels + } + +/ + private bool invalidateLayout_; private int invalidStart = int.max; private int invalidEnd = 0; @@ -2024,13 +2077,19 @@ class TextLayouter { TextStyle currentStyle = null; int currentStyleIndex = 0; MeasurableFont font; + bool glyphCacheValid; ubyte[128] glyphWidths; void loadNewFont(MeasurableFont what) { font = what; // caching the ascii widths locally can give a boost to ~ 20% of the speed of this function + glyphCacheValid = true; foreach(char c; 32 .. 128) { auto w = font.stringWidth((&c)[0 .. 1]); + if(w >= 256) { + glyphCacheValid = false; + break; + } glyphWidths[c] = cast(ubyte) w; // FIXME: what if it doesn't fit? } } @@ -2273,6 +2332,9 @@ class TextLayouter { int thisWidth = 0; + // FIXME: delegate private-use area to their own segments + // FIXME: line separator, paragraph separator, form feed + switch(ch) { case 0: goto advance; @@ -2296,7 +2358,8 @@ class TextLayouter { // a tab should be its own segment with no text // per se - thisWidth = 48; + enum tabStop = 48; + thisWidth = 16 + tabStop - currentCorner.x % tabStop; segment.width += thisWidth; currentCorner.x += thisWidth; @@ -2319,7 +2382,7 @@ class TextLayouter { thisWidth = width; } } else { - if(text[idx] < 128) + if(glyphCacheValid && text[idx] < 128) thisWidth = glyphWidths[text[idx]]; else thisWidth = font.stringWidth(text[idx .. idx + stride(text[idx])]); diff --git a/xlsx.d b/xlsx.d new file mode 100644 index 0000000..0218f84 --- /dev/null +++ b/xlsx.d @@ -0,0 +1,290 @@ +/++ + Some support for the Microsoft Excel Spreadsheet file format. + + Don't expect much from it. + + Some code is borrowed from the xlsxreader package. + + History: + Added February 13, 2025 + + See_Also: + https://github.com/symmetryinvestments/xlsxd which supports writing xlsx files. I might add write support here too someday but I kinda doubt it. ++/ +module arsd.xlsx; + +// See also Robert's impl: https://github.com/symmetryinvestments/xlsxreader/blob/master/source/xlsxreader.d + +import arsd.core; +import arsd.zip; +import arsd.dom; +import arsd.color; + +import std.conv; + +/+ +struct XlsxCell { + string type; + string formula; + string value; +} ++/ + +struct CellReference { + string name; + + static CellReference fromInts(int column, int row) { + string ret; + + string piece; + do { + piece ~= cast(char)(column % 26 + 'A'); + column /= 26; + } while(column); + + foreach_reverse(ch; piece) + ret ~= ch; + piece = null; + + do { + piece ~= cast(char)(row % 10 + '0'); + row /= 10; + } while(row); + + foreach_reverse(ch; piece) + ret ~= ch; + piece = null; + + return CellReference(ret); + } + + int toColumnIndex() { + int accumulator; + foreach(ch; name) { + if(ch < 'A' || ch > 'Z') + break; + accumulator *= 26; + accumulator += ch - 'A'; + } + return accumulator; + } + + int toRowIndex() { + int accumulator; + foreach(ch; name) { + if(ch >= 'A' && ch <= 'Z') + continue; + accumulator *= 10; + accumulator += ch - '0'; + } + return accumulator; + } +} + +/++ + ++/ +class XlsxSheet { + private string name_; + private XlsxFile file; + private XmlDocument document; + private this(XlsxFile file, string name, XmlDocument document) { + this.file = file; + this.name_ = name; + this.document = document; + + this.dimension = document.requireSelector("worksheet > dimension").getAttribute("ref"); + // there's also sheetView with selection, activeCell, etc + // and cols with widths and such + + auto ul = this.upperLeft; + this.minRow = ul.toRowIndex; + this.minColumn = ul.toColumnIndex; + + auto lr = this.lowerRight; + this.maxRow = lr.toRowIndex + 1; + this.maxColumn = lr.toColumnIndex + 1; + } + + private string dimension; + + private int minRow; + private int minColumn; + private int maxRow; + private int maxColumn; + + /++ + +/ + Size size() { + return Size(maxColumn - minColumn, maxRow - minRow); + } + + private CellReference upperLeft() { + foreach(idx, ch; dimension) + if(ch == ':') + return CellReference(dimension[0 .. idx]); + assert(0); + } + + private CellReference lowerRight() { + foreach(idx, ch; dimension) + if(ch == ':') + return CellReference(dimension[idx + 1 .. $]); + assert(0); + } + + // opIndex could be like sheet["A1:B4"] and sheet["A1", "B4"] and stuff maybe. + + /++ + +/ + string name() { + return name_; + } + + /++ + Suitable for passing to [arsd.csv.toCsv] + +/ + string[][] toStringGrid() { + // FIXME: this crashes on opend dmd! + // string[][] ret = new string[][](size.height, size.width); + + string[][] ret; + ret.length = size.height; + foreach(ref row; ret) + row.length = size.width; + + //alloc done + + foreach(int rowIdx, row; ret) + foreach(int cellIdx, ref cell; row) { + string cellReference = CellReference.fromInts(cellIdx + minColumn, rowIdx + minRow).name; + // FIXME: i should prolly read left to right here at least and not iterate the whole document over and over + auto element = document.querySelector("c[r=\""~cellReference~"\"]"); + if(element is null) + continue; + string v = element.requireSelector("v").textContent; + if(element.attrs.t == "s") + v = file.sharedStrings[v.to!int()]; + cell = v; + } + return ret; + } +} + +/++ + ++/ +class XlsxFile { + private ZipFile zipFile; + + /++ + + +/ + this(FilePath file) { + this.zipFile = new ZipFile(file); + + load(); + } + + /// ditto + this(immutable(ubyte)[] rawData) { + this.zipFile = new ZipFile(rawData); + + load(); + } + + /++ + +/ + int sheetCount() { + return cast(int) sheetsInternal.length; + } + + /++ + +/ + string[] sheetNames() { + string[] ret; + foreach(sheet; sheetsInternal) + ret ~= sheet.name; + return ret; + } + + /++ + +/ + XlsxSheet getSheet(string name) { + foreach(ref sheet; sheetsInternal) + if(sheet.name == name) + return getSheetParsed(sheet); + return null; + + } + + /// ditto + XlsxSheet getSheet(int indexZeroBased) { + // FIXME: if it is out of range do what? + return getSheetParsed(sheetsInternal[indexZeroBased]); + } + + // docProps/core.xml has creator, last modified, etc. + + private string[string] contentTypes; + private struct Relationship { + string id; + string type; + string target; + } + private Relationship[string] relationships; + private string[] sharedStrings; + + private struct SheetInternal { + string name; + string id; + string rel; + + XmlDocument cached; + XlsxSheet parsed; + } + private SheetInternal[] sheetsInternal; + + private XmlDocument getSheetXml(ref SheetInternal sheet) { + if(sheet.cached is null) + loadXml("xl/" ~ relationships[sheet.rel].target, (document) { sheet.cached = document; }); + + return sheet.cached; + } + + private XlsxSheet getSheetParsed(ref SheetInternal sheet) { + if(sheet.parsed is null) + sheet.parsed = new XlsxSheet(this, sheet.name, getSheetXml(sheet)); + + return sheet.parsed; + } + + + private void load() { + loadXml("[Content_Types].xml", (document) { + foreach(element; document.querySelectorAll("Override")) + contentTypes[element.attrs.PartName] = element.attrs.ContentType; + }); + + loadXml("xl/_rels/workbook.xml.rels", (document) { + foreach(element; document.querySelectorAll("Relationship")) + relationships[element.attrs.Id] = Relationship(element.attrs.Id, element.attrs.Type, element.attrs.Target); + }); + + loadXml("xl/sharedStrings.xml", (document) { + foreach(element; document.querySelectorAll("si t")) + sharedStrings ~= element.textContent; + }); + + loadXml("xl/workbook.xml", (document) { + foreach(element; document.querySelectorAll("sheets > sheet")) { + sheetsInternal ~= SheetInternal(element.attrs.name, element.attrs.sheetId, element.getAttribute("r:id")); + } + }); + } + + private void loadXml(string filename, scope void delegate(XmlDocument document) handler) { + auto document = new XmlDocument(cast(string) zipFile.getContent(filename)); + handler(document); + } +} diff --git a/zip.d b/zip.d new file mode 100644 index 0000000..23ca3dd --- /dev/null +++ b/zip.d @@ -0,0 +1,52 @@ +/++ + DO NOT USE - ZERO STABILITY AT THIS TIME. + + Support for reading (and later, writing) .zip files. + + Currently a wrapper around phobos to change the interface for consistency + and compatibility with my other modules. + + You're better off using Phobos [std.zip] for stability at this time. + + History: + Added February 19, 2025 ++/ +module arsd.zip; + +import arsd.core; + +import std.zip; + +// https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT + +/++ + ++/ +class ZipFile { + ZipArchive phobos; + + /++ + + +/ + this(immutable(ubyte)[] fileData) { + phobos = new ZipArchive(cast(void[]) fileData); + } + + /// ditto + this(FilePath filename) { + import std.file; + this(cast(immutable(ubyte)[]) std.file.read(filename.toString())); + } + + /++ + Unstable, avoid. + +/ + immutable(ubyte)[] getContent(string filename, bool allowEmptyIfNotExist = false) { + if(filename !in phobos.directory) { + if(allowEmptyIfNotExist) + return null; + throw ArsdException!"Zip content not found"(filename); + } + return cast(immutable(ubyte)[]) phobos.expand(phobos.directory[filename]); + } +}