booktext.d

   1 /* Written by Ketmar // Invisible Vector <ketmar@ketmar.no-ip.org>
   2  * Understanding is not required. Only obedience.
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17 module booktext /*is aliced*/;
  18
  19 import std.encoding;
  20
  21 import arsd.color;
  22 import arsd.png;
  23 import arsd.jpeg;
  24
  25 import iv.encoding;
  26 import iv.iresample;
  27 import iv.nanovg;
  28 import iv.saxy;
  29 import iv.strex;
  30 import iv.utfutil;
  31 import iv.vfs;
  32
  33 import xlayouter;
  34
  35
  36 // ////////////////////////////////////////////////////////////////////////// //
  37 struct BookInfo {
  38   string author;
  39   string title;
  40   string seqname;
  41   uint seqnum;
  42   string diskfile; // not set by `loadBookInfo()`!
  43 }
  44
  45
  46 BookInfo loadBookInfo (const(char)[] fname) {
  47   static BookInfo loadFile (VFile fl) {
  48     BookInfo res;
  49     auto sax = new SaxyEx();
  50     bool complete = false;
  51     string authorFirst, authorLast;
  52
  53     inout(char)[] strip (inout(char)[] s) inout {
  54       while (s.length && s.ptr[0] <= ' ') s = s[1..$];
  55       while (s.length && s[$-1] <= ' ') s = s[0..$-1];
  56       return s;
  57     }
  58
  59     try {
  60       // sequence tag
  61       sax.onOpen("/FictionBook/description/title-info/sequence", (char[] text, char[][string] attrs) {
  62         if (auto sn = "name" in attrs) {
  63           res.seqname = strip(*sn).dup;
  64           if (auto id = "number" in attrs) {
  65             import std.conv : to;
  66             res.seqnum = to!uint(*id);
  67             if (res.seqnum < 1 || res.seqnum > 8192) res.seqname = null;
  68           }
  69         } else {
  70           res.seqname = null;
  71         }
  72         if (res.seqname.length == 0) { res.seqname = null; res.seqnum = 0; }
  73       });
  74
  75       sax.onClose("/FictionBook/description", (char[] text) {
  76         complete = true;
  77         throw new Exception("done"); // sorry
  78       });
  79
  80       // author's first name
  81       sax.onContent("/FictionBook/description/title-info/author/first-name", (char[] text) {
  82         authorFirst = strip(text).idup;
  83       });
  84       // author's last name
  85       sax.onContent("/FictionBook/description/title-info/author/last-name", (char[] text) {
  86         authorLast = strip(text).idup;
  87       });
  88       // book title
  89       sax.onContent("/FictionBook/description/title-info/book-title", (char[] text) {
  90         res.title = strip(text).idup;
  91       });
  92
  93       sax.loadStream(fl);
  94     } catch (Exception e) {
  95       if (!complete) throw e;
  96     }
  97     if (authorFirst.length == 0) {
  98       authorFirst = authorLast;
  99       authorLast = null;
 100     } else if (authorLast.length != 0) {
 101       authorFirst ~= " "~authorLast;
 102     }
 103     if (authorFirst.length == 0 && res.title.length == 0) throw new Exception("no book title found");
 104     res.author = authorFirst;
 105     return res;
 106   }
 107
 108   import std.path : extension;
 109   if (strEquCI(fname.extension, ".zip")) {
 110     vfsAddPak(fname);
 111     scope(exit) vfsRemovePack(fname);
 112     foreach (immutable idx, ref de; vfsFileList) {
 113       if (strEquCI(de.name.extension, ".fb2")) return loadFile(vfsOpenFile(de.name));
 114     }
 115     throw new Exception("no fb2 file found in '"~fname.idup~"'");
 116   } else {
 117     return loadFile(vfsOpenFile(fname));
 118   }
 119 }
 120
 121
 122 // ////////////////////////////////////////////////////////////////////////// //
 123 final class Tag {
 124   string name; // empty: text node
 125   string id;
 126   string href;
 127   string text;
 128   Tag[] children;
 129   Tag parent;
 130   //Tag prevSibling;
 131   //Tag nextSibling;
 132
 133   @property inout(Tag) firstChild () inout pure nothrow @trusted @nogc { pragma(inline, true); return (children.length ? children.ptr[0] : null); }
 134   @property inout(Tag) lastChild () inout pure nothrow @trusted @nogc { pragma(inline, true); return (children.length ? children[$-1] : null); }
 135
 136   string textContent () const {
 137     if (name.length == 0) return text;
 138     string res;
 139     foreach (const Tag t; children) res ~= t.textContent;
 140     return res;
 141   }
 142
 143   string toStringNice (int indent=0) const {
 144     string res;
 145     void addIndent () { foreach (immutable _; 0..indent) res ~= ' '; }
 146     void newLine () { res ~= '\n'; foreach (immutable _; 0..indent) res ~= ' '; }
 147     if (name.length == 0) return text;
 148     res ~= '<';
 149     if (children.length == 0) res ~= '/';
 150     res ~= name;
 151     if (id.length) { res ~= " id="; res ~= id; }
 152     if (href.length) { res ~= " href="; res ~= href; }
 153     res ~= '>';
 154     if (children.length) {
 155       if (indent >= 0) indent += 2;
 156       foreach (const Tag cc; children) {
 157         if (indent >= 0) newLine();
 158         res ~= cc.toStringNice(indent);
 159       }
 160       if (indent >= 0) indent -= 2;
 161       if (indent >= 0) newLine();
 162       res ~= "</";
 163       res ~= name;
 164       res ~= ">";
 165     }
 166     return res;
 167   }
 168
 169   override string toString () const { return toStringNice(int.min); }
 170 }
 171
 172
 173 // ////////////////////////////////////////////////////////////////////////// //
 174 final class BookText {
 175   string authorFirst;
 176   string authorLast;
 177   string title;
 178   string sequence;
 179   uint seqnum;
 180
 181   static struct Image {
 182     string id;
 183     TrueColorImage img;
 184     int nvgid = -1;
 185   }
 186
 187   Tag content; // body
 188   Image[] images;
 189
 190   this (const(char)[] fname) { loadFile(fname); }
 191   this (VFile fl) { loadFile(fl); }
 192
 193 private:
 194   void loadFile (VFile fl) {
 195     auto sax = new SaxyEx();
 196
 197     string norm (const(char)[] s) {
 198       string res;
 199       foreach (char ch; s) {
 200         if (ch <= ' ' || ch == 127) {
 201           if (res.length && res[$-1] > ' ') res ~= ch;
 202         } else {
 203           res ~= ch;
 204         }
 205       }
 206       return res;
 207     }
 208
 209     // sequence tag
 210     sax.onOpen("/FictionBook/description/title-info/sequence", (char[] text, char[][string] attrs) {
 211       if (auto sn = "name" in attrs) {
 212         sequence = (*sn).dup;
 213         if (auto id = "number" in attrs) {
 214           import std.conv : to;
 215           seqnum = to!uint(*id);
 216           if (seqnum < 1 || seqnum > 8192) sequence = null;
 217         }
 218       } else {
 219         sequence = null;
 220       }
 221       if (sequence.length == 0) { sequence = null; seqnum = 0; }
 222     });
 223
 224     // author's first name
 225     sax.onContent("/FictionBook/description/title-info/author/first-name", (char[] text) {
 226       authorFirst = norm(text);
 227     });
 228     // author's last name
 229     sax.onContent("/FictionBook/description/title-info/author/last-name", (char[] text) {
 230       authorLast = norm(text);
 231     });
 232     // book title
 233     sax.onContent("/FictionBook/description/title-info/book-title", (char[] text) {
 234       title = norm(text);
 235     });
 236
 237     string imageid;
 238     string imagefmt;
 239     char[] imagectx;
 240
 241     sax.onOpen("/FictionBook/binary", (char[] text, char[][string] attrs) {
 242       import iv.vfs.io;
 243       if (auto ctp = "content-type" in attrs) {
 244         if (*ctp == "image/png" || *ctp == "image/jpeg") {
 245           if (auto idp = "id" in attrs) {
 246             imageid = (*idp).idup;
 247             if (imageid.length == 0) {
 248               writeln("image without id");
 249             } else {
 250               imagefmt = (*ctp).idup;
 251             }
 252           }
 253         } else {
 254           writeln("unknown binary content format: '", *ctp, "'");
 255         }
 256       }
 257     });
 258     sax.onContent("/FictionBook/binary", (char[] text) {
 259       if (imageid.length) {
 260         foreach (char ch; text) if (ch > ' ') imagectx ~= ch;
 261       }
 262     });
 263     sax.onClose("/FictionBook/binary", (char[] text) {
 264       import iv.vfs.io;
 265       if (imageid.length) {
 266         //writeln("image with id '", imageid, "'...");
 267         import std.base64;
 268         if (imagectx.length == 0) {
 269           writeln("image with id '", imageid, "' has no data");
 270         } else {
 271           try {
 272             auto imgdata = Base64.decode(imagectx);
 273             TrueColorImage img;
 274             if (imagefmt == "image/jpeg") {
 275               img = readJpegFromMemory(imgdata[]).getAsTrueColorImage;
 276             } else if (imagefmt == "image/png") {
 277               img = imageFromPng(readPng(imgdata[])).getAsTrueColorImage;
 278             } else {
 279               assert(0, "wtf?!");
 280             }
 281             if (img.width > 1 && img.height > 1) {
 282               if (img.width > 1024 || img.height > 1024) {
 283                 // scale image
 284                 float scl = 1024.0f/(img.width > img.height ? img.width : img.height);
 285                 int nw = cast(int)(img.width*scl);
 286                 int nh = cast(int)(img.height*scl);
 287                 if (nw < 1) nw = 1;
 288                 if (nh < 1) nh = 1;
 289                 img = imageResample(img, nw, nh, RESAMPLER_DEFAULT_FILTER);
 290               }
 291             }
 292             images ~= Image(imageid, img);
 293             //writePng("z_"~imageid~".png", images[$-1].img);
 294           } catch (Exception e) {
 295             writeln("image with id '", imageid, "' has invalid data");
 296             writeln("ERROR: ", e.msg);
 297           }
 298         }
 299       }
 300       imageid = null;
 301       imagectx = null;
 302       imagefmt = null;
 303     });
 304
 305     Tag[] tagStack;
 306
 307     sax.onOpen("/FictionBook/body", (char[] text) {
 308       if (content is null) {
 309         content = new Tag();
 310         content.name = "body";
 311       }
 312       tagStack ~= content;
 313     });
 314
 315     sax.onClose("/FictionBook/body", (char[] text) {
 316       if (content is null) assert(0, "wtf?!");
 317       tagStack.length -= 1;
 318       tagStack.assumeSafeAppend;
 319     });
 320
 321     sax.onOpen("/FictionBook/body/+", (char[] text, char[][string] attrs) {
 322       auto tag = new Tag();
 323       tag.name = text.idup;
 324       tag.parent = tagStack[$-1];
 325       /*
 326       if (auto ls = tag.parent.lastChild) {
 327         ls.nextSibling = tag;
 328         tag.prevSibling = ls;
 329       }
 330       */
 331       tag.parent.children ~= tag;
 332       if (auto p = "id" in attrs) tag.id = norm(*p);
 333            if (auto p = "href" in attrs) tag.href = norm(*p);
 334       else if (auto p = "l:href" in attrs) tag.href = norm(*p);
 335       /*
 336       if (tag.name == "image") {
 337         import iv.vfs.io;
 338         writeln("IMAGE: ", tag.href);
 339       }
 340       */
 341       tagStack ~= tag;
 342     });
 343
 344     sax.onClose("/FictionBook/body/+", (char[] text) {
 345       tagStack.length -= 1;
 346       tagStack.assumeSafeAppend;
 347     });
 348
 349     sax.onContent("/FictionBook/body/+", (char[] text) {
 350       auto tag = new Tag();
 351       tag.name = null;
 352       tag.parent = tagStack[$-1];
 353       /*
 354       if (auto ls = tag.parent.lastChild) {
 355         ls.nextSibling = tag;
 356         tag.prevSibling = ls;
 357       }
 358       */
 359       tag.parent.children ~= tag;
 360       tag.text ~= text.idup;
 361     });
 362
 363     sax.loadStream(fl);
 364
 365     if (content is null) {
 366       content = new Tag();
 367       content.name = "body";
 368     }
 369   }
 370
 371   void loadFile (const(char)[] fname) {
 372     import std.path : extension;
 373     if (strEquCI(fname.extension, ".zip")) {
 374       vfsAddPak(fname);
 375       scope(exit) vfsRemovePack(fname);
 376       foreach (immutable idx, ref de; vfsFileList) {
 377         if (strEquCI(de.name.extension, ".fb2")) { loadFile(vfsOpenFile(de.name)); return; }
 378       }
 379       throw new Exception("no fb2 file found in '"~fname.idup~"'");
 380     } else {
 381       loadFile(vfsOpenFile(fname));
 382     }
 383   }
 384 }