44 files changed, 7013 insertions, 0 deletions
diff --git a/noncore/apps/opie-reader/Aportis.cpp b/noncore/apps/opie-reader/Aportis.cpp new file mode 100644 index 0000000..595b385 --- a/dev/null +++ b/noncore/apps/opie-reader/Aportis.cpp @@ -0,0 +1,291 @@ +#include <stdio.h> +#include <string.h> +#include "Aportis.h" + +Aportis::Aportis() { /*printf("constructing:%x\n",fin);*/ } + +CList<Bkmk>* Aportis::getbkmklist() +{ + if (bCompressed != 4) return NULL; + CList<Bkmk>* t = new CList<Bkmk>; + size_t cur = ftell(fin); + for (int i = 0; i < nRecs2; i++) + { + DWORD dwPos; + fseek(fin, 0x56 + 8*i, SEEK_SET); + fread(&dwPos, 4, 1, fin); + dwPos = SwapLong(dwPos); + fseek(fin,dwPos,SEEK_SET); + unsigned char ch; + fread(&ch,1,1,fin); + if (ch != 241) + { + char name[17]; + name[16] = '\0'; + fseek(fin,dwPos,SEEK_SET); + fread(name,1,16,fin); + unsigned long lcn; + fread(&lcn,sizeof(lcn),1,fin); + lcn = SwapLong(lcn); +#ifdef _UNICODE + tchar tname[17]; + memset(tname, 0, sizeof(tname)); + for (int i = 0; name[i] != 0; i++) + { + tname[i] = name[i]; + } + t->push_back(Bkmk(tname,lcn)); +#else + t->push_back(Bkmk(name,lcn)); +#endif + } + } + fseek(fin, cur, SEEK_SET); + return t; +} + +int Aportis::openfile(const char *src) +{ + + // printf("In openfile\n"); + int ret = 0; + + if (!Cpdb::openfile(src)) return -1; + + if (head.creator != 0x64414552 // 'dAER' + || head.type != 0x74584554) // 'tXET') + { + return -2; + } + + gotorecordnumber(0); + tDocRecord0 hdr0; + fread(&hdr0, sizeof(hdr0), 1, fin); + bCompressed = SwapWord(hdr0.wVersion); + if (bCompressed!=1 && bCompressed!=2 && bCompressed != 4) { + ret = bCompressed; + bCompressed = 2; + } + + fseek(fin,0,SEEK_END); + dwLen = ftell(fin); + nRecs2 = nRecs = SwapWord(head.recordList.numRecords) - 1; + + switch (bCompressed) + { + case 4: + { + dwTLen = 0; + int i; + for (i = 0; i < nRecs; i++) + { + unsigned int bs = GetBS(i); + if (bs == 0) break; + else dwTLen += bs; + } + nRecs = i; + BlockSize = 0; + } + break; + case 1: + case 2: + default: + dwTLen = SwapLong(hdr0.dwStoryLen); + BlockSize = SwapWord(hdr0.wRecSize); + if (BlockSize == 0) + { + BlockSize = 4096; + printf("WARNING: Blocksize not set in source file\n"); + } + } + + + // this is the main record buffer + // it knows how to stretch to accomodate the decompress + currentrec = 0; + cbptr = 0; + outptr = 0; + refreshbuffer(); + return ret; +} + +int Aportis::getch() +{ + if (bCompressed == 1) + { + if ((dwRecLen == 0) && !refreshbuffer()) return EOF; + else + { + int c = getc(fin); + dwRecLen--; + currentpos++; + return c; + } + } + if (outptr != cbptr) + { + currentpos++; + return (circbuf[outptr = (outptr + 1) % 2048]); + } + if ((dwRecLen == 0) && !refreshbuffer()) return EOF; + currentpos++; + unsigned int c; + + // take a char from the input buffer + c = getc(fin); + dwRecLen--; + // separate the char into zones: 0, 1...8, 9...0x7F, 0x80...0xBF, 0xC0...0xFF + + // codes 1...8 mean copy that many chars; for accented chars & binary + if (c == 0) + { + circbuf[outptr = cbptr = (cbptr+1)%2048] = c; + return c; + } + else if (c >= 0x09 && c <= 0x7F) + { + circbuf[outptr = cbptr = (cbptr+1)%2048] = c; + return c; + } + else if (c >= 0x01 && c <= 0x08) + { + dwRecLen -= c; + while(c--) + { + circbuf[cbptr = (cbptr+1)%2048] = getc(fin); + } + return circbuf[outptr = (outptr+1)%2048]; + } + else if (c >= 0x80 && c <= 0xBF) + { + int m,n; + c <<= 8; + c += getc(fin); + dwRecLen--; + m = (c & 0x3FFF) >> COUNT_BITS; + n = c & ((1<<COUNT_BITS) - 1); + n += 3; + while (n--) + { + cbptr = (cbptr+1)%2048; + circbuf[cbptr] = circbuf[(cbptr+2048-m)%2048]; + } + return circbuf[outptr = (outptr+1)%2048]; + } + else if (c >= 0xC0 && c <= 0xFF) + { + circbuf[cbptr = (cbptr+1)%2048] = ' '; + circbuf[cbptr = (cbptr+1)%2048] = c^0x80; + return circbuf[outptr = (outptr+1)%2048]; + } +} + +unsigned int Aportis::GetBS(unsigned int bn) +{ + DWORD dwPos; + WORD fs; + + fseek(fin, 0x56 + 8*bn, SEEK_SET); + fread(&dwPos, 4, 1, fin); + dwPos = SwapLong(dwPos); + fseek(fin,dwPos,SEEK_SET); + +// gotorecordnumber(bn+1); + unsigned char ch; + fread(&ch,1,1,fin); + if (ch == 241) + { + fread(&fs,sizeof(fs),1,fin); + fs = SwapWord(fs); + } + else + fs = 0; + return fs; +} + +unsigned int Aportis::locate() +{ + if (bCompressed == 4) + { + size_t cur = ftell(fin); + unsigned int clen = 0; + for (unsigned int i = 0; i < currentrec-1; i++) + { + unsigned int bs = GetBS(i); + if (bs == 0) break; + clen += bs; + } + fseek(fin,cur,SEEK_SET); + return clen+currentpos; + } + else + return (currentrec-1)*BlockSize+currentpos; +} + +void Aportis::locate(unsigned int n) +{ + unsigned int offset; + // currentrec = (n >> OFFBITS); + switch (bCompressed) + { + case 4: + { + DWORD clen = 0; + offset = n; + unsigned int i; + for (i = 0; i < nRecs; i++) + { + unsigned int bs = GetBS(i); + if (bs == 0) break; + clen += bs; + if (clen > n) break; + offset = n - clen; + } + currentrec = i; + } + break; + case 1: + case 2: + default: + currentrec = n / BlockSize; + offset = n % BlockSize; + } + + outptr = cbptr; + refreshbuffer(); + while (currentpos < offset && getch() != EOF); +} + +bool Aportis::refreshbuffer() +{ + if (currentrec < nRecs) + { + dwRecLen = recordlength(currentrec+1); + gotorecordnumber(currentrec+1); + if (bCompressed == 4) + { + unsigned char t[3]; + fread(t,1,3,fin); + if (t[0] != 241) + { + printf("You shouldn't be here!\n"); + return false; + } + dwRecLen -= 3; + } + /* + int n = fread(t.buf, 1, dwRecLen, fin); + t.len = n; + // if(bCompressed) + t.Decompress(); + + t.buf[t.Len()] = '\0'; + */ + currentpos = 0; + currentrec++; + return true; + } + else { + return false; + } +} diff --git a/noncore/apps/opie-reader/Aportis.h b/noncore/apps/opie-reader/Aportis.h new file mode 100644 index 0000000..08016f4 --- a/dev/null +++ b/noncore/apps/opie-reader/Aportis.h @@ -0,0 +1,86 @@ +/* + Derived from makedoc9 by Pat Beirne +*/ + +#ifndef __Aportis_h +#define __Aportis_h + +#include "CExpander.h" +#include "pdb.h" + +typedef UInt32 DWORD; +typedef UInt16 WORD; + +#define DISP_BITS 11 +#define COUNT_BITS 3 +/* +// all numbers in these structs are big-endian, MAC format +struct tDocHeader { + char sName[32]; + DWORD dwUnknown1; + DWORD dwTime1; + DWORD dwTime2; + DWORD dwTime3; + DWORD dwLastSync; + DWORD ofsSort; + DWORD ofsCatagories; + DWORD dwCreator; + DWORD dwType; + DWORD dwUnknown2; + DWORD dwUnknown3; + WORD wNumRecs; +}; +*/ +struct tDocRecord0 { + WORD wVersion; // 1=plain text, 2=compressed + WORD wSpare; + DWORD dwStoryLen; // in chars, when decompressed + WORD wNumRecs; // text records only; equals tDocHeader.wNumRecs-1 + WORD wRecSize; // usually 0x1000 + DWORD dwSpare2; +}; + +////////////// utilities ////////////////////////////////////// + +inline WORD SwapWord(WORD r) +{ + return (r>>8) + (r<<8); +} + +inline DWORD SwapLong(DWORD r) +{ + return ((r>>24) & 0xFF) + (r<<24) + ((r>>8) & 0xFF00) + ((r<<8) & 0xFF0000); +} + +class Aportis : public CExpander, Cpdb { + DWORD dwLen; + WORD nRecs2; + DWORD dwTLen; + WORD nRecs; + WORD BlockSize; + DWORD dwRecLen; + int currentrec, currentpos; + unsigned int cbptr; + unsigned int outptr; + unsigned char circbuf[2048]; + char bCompressed; +public: + virtual void sizes(unsigned long& _file, unsigned long& _text) + { + _file = dwLen; + _text = dwTLen; + } + virtual bool hasrandomaccess() { return true; } + virtual ~Aportis() {} + Aportis(); + virtual int openfile(const char *src); + virtual int getch(); + virtual unsigned int locate(); + virtual void locate(unsigned int n); + virtual CList<Bkmk>* getbkmklist(); +private: + bool refreshbuffer(); + unsigned int GetBS(unsigned int bn); +}; + +#endif diff --git a/noncore/apps/opie-reader/BuffDoc.cpp b/noncore/apps/opie-reader/BuffDoc.cpp new file mode 100644 index 0000000..df2f4eb --- a/dev/null +++ b/noncore/apps/opie-reader/BuffDoc.cpp @@ -0,0 +1,126 @@ +#include "BuffDoc.h" +//#include <FL/fl_draw.h> +#include "config.h" + +void BuffDoc::locate(unsigned int n) +{ + // qDebug("BuffDoc:locating:%u",n); + + lastword[0] = '\0'; + lastsizes[0] = laststartline = n; + lastispara = false; + // tchar linebuf[1024]; + if (exp != NULL) exp->locate(n); + // qDebug("BuffDoc:Located"); +} + +bool BuffDoc::getline(CBuffer* buff, int w) +{ + if (exp == NULL) + { + (*buff)[0] = '\0'; + return false; + } + int len = 0, ch, lastcheck = 0; + *buff = lastword.data(); + lastcheck = len = buff->length(); + // unsigned int slen = fl_widthi(buff->data(),len); +#ifdef _UNICODE + unsigned int slen = m_fm->width(toQString(buff->data()),len); +#else + unsigned int slen = m_fm->width(buff->data(),len); +#endif + if (slen > w) + { + for ( ; len > 0; len--) + { + // if (fl_widthi(buff->data(),len) < w) break; +#ifdef _UNICODE + if (m_fm->width(toQString(buff->data()),len) < w) break; +#else + if (m_fm->width(buff->data(),len) < w) break; +#endif + } + lastword = buff->data() + len - 1; + for (int i = 0; i < buff->length(); i++) lastsizes[i] = lastsizes[i+len-1]; + (*buff)[len-1] = '-'; + (*buff)[len] = '\0'; + laststartline = lastsizes[len-1]; + return true; + } + if (lastispara) + { + lastispara = false; + lastword[0] = '\0'; + len = buff->length(); + // while (fl_widthi(buff->data(),len) > w) len--; +#ifdef _UNICODE + while (m_fm->width(toQString(buff->data()),len) > w) len--; +#else + while (m_fm->width(buff->data(),len) > w) len--; +#endif + (*buff)[len] = '\0'; + laststartline = exp->locate(); + return true; + } + lastispara = false; + for (int i = 0; i < len; i++) allsizes[i] = lastsizes[i]; + while (slen < w) + { + lastcheck = len; + allsizes[len] = exp->locate(); + while ((ch = getch()) != ' ' && ch != '\012' && ch != UEOF && len < 128) + { + (*buff)[len++] = ch; + allsizes[len] = exp->locate(); + } + (*buff)[len] = 0; +#ifdef _UNICODE + slen = m_fm->width(toQString(buff->data()),len); +#else + slen = m_fm->width(buff->data(),len); +#endif + (*buff)[len++] = ' '; + allsizes[len] = exp->locate(); + if (slen < w && ch != ' ') + { + lastcheck = len; + break; + } + lastispara = (ch == '\012'); + } + (*buff)[len] = '\0'; + lastword = buff->data()+lastcheck; + for (int i = 0; i < lastword.length(); i++) lastsizes[i] = allsizes[i+lastcheck]; + if (lastcheck > 0) + { + laststartline = allsizes[lastcheck]; + (*buff)[lastcheck-1] = '\0'; + } + else + { + laststartline = (lastcheck == len) ? exp->locate() : allsizes[lastcheck+1]; + (*buff)[lastcheck] = '\0'; + } +// laststartline = sizes[lastcheck+1]; +// (*buff)[(lastcheck > 0) ? lastcheck-1:lastcheck] = '\0'; + return (ch != UEOF); +} + +bool BuffDoc::getline(CBuffer* buff, int w, int cw) +{ + if (exp == NULL) + { + (*buff)[0] = '\0'; + return false; + } + tchar ch; + int i = 0; + while ((i < w/cw) && ((ch = getch()) != '\012') && (ch != UEOF)) + { + (*buff)[i++] = ch; + } + (*buff)[i] = '\0'; + laststartline = exp->locate(); + return (ch != UEOF); +} diff --git a/noncore/apps/opie-reader/BuffDoc.h b/noncore/apps/opie-reader/BuffDoc.h new file mode 100644 index 0000000..7c5ef9a --- a/dev/null +++ b/noncore/apps/opie-reader/BuffDoc.h @@ -0,0 +1,138 @@ +#ifndef __BuffDoc_h +#define __BuffDoc_h + +#include "CBuffer.h" +#include "ZText.h" +#include "Aportis.h" +#include "ztxt.h" +#include "ppm_expander.h" +#include "CFilter.h" +#include <qfontmetrics.h> +#include <qmessagebox.h> + +class BuffDoc +{ + CBuffer lastword; + CSizeBuffer lastsizes, allsizes; + size_t laststartline; + bool lastispara; + CExpander* exp; + CFilterChain* filt; + QFontMetrics* m_fm; + public: + ~BuffDoc() + { + delete filt; + delete exp; + } + BuffDoc() : m_fm(NULL) + { + exp = NULL; + filt = NULL; + // qDebug("Buffdoc created"); + } + bool empty() { return (exp == NULL); } + void setfm(QFontMetrics* fm) + { + m_fm = fm; + // qDebug("Buffdoc:setfm"); + } + void setfilter(CFilterChain* _f) + { + if (filt != NULL) delete filt; + filt = _f; + filt->setsource(exp); + } + CList<Bkmk>* getbkmklist() { return exp->getbkmklist(); } + bool hasrandomaccess() { return (exp == NULL) ? false : exp->hasrandomaccess(); } + bool iseol() { return (lastword[0] == '\0'); } + int openfile(QWidget* _parent, const char *src) + { + // qDebug("BuffDoc:Openfile:%s", src); + // qDebug("Trying aportis %x",exp); + if (exp != NULL) delete exp; + lastword[0] = '\0'; + lastsizes[0] = laststartline = 0; + lastispara = false; + /* + exp = new Text; + int ret = exp->openfile(src); + */ + + exp = new Aportis; + // qDebug("Calling openfile"); + int ret = exp->openfile(src); + // qDebug("Called openfile"); + if (ret == -1) + { + // qDebug("problem opening source file:%s",src); + delete exp; + exp = NULL; + return ret; + } + if (ret == -2) + { + + delete exp; +// qDebug("Trying ztxt"); + exp = new ztxt; + ret = exp->openfile(src); + } +#ifndef SMALL + if (ret != 0) + { + delete exp; +// qDebug("Trying ppms"); + exp = new ppm_expander; + ret = exp->openfile(src); + } + + if (ret != 0) + { + delete exp; + exp = new Text; +// qDebug("Trying text"); + ret = exp->openfile(src); + } +#else + if (ret != 0) + { + delete exp; + exp = new Text; + ret = exp->openfile(src); + } +#endif + if (ret != 0) + { + delete exp; + QMessageBox::information(_parent, "QTReader", "Unknown file compression type","Try another file"); + return ret; + } + // qDebug("Doing final open:%x:%x",exp,filt); + + lastword[0] = '\0'; + lastsizes[0] = laststartline = 0; + lastispara = false; + exp->locate(0); + filt->setsource(exp); + // qDebug("BuffDoc:file opened"); + return 0; + } + int getch() { return (exp == NULL) ? UEOF : filt->getch(); } + unsigned int locate() { return (exp == NULL) ? 0 : laststartline; } + void locate(unsigned int n); + bool getline(CBuffer* buff, int w); + bool getline(CBuffer* buff, int w, int cw); + void sizes(unsigned long& fs, unsigned long& ts) { exp->sizes(fs,ts); } + int getpara(CBuffer& buff) + { + int ch, i = 0; + while ((ch = getch()) != 10 && ch != UEOF) buff[i++] = ch; + buff[i] = '\0'; + if (i == 0 && ch == UEOF) i = -1; + laststartline = exp->locate(); + return i; + } +}; + +#endif diff --git a/noncore/apps/opie-reader/CBuffer.cpp b/noncore/apps/opie-reader/CBuffer.cpp new file mode 100644 index 0000000..db52476 --- a/dev/null +++ b/noncore/apps/opie-reader/CBuffer.cpp @@ -0,0 +1,35 @@ +#include "CBuffer.h" + +CBuffer& CBuffer::operator=(const tchar*sztmp) +{ + int i; + for (i = 0; sztmp[i] != '\0'; i++) (*this)[i] = sztmp[i]; + (*this)[i] = '\0'; + return *this; +} + +tchar& CBuffer::operator[](int i) +{ + if (i >= len) + { + tchar *newbuff = new tchar[i+1]; + memcpy(newbuff,buffer,sizeof(tchar)*len); + delete [] buffer; + buffer = newbuff; + len = i+1; + } + return buffer[i]; +} + +size_t& CSizeBuffer::operator[](int i) +{ + if (i >= len) + { + size_t *newbuff = new size_t[i+1]; + memcpy(newbuff,buffer,sizeof(size_t)*len); + delete [] buffer; + buffer = newbuff; + len = i+1; + } + return buffer[i]; +} diff --git a/noncore/apps/opie-reader/CBuffer.h b/noncore/apps/opie-reader/CBuffer.h new file mode 100644 index 0000000..9807d27 --- a/dev/null +++ b/noncore/apps/opie-reader/CBuffer.h @@ -0,0 +1,45 @@ +#ifndef __CBUFFER_H +#define __CBUFFER_H + +#include <stdlib.h> +#include <string.h> +#include "config.h" + +class CBuffer +{ + size_t len; + tchar *buffer; + CBuffer(const CBuffer&); + public: + CBuffer& operator=(const tchar*sztmp); +#ifdef _UNICODE + size_t length() { return ustrlen(buffer); } +#else + size_t length() { return strlen(buffer); } +#endif + tchar* data() { return buffer; } + CBuffer(size_t n = 16) : len(n) + { + buffer = new tchar[len]; + buffer[0] = '\0'; + } + ~CBuffer() { delete [] buffer; } + tchar& operator[](int i); +}; + +class CSizeBuffer +{ + size_t len; + size_t *buffer; + CSizeBuffer(const CSizeBuffer&); + public: + size_t* data() { return buffer; } + CSizeBuffer(size_t n = 16) : len(n) + { + buffer = new size_t[len]; + } + ~CSizeBuffer() { delete [] buffer; } + size_t& operator[](int i); +}; + +#endif diff --git a/noncore/apps/opie-reader/CEncoding.cpp b/noncore/apps/opie-reader/CEncoding.cpp new file mode 100644 index 0000000..18d18d3 --- a/dev/null +++ b/noncore/apps/opie-reader/CEncoding.cpp @@ -0,0 +1,150 @@ +#include <stdio.h> +#include "CEncoding.h" + +tchar CUtf8::getch() +{ + int iret = parent->getch(); + if (iret == EOF) return UEOF; + tchar ret = iret; + int count = 0; + if (ret & (1 << 7)) + { + unsigned char flags = ret << 1; + while ((flags & (1 << 7)) != 0) + { + ret <<= 6; + ret += parent->getch() & 0x3f; + flags <<= 1; + count++; + } + switch (count) + { + case 0: + break; + case 1: + ret &= 0x07ff; + break; + case 2: + break; + case 3: + case 4: + case 5: + default: + printf("Only 16bit unicode supported..."); + } + } + return ret; +} + + +tchar CUcs16be::getch() +{ + int iret = parent->getch(); + if (iret == EOF) return UEOF; + tchar ret = iret; + return (ret << 8) + parent->getch(); +} + +tchar CUcs16le::getch() +{ + int iret = parent->getch(); + if (iret == EOF) return UEOF; + tchar ret = iret; + return ret + (parent->getch() << 8); +} + +tchar Ccp1252::getch() +{ + int iret = parent->getch(); + switch (iret) + { + case EOF: + return UEOF; + case 0x80: + return 0x20ac; + case 0x82: + return 0x201a; + case 0x83: + return 0x0192; + case 0x84: + return 0x201e; + case 0x85: + return 0x2026; + case 0x86: + return 0x2020; + case 0x87: + return 0x2021; + case 0x88: + return 0x02c6; + case 0x89: + return 0x2030; + case 0x8a: + return 0x0160; + case 0x8b: + return 0x2039; + case 0x8c: + return 0x0152; + case 0x8e: + return 0x017d; + case 0x91: + return 0x2018; + case 0x92: + return 0x2019; + case 0x93: + return 0x201c; + case 0x94: + return 0x201d; + case 0x95: + return 0x2022; + case 0x96: + return 0x2013; + case 0x97: + return 0x2014; + case 0x98: + return 0x02dc; + case 0x99: + return 0x2122; + case 0x9a: + return 0x0161; + case 0x9b: + return 0x203a; + case 0x9c: + return 0x0153; + case 0x9e: + return 0x017e; + case 0x9f: + return 0x0178; + default: + return iret; + } +} + +tchar CPalm::getch() +{ + tchar iret = Ccp1252::getch(); + switch (iret) + { + case 0x18: + return 0x2026; + case 0x19: + return 0x2007; + case 0x8d: + return 0x2662; + case 0x8e: + return 0x2663; + case 0x8f: + return 0x2661; + case 0x90: + return 0x2660; + default: + return iret; + } +} + +tchar CAscii::getch() +{ + int iret = parent->getch(); + if (iret == EOF) return UEOF; + return iret; +} + diff --git a/noncore/apps/opie-reader/CEncoding.h b/noncore/apps/opie-reader/CEncoding.h new file mode 100644 index 0000000..1eee29e --- a/dev/null +++ b/noncore/apps/opie-reader/CEncoding.h @@ -0,0 +1,53 @@ +#ifndef __CENCODING_H +#define __CENCODING_H + +#include "CExpander.h" + +class CEncoding : public CCharacterSource +{ + friend class CFilterChain; + protected: + CExpander* parent; +public: + CEncoding() : parent(NULL) {} + void setparent(CExpander* p) { parent = p; } + virtual ~CEncoding() {}; +}; + +class CUtf8 : public CEncoding +{ +public: + tchar getch(); +}; + +class CUcs16be : public CEncoding +{ +public: + tchar getch(); +}; + +class CUcs16le : public CEncoding +{ +public: + tchar getch(); +}; + +class Ccp1252 : public CEncoding +{ +public: + virtual tchar getch(); +}; + +class CPalm : public Ccp1252 +{ +public: + tchar getch(); +}; + +class CAscii : public CEncoding +{ +public: + tchar getch(); +}; + +#endif diff --git a/noncore/apps/opie-reader/CExpander.h b/noncore/apps/opie-reader/CExpander.h new file mode 100644 index 0000000..07c14fa --- a/dev/null +++ b/noncore/apps/opie-reader/CExpander.h @@ -0,0 +1,145 @@ +#ifndef __CExpander_h +#define __CExpander_h + +#include "my_list.h" +#include "config.h" + +class Bkmk +{ + friend class BkmkFile; + tchar* m_name; + unsigned int m_position; + public: + Bkmk() : m_name(NULL), m_position(0) {}; + Bkmk(const tchar* _nm, unsigned int _p) : m_position(_p) + { + int len = ustrlen(_nm)+1; + m_name = new tchar[len]; + for (int i = 0; i < len; i++) m_name[i] = _nm[i]; + } + Bkmk(const Bkmk& rhs) : m_name(NULL) + { + *this = rhs; + } + ~Bkmk() { if (m_name != NULL) delete [] m_name; } + unsigned int value() const { return m_position; } + tchar *name() const { return m_name; } + bool operator<(const Bkmk& rhs) { return (m_position < rhs.m_position); } + Bkmk& operator=(const Bkmk& rhs) + { + if (m_name != NULL) delete [] m_name; + if (rhs.m_name != NULL) + { + int len = ustrlen(rhs.m_name)+1; + m_name = new tchar[len]; + for (int i = 0; i < len; i++) m_name[i] = rhs.m_name[i]; + } + else + m_name = NULL; + m_position = rhs.m_position; + return *this; + } + bool operator==(const Bkmk& rhs) + { + return (m_position == rhs.m_position && ustrcmp(m_name,rhs.m_name) == 0); + } +}; + +class BkmkFile +{ + FILE* f; + bool wt; +public: + BkmkFile(const char *fnm, bool w = false) + : + wt(w) + { + if (w) + f = fopen(fnm, "wb"); + else + f = fopen(fnm, "rb"); + } + ~BkmkFile() + { + if (f != NULL) fclose(f); + } + void write(tchar* nm, const unsigned int& pos) + { + if (f != NULL) + { + unsigned short ln = ustrlen(nm); + fwrite(&ln,sizeof(ln),1,f); + fwrite(nm,sizeof(tchar),ln,f); + fwrite(&pos,sizeof(pos),1,f); + } + } + void write(const Bkmk& b) { write(b.name(), b.value()); } + void write(CList<Bkmk>& bl) + { + if (f != NULL) + { + for (CList<Bkmk>::iterator i = bl.begin(); i != bl.end(); i++) + { + write(*i); + } + } + } + Bkmk* read() + { + Bkmk* b = NULL; + if (f != NULL) + { + unsigned short ln; + if (fread(&ln,sizeof(ln),1,f) == 1) + { + b = new Bkmk; + b->m_name = new tchar[ln+1]; + fread(b->m_name,sizeof(tchar),ln,f); + b->m_name[ln] = 0; + fread(&b->m_position,sizeof(b->m_position),1,f); + } + } + return b; + } + CList<Bkmk>* readall() + { + CList<Bkmk>* bl = NULL; + if (f != NULL) + { + bl = new CList<Bkmk>; + while (1) + { + Bkmk* b = read(); + if (b == NULL) break; + bl->push_back(*b); + delete b; + } + } + return bl; + } +}; + +class CCharacterSource +{ + public: +#ifdef _UNICODE + virtual tchar getch() = 0; +#else + virtual int getch() = 0; +#endif +}; + +class CExpander +{ + public: + CExpander() {}; + virtual ~CExpander() {}; + virtual int openfile(const char *src) = 0; + virtual unsigned int locate() = 0; + virtual void locate(unsigned int n) = 0; + virtual bool hasrandomaccess() = 0; + virtual void sizes(unsigned long& file, unsigned long& text) = 0; + virtual CList<Bkmk>* getbkmklist() { return NULL; } + virtual int getch() = 0; +}; +#endif diff --git a/noncore/apps/opie-reader/CFilter.h b/noncore/apps/opie-reader/CFilter.h new file mode 100644 index 0000000..4f609dc --- a/dev/null +++ b/noncore/apps/opie-reader/CFilter.h @@ -0,0 +1,354 @@ +#ifndef __CFILTER_H +#define __CFILTER_H + +#include "CExpander.h" +#include "CEncoding.h" + +class CFilter : public CCharacterSource +{ + friend class CFilterChain; + protected: + CCharacterSource* parent; +public: + CFilter() : parent(NULL) {} + void setparent(CCharacterSource* p) { parent = p; } + virtual ~CFilter() {}; +}; + +class vanilla : public CFilter +{ +public: + vanilla() {} + virtual ~vanilla() {} +#ifdef _UNICODE + virtual tchar getch() +#else + virtual int getch() +#endif + { + return parent->getch(); + } +}; + +class CFilterChain +{ + CExpander* expander; + CEncoding* encoder; + CFilter* first; + CCharacterSource* front; + public: + CFilterChain(CEncoding* _e) : encoder(_e), first(NULL), front(_e) {}; + ~CFilterChain() + { + CCharacterSource* p = front; + while (p != encoder) + { + CFilter* pnext = (CFilter*)p; + p = ((CFilter*)p)->parent; + delete pnext; + } + delete encoder; + } + int getch() { return front->getch(); } + void addfilter(CFilter* p) + { + if (first == NULL) + { + front = first = p; + p->setparent(encoder); + } + else + { + p->setparent(front); + front = p; + } + } + void setsource(CExpander* p) + { + expander = p; + encoder->setparent(p); + } + void setencoder(CEncoding* p) + { + delete encoder; + encoder = p; + first->setparent(p); + encoder->setparent(expander); + } +}; + +class stripcr : public CFilter +{ +public: + stripcr() {} + virtual ~stripcr() {} +#ifdef _UNICODE + virtual tchar getch() + { + tchar ch; + do + { + ch = parent->getch(); + } + while (ch == 13); + return ch; + } +#else + virtual int getch() + { + int ch; + do + { + ch = parent->getch(); + } + while (ch == 13); + return ch; + } +#endif +}; + +class dehyphen : public CFilter +{ + bool m_bCharWaiting; + tchar m_nextChar; + public: + dehyphen() : m_bCharWaiting(false) {} + virtual ~dehyphen() {} + virtual tchar getch() + { + if (m_bCharWaiting) + { + m_bCharWaiting = false; + return m_nextChar; + } + tchar ch = parent->getch(); + if (ch != '-') return ch; + m_nextChar = parent->getch(); + if (m_nextChar != 10) + { + m_bCharWaiting = true; + return '-'; + } + return parent->getch(); + } +}; + +class striphtml : public CFilter +{ +public: + striphtml() {} + virtual ~striphtml() {} +#ifdef _UNICODE + virtual tchar getch() + { + tchar ch; + ch = parent->getch(); + while (ch == '<') + { + while (ch != '>') + { + ch = parent->getch(); + } + ch = parent->getch(); + } + if (ch == '&') + { + ch = parent->getch(); + if (ch == '#') + { + int id = 0; + while ((ch = parent->getch()) != ';') id = 10*id+ch-'0'; + ch = id; + } + } + return ch; + } +#else + virtual int getch() + { + int ch; + ch = parent->getch(); + while (ch == '<') + { + while (ch != '>') + { + ch = parent->getch(); + } + ch = parent->getch(); + } + if (ch == '&') + { + ch = parent->getch(); + if (ch == '#') + { + int id = 0; + while ((ch = parent->getch()) != ';') id = 10*id+ch-'0'; + ch = id; + } + } + return ch; + } +#endif +}; + +class unindent : public CFilter +{ + tchar lc; +public: + unindent() : lc(0) {} + virtual ~unindent() {} +#ifdef _UNICODE + virtual tchar getch() + { + tchar ch; + if (lc == 10) + { + while ((ch = parent->getch()) == ' '); + } + else ch = parent->getch(); + lc = ch; + return ch; + } +#else + virtual int getch() + { + int ch; + if (lc == 10) + { + while ((ch = parent->getch()) == ' '); + } + else ch = parent->getch(); + lc = ch; + return ch; + } +#endif +}; + +#ifdef _UNICODE +class repara : public CFilter +{ + tchar tch; +public: + repara() : tch(0) {} + virtual ~repara() {} + virtual tchar getch() + { + tchar ch = parent->getch(); + if (ch == 10) + { + if (tch == 10) + { + return ch; + } + else + { + tch = ch; + return ' '; + } + } + tch = ch; + return ch; + } +}; +#else +class repara : public CFilter +{ + int tch; +public: + repara() : tch(0) {} + virtual ~repara() {} + virtual int getch() + { + int ch = parent->getch(); + if (ch == 10) + { + if (tch == 10) + { + return ch; + } + else + { + tch = ch; + return ' '; + } + } + tch = ch; + return ch; + } +}; +#endif + +class indenter : public CFilter +{ + int amnt; + int indent; +public: + indenter(int _a=5) : amnt(_a), indent(0) {} + virtual ~indenter() {} +#ifdef _UNICODE + virtual tchar getch() + { + if (indent > 0) + { + indent--; + return ' '; + } + tchar ch = parent->getch(); + if (ch == 10) + { + indent = amnt; + } + return ch; + } +#else + virtual int getch() + { + if (indent > 0) + { + indent--; + return ' '; + } + int ch = parent->getch(); + if (ch == 10) + { + indent = amnt; + } + return ch; + } +#endif +}; + +class dblspce : public CFilter +{ + bool lastlf; +public: + dblspce() : lastlf(false) {} + virtual ~dblspce() {} +#ifdef _UNICODE + virtual tchar getch() + { + if (lastlf) + { + lastlf = false; + return 10; + } + tchar ch = parent->getch(); + lastlf = (ch == 10); + return ch; + } +#else + virtual int getch() + { + if (lastlf) + { + lastlf = false; + return 10; + } + int ch = parent->getch(); + lastlf = (ch == 10); + return ch; + } +#endif +}; + +#endif diff --git a/noncore/apps/opie-reader/QTReader.cpp b/noncore/apps/opie-reader/QTReader.cpp new file mode 100644 index 0000000..6251812 --- a/dev/null +++ b/noncore/apps/opie-reader/QTReader.cpp @@ -0,0 +1,1034 @@ +/**************************************************************************** +** $Id$ +** +** Copyright (C) 1992-2000 Trolltech AS. All rights reserved. +** +** This file is part of an example program for Qt. This example +** program may be used, distributed and modified without limitation. +** +*****************************************************************************/ + +#include "config.h" +#include "QTReader.h" +#include "QTReaderApp.h" +#include <qpe/qpeapplication.h> +#include <math.h> +#include <ctype.h> +#include <stdio.h> //for sprintf +#include <qpe/config.h> +#include <qpe/applnk.h> +#include <qfontdatabase.h> +#include <qpe/global.h> +#include <qpe/qcopenvelope_qws.h> + +#ifdef _UNICODE +const char *QTReader::fonts[] = { "unifont", "Courier", "Times", 0 }; +#else +const char *QTReader::fonts[] = { "Helvetica", "Courier", "Times", 0 }; +#endif +//const int QTReader::fontsizes[] = { 8, 10, 12, 14, 18, 24, 30, 40, 50, 60, 70, 80, 90, 100, 0 }; + +//const tchar *QTReader::fonts[] = { "unifont", "fixed", "micro", "smoothtimes", "Courier", "Times", 0 }; +//const int QTReader::fontsizes[] = {10,16,17,22,0}; +//const tchar *QTReader::fonts[] = { "verdana", "Courier", "Times", 0 }; +//const int QTReader::fontsizes[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,0}; + +QTReader::QTReader( QWidget *parent=0, const char *name=0, WFlags f = 0) : + QWidget(parent, name, f), + m_delay(100), + m_scrolldy(0), + m_autoScroll(false), + textarray(NULL), + locnarray(NULL), + numlines(0), + m_fontname("unifont"), + m_fm(NULL) +{ + m_overlap = 1; + fontsizes = NULL; +// init(); +} +/* +QTReader::QTReader( const QString& filename, QWidget *parent=0, const tchar *name=0, WFlags f = 0) : + QWidget(parent, name, f), + m_textfont(0), + m_textsize(1), + textarray(NULL), + numlines(0), + bstripcr(true), + bunindent(false), + brepara(false), + bdblspce(false), + btight(false), + bindenter(0), + m_fm(NULL) +{ + init(); + // qDebug("Load_file(1)"); + load_file((const tchar*)filename); +} +*/ + +long QTReader::real_delay() +{ + return ( 8976 + m_delay ) / ( m_linespacing * m_linespacing ); +} + +void QTReader::mouseReleaseEvent( QMouseEvent* _e ) +//void QTReader::mouseDoubleClickEvent( QMouseEvent* _e ) +{ + if (textarray != NULL) + { +// printf("(%u, %u)\n", _e->x(), _e->y()); + QString wrd = QString::null; + int lineno = _e->y()/m_linespacing; + if (m_bMonoSpaced) + { + int chno = _e->x()/m_charWidth; + if (chno < ustrlen(textarray[lineno]->data())) + { + wrd[0] = textarray[lineno]->data()[chno]; + } + } + else + { + CBuffer* t = textarray[lineno]; + int first = 0; + while (1) + { + int i = first+1; +// while ((*t)[i] != ' ' && (*t)[i] != 0) i++; + while (QChar((*t)[i]).isLetter() && (*t)[i] != 0) i++; + if (m_fm->width(toQString(t->data()), i) > _e->x()) + { + wrd = toQString(t->data()+first, i - first); + break; + } +// while ((*t)[i] == ' ' && (*t)[i] != 0) i++; + while (!QChar((*t)[i]).isLetter() && (*t)[i] != 0) i++; + if ((*t)[i] == 0) break; + first = i; + } + } + if (!wrd.isEmpty()) + { + QClipboard* cb = QApplication::clipboard(); + cb->setText(wrd); + Global::statusMessage(wrd); + if (!m_targetapp.isEmpty() && !m_targetmsg.isEmpty()) + { + QCopEnvelope e(("QPE/Application/"+m_targetapp).utf8(), (m_targetmsg+"(QString)").utf8()); + e << wrd; + } + } + } +} + +void QTReader::focusInEvent(QFocusEvent* e) +{ + if (m_autoScroll) timer->start(real_delay(), false); + update(); +} + +void QTReader::focusOutEvent(QFocusEvent* e) +{ + if (m_autoScroll) + { + timer->stop(); + m_scrolldy = 0; + } +} + +#include <qapplication.h> +#include <qdrawutil.h> +#include <unistd.h> + +void QTReader::goDown() +{ + if (m_bpagemode) + { + dopagedn(); + } + else + { + lineDown(); + } +} + +void QTReader::goUp() +{ + if (m_bpagemode) + { + dopageup(); + } + else + { + lineUp(); + } +} + +void QTReader::keyPressEvent(QKeyEvent* e) +{ + switch (e->key()) + { + case Key_Down: + { + e->accept(); + if (m_autoScroll) + { + if (m_delay < 59049) + { + m_delay = (3*m_delay)/2; + timer->changeInterval(real_delay()); + } + else + { + m_delay = 59049; + } + } + else + { + goDown(); + } + } + break; + case Key_Up: + { + e->accept(); + if (m_autoScroll) + { + if (m_delay > 1024) + { + m_delay = (2*m_delay)/3; + timer->changeInterval(real_delay()); + } + else + { + m_delay = 1024; + } + } + else + { + goUp(); + } + } + break; + /* + case Key_Left: + { + e->accept(); + if (m_textfont > 0) + { + m_textfont--; + setfont(NULL); + locate(pagelocate()); + update(); + } + } + break; + case Key_Right: + { + e->accept(); + if (fonts[++m_textfont] == 0) + { + m_textfont--; + } + else + { + setfont(NULL); + locate(pagelocate()); + update(); + } + } + break; + */ + case Key_Right: + { + e->accept(); + if (fontsizes[++m_textsize] == 0) + { + m_textsize--; + } + else + { + bool sc = m_autoScroll; + m_autoScroll = false; + setfont(NULL); + locate(pagelocate()); + update(); + m_autoScroll = sc; + if (m_autoScroll) autoscroll(); + } + } + break; + case Key_Left: + { + e->accept(); + if (m_textsize > 0) + { + bool sc = m_autoScroll; + m_autoScroll = false; + m_textsize--; + setfont(NULL); + locate(pagelocate()); + update(); + m_autoScroll = sc; + if (m_autoScroll) autoscroll(); + } + } + break; + case Key_Space: +// case Key_Enter: + case Key_Return: + { + e->accept(); + setautoscroll(!m_autoScroll); + ((QTReaderApp*)parent()->parent())->setScrollState(m_autoScroll); + } + break; + default: + e->ignore(); + } +} + +void QTReader::setautoscroll(bool _sc) +{ + if (_sc == m_autoScroll) return; + if (m_autoScroll) + { + m_autoScroll = false; + } + else + { + m_autoScroll = true; + autoscroll(); + } +} + +bool QTReader::getline(CBuffer *buff) +{ + if (m_bMonoSpaced) + { + return buffdoc.getline(buff ,width(), m_charWidth); + } + else + { + return buffdoc.getline(buff, width()); + } +} + +void QTReader::doscroll() +{ + if (!m_autoScroll) + { + timer->stop(); + return; + } +// timer->changeInterval(real_delay()); + QPainter p( this ); + QBrush b( white); + bitBlt(this,0,0,this,0,1,width(),-1); + qDrawPlainRect(&p,0,height() - 2,width(),2,white,1,&b); + + if (++m_scrolldy == m_linespacing) + { + setfont(&p); + m_scrolldy = 0; +// qDrawPlainRect(&p,0,height() - m_linespacing,width(),m_linespacing,white,1,&b); + pagepos = locnarray[1]; + CBuffer* buff = textarray[0]; + for (int i = 1; i < numlines; i++) + { + textarray[i-1] = textarray[i]; + locnarray[i-1] = locnarray[i]; + } + locnarray[numlines-1] = locate(); + if (getline(buff)) + { + textarray[numlines-1] = buff; + drawText( p, 0, height() - m_descent - 2, buff->data()); + mylastpos = locate(); + } + else + { +// (*buff)[0] = '\0'; + textarray[numlines-1] = buff; + m_autoScroll = false; + ((QTReaderApp*)parent()->parent())->setScrollState(m_autoScroll); + } + } +} + +void QTReader::drawText(QPainter& p, int x, int y, tchar* _text) +{ + QString text = toQString(_text); + if (m_bMonoSpaced) + { + for (int i = 0; i < text.length(); i++) + { + p.drawText( x+i*m_charWidth, y, QString(text[i]) ); + } + } + else + { + p.drawText( x, y, text ); + } +} + +void QTReader::autoscroll() +{ + timer->start(real_delay(), false); +} + +void QTReader::setfont(QPainter* p) +{ + // qDebug("Fontsize = %u",fontsizes[m_textsize]); + // qDebug("SetFont %x",p); + QFont font(m_fontname, fontsizes[m_textsize], (m_bBold) ? QFont::Bold : QFont::Normal ); + m_charWidth = (m_charpc*fontsizes[m_textsize])/100; + if (m_charWidth <= 0) m_charWidth = 1; +// font.setFixedPitch(m_bMonoSpaced); +// qDebug("Raw name = %s", (const char*)font.rawName()); + if (p != NULL) p->setFont( font ); + if (m_fm == NULL) + { + m_fm = new QFontMetrics(font); + buffdoc.setfm(m_fm); + } + else + { + *m_fm = QFontMetrics(font); + } + m_ascent = m_fm->ascent(); + m_descent = m_fm->descent(); + m_linespacing = m_fm->lineSpacing(); +} + +void QTReader::drawFonts( QPainter *p ) +{ + setfont(p); + if (m_lastwidth != width()) + { + m_lastwidth = width(); + locate(pagepos); + } + else + { + int sl = screenlines(); + if (sl < numlines) + { +// qDebug("df:<%u,%u>",sl,numlines); + + size_t newpos = locnarray[sl]; + CBuffer** nta = new CBuffer*[sl]; + size_t* nla = new size_t[sl]; + for (int i = 0; i < sl; i++) + { + nta[i] = textarray[i]; + nla[i] = locnarray[i]; + } + for (int i = sl; i < numlines; i++) delete textarray[i]; + delete [] textarray; + delete [] locnarray; + textarray = nta; + locnarray = nla; + numlines = sl; + jumpto(mylastpos = newpos); +// locate(pagepos); + } + if (sl > numlines) + { +// qDebug("df:<%u,%u>",sl,numlines); + CBuffer** nta = new CBuffer*[sl]; + size_t* nla = new size_t[sl]; + for (int i = 0; i < numlines; i++) + { + nta[i] = textarray[i]; + nla[i] = locnarray[i]; + } + if (locate() != mylastpos) jumpto(mylastpos); + for (int i = numlines; i < sl; i++) + { + nta[i] = new CBuffer; + nla[i] = locate(); + getline(nta[i]); + } + mylastpos = locate(); + delete [] textarray; + delete [] locnarray; + textarray = nta; + locnarray = nla; + numlines = sl; + } + int ypos = (btight) ? 0 : m_ascent-m_linespacing; + // int linespacing = (tight) ? m_ascent : m_ascent+m_descent; + for (int i = 0; i < numlines; i++) + { + drawText( *p, 0, ypos += m_linespacing, textarray[i]->data()); + } + /* + + + + int nlines = height()/(fontmetric.ascent()+fontmetric.descent()); + tchar buffer[1024]; + for (int i = 0; i < nlines; i++) + { + y += fontmetric.ascent(); + sprintf(buffer, "%d:%d:%s[%d]:Lines %d:%s", i+1, m_textfont, fonts[m_textfont], m_fs, nlines, (const tchar*)m_string); + drawText( *p, 0, y, buffer ); + y += fontmetric.descent(); + } + */ + } + m_scrolldy = 0; +} + +QString QTReader::firstword() +{ + if (m_bMonoSpaced) + { + return toQString(textarray[0]->data()); + } + else + { + int start, end, len, j; + for (j = 0; j < numlines; j++) + { + len = textarray[j]->length(); + for (start = 0; start < len && !isalpha((*textarray[j])[start]); start++); + if (start < len) break; + } + if (j < numlines) + { + QString ret = ""; + for (end = start; end < len && isalpha((*textarray[j])[end]); end++) + ret += (*textarray[j])[end]; + if (ret.isEmpty()) ret = "Current position"; + return ret; + } + else + return "Current position"; + } +} + +// +// Construct the QTReader with buttons. +// + +void QTReader::ChangeFont(int tgt) +{ + + QValueList<int>::Iterator it; + +// QValueList<int> sizes = QFontDatabase::pointSizes(m_fontname, (m_bBold) ? QFont::Bold : QFont::Normal); + QFontDatabase fdb; +/* + QStringList styles = fdb.styles(m_fontname); + for ( QStringList::Iterator it = styles.begin(); it != styles.end(); ++it ) + { + printf( "%s \n", (*it).latin1() ); + } +*/ + QValueList<int> sizes = fdb.pointSizes(m_fontname, (m_bBold) ? QString("Bold") : QString::null); + uint n = sizes.count(); + if (fontsizes != NULL) delete [] fontsizes; + fontsizes = new unsigned int[n+1]; + uint i = 0; + uint best = 0; + for (it = sizes.begin(); it != sizes.end(); it++) + { + fontsizes[i] = (*it)/10; + if (abs(tgt-fontsizes[i]) < abs(tgt-fontsizes[best])) + { + best = i; + } + i++; + } + m_textsize = best; + fontsizes[i] = 0; + setfont(NULL); + QFont font(m_fontname, fontsizes[m_textsize], (m_bBold) ? QFont::Bold : QFont::Normal ); + if (m_fm == NULL) + { + m_fm = new QFontMetrics(font); + buffdoc.setfm(m_fm); + } +} + +void QTReader::init() +{ + // setCaption( "Qt Draw Demo Application" ); + + setBackgroundColor( white ); +// QPainter p(this); +// p.setBackgroundMode( Qt::OpaqueMode ); + buffdoc.setfilter(getfilter()); + ChangeFont(m_textsize); + // setFocusPolicy(QWidget::StrongFocus); + // resize( 240, 320 ); + //setFocus(); + timer = new QTimer(this); + connect(timer, SIGNAL(timeout()), this, SLOT(doscroll())); +// QMessageBox::information(this, "init", m_lastfile, 1); + m_lastwidth = width(); + if (!m_lastfile.isEmpty()) + { + m_string = DocLnk(m_lastfile).name(); + load_file(m_lastfile); + } +} + +// +// Clean up +// +QTReader::~QTReader() +{ + if (fontsizes != NULL) delete [] fontsizes; +#ifndef QT_NO_PRINTER + // delete printer; +#endif +} + +// +// Calls the drawing function as specified by the radio buttons. +// + +void QTReader::drawIt( QPainter *p ) +{ + drawFonts(p); +} + +// +// Called when the print button is clicked. +// +/* +void QTReader::printIt() +{ +#ifndef QT_NO_PRINTER + if ( printer->setup( this ) ) { + QPainter paint; + if ( !paint.begin( printer ) ) + return; + drawIt( &paint ); + } +#endif +} +*/ +// +// Called when the widget needs to be updated. +// + +void QTReader::paintEvent( QPaintEvent * ) +{ + QPainter paint( this ); + drawIt( &paint ); +} + +// +// Called when the widget has been resized. +// Moves the button group to the upper right corner +// of the widget. + +/* +void QTReader::resizeEvent( QResizeEvent * ) +{ + // qDebug("resize:(%u,%u)", width(), height()); + // bgroup->move( width()-bgroup->width(), 0 ); +} +*/ + +// +// Create and display our widget. +// +/* +int main( int argc, tchar **argv ) +{ + QApplication app( argc, argv ); + QTReader draw; + app.setMainWidget( &draw ); + draw.setCaption("Qt Example - Drawdemo"); + draw.show(); + return app.exec(); +} +*/ + + +bool QTReader::locate(unsigned long n) { + //printf("Locate\n"); + buffdoc.locate(n); + // qDebug("&buffdoc.located"); + fillbuffer(); + // qDebug("&Buffer filled"); + update(); + // qDebug("&Located"); + return true; +} + +unsigned int QTReader::screenlines() +{ + // int linespacing = (tight) ? m_ascent : m_ascent+m_descent; + // return (height()-m_descent)/(m_linespacing); + return (height()-2)/(m_linespacing); +}; + +bool QTReader::fillbuffer() { + //printf("Fillbuffer\n"); + m_scrolldy = 0; + int ch; + bool ret = false; + int delta = screenlines(); + // qDebug("fillbuffer:%u-%u",delta,numlines); + if (delta != numlines) + { + if (textarray != NULL) + { + for (int i = 0; i < numlines; i++) delete textarray[i]; + delete [] textarray; + delete [] locnarray; + } + numlines = delta; + textarray = new CBuffer*[numlines]; + locnarray = new size_t[numlines]; + for (int i = 0; i < numlines; i++) textarray[i] = new CBuffer; + } + // qDebug("fillbuffer:pagepos:%u",pagepos); + unsigned int oldpagepos = pagepos; +// if (textarray != NULL) +// pagepos = locnarray[0]; +// else + pagepos = locate(); + for (int i = 0; i < delta; i++) + { + locnarray[i] = locate(); + ch = getline(textarray[i]); + // if (ch == EOF) { + if (!ch) + { + if (i == 0) + { + pagepos = oldpagepos; + return false; + } + else + { + ret = true; + for (int j = i+1; j < delta; j++) + { + locnarray[j] = locnarray[j-1]; + (*(textarray[j]))[0] = '\0'; + } + break; + } + } + if (ch == '\012') ret = true; + } + mylastpos = locate(); + // qDebug("fillbuffer:lastpos:%u",mylastpos); + return true; +} + + +void QTReader::dopagedn() +{ + if (m_overlap == 0) + { + if (locate() != mylastpos) jumpto(mylastpos); + } + else + { + if (m_overlap >= screenlines()) m_overlap = screenlines()/2; + jumpto(locnarray[screenlines()-m_overlap]); + } + if (fillbuffer()) + { + update(); + } +} + +void QTReader::dopageup() +{ + CBuffer** buff = textarray; + unsigned int *loc = new unsigned int[numlines]; + int cbptr = 0; + if (locate() != mylastpos) jumpto(mylastpos); + if (m_overlap >= screenlines()) m_overlap = screenlines()/2; + unsigned int target = locnarray[m_overlap]; + if (buffdoc.hasrandomaccess()) + { + unsigned int delta = locate()-pagelocate(); + if (delta < 64) delta = 64; + if (delta % 2 != 0) delta++; + if (target % 2 != 0) target++; + do + { + delta <<= 1; + if (delta >= target) + { + delta = target; + jumpto(0); + for (int i = 0; i < numlines; i++) + { + loc[i] = locate(); + getline(buff[i]); + } + break; + } + jumpto(target-delta); + do + { + getline(buff[0]); +#ifdef WS + //printf("Trying:%s\n",buff[0]); +#endif + if (locate() > target) continue; + } + while (!buffdoc.iseol()); + for (int i = 0; i < numlines; i++) + { + loc[i] = locate(); + getline(buff[i]); +#ifdef WS + //printf("Filling:%s\n",buff[i]); +#endif + } + } + while (locate() >= target && delta < 4096); +#ifdef WS + //printf("Delta:%u\n",delta); +#endif + } + else + { + jumpto(0); + for (int i = 0; i < numlines; i++) + { + loc[i] = locate(); + getline(buff[i]); + } + } + cbptr = 0; + while (locate() < target) + { + loc[cbptr] = locate(); + getline(buff[cbptr]); +#ifdef WS + //printf("Adding:%s\n",buff[cbptr]->data()); +#endif + cbptr = (cbptr+1) % numlines; + } + pagepos = loc[cbptr]; + textarray = new CBuffer*[numlines]; + for (int i = 0; i < numlines; i++) + { + int j = (cbptr+i)%numlines; + textarray[i] = buff[j]; + locnarray[i] = loc[j]; + } + delete [] buff; + delete [] loc; + mylastpos = locate(); + update(); +} + +bool QTReader::load_file(const char *newfile, unsigned int _lcn) +{ +// QMessageBox::information(this, "Name", name, 1); +// QMessageBox::information(this, "load_file", newfile, 1); + + bool bRC = false; + unsigned int lcn = _lcn; + if (m_lastfile == newfile) + { + lcn = m_lastposn; + } + m_lastfile = newfile; + // QMessageBox::information(0, "Opening...", newfile); + if (buffdoc.openfile(this,newfile) == 0) + { + bRC = true; + // qDebug("buffdoc.openfile done"); + locate(lcn); + // qDebug("buffdoc.locate done"); + } + update(); + // qDebug("Updated"); + return bRC; +} + +void QTReader::lineDown() +{ + pagepos = locnarray[1]; + CBuffer* buff = textarray[0]; + for (int i = 1; i < numlines; i++) + { + textarray[i-1] = textarray[i]; + locnarray[i-1] = locnarray[i]; + } + locnarray[numlines-1] = locate(); + if (getline(buff)) + { + textarray[numlines-1] = buff; + mylastpos = locate(); + } + else + { + textarray[numlines-1] = buff; + } + update(); +} +/* +void QTReader::lineUp() +{ + CBuffer** buff = textarray; + unsigned int *loc = new unsigned int[numlines]; + int cbptr = 0; + if (locate() != mylastpos) jumpto(mylastpos); + unsigned int target = locnarray[numlines-1]; + if (buffdoc.hasrandomaccess()) + { + unsigned int delta = locate()-pagelocate(); + if (delta < 64) delta = 64; + do + { + delta <<= 1; + if (delta >= target) + { + delta = target; + jumpto(0); + for (int i = 0; i < numlines; i++) + { + loc[i] = locate(); + getline(buff[i]); + } + break; + } + jumpto(target-delta); + do + { + buffdoc.getline(buff[0],width()); +#ifdef WS + //printf("Trying:%s\n",buff[0]); +#endif + if (locate() > target) continue; + } + while (!buffdoc.iseol()); + for (int i = 0; i < numlines; i++) + { + loc[i] = locate(); + buffdoc.getline(buff[i],width()); +#ifdef WS + //printf("Filling:%s\n",buff[i]); +#endif + } + } + while (locate() >= target && delta < 4096); +#ifdef WS + //printf("Delta:%u\n",delta); +#endif + } + else + { + jumpto(0); + for (int i = 0; i < numlines; i++) + { + loc[i] = locate(); + buffdoc.getline(buff[i],width()); + } + } + cbptr = 0; + while (locate() < target) + { + loc[cbptr] = locate(); + buffdoc.getline(buff[cbptr], width()); +#ifdef WS + //printf("Adding:%s\n",buff[cbptr]->data()); +#endif + cbptr = (cbptr+1) % numlines; + } + pagepos = loc[cbptr]; + textarray = new CBuffer*[numlines]; + for (int i = 0; i < numlines; i++) + { + int j = (cbptr+i)%numlines; + textarray[i] = buff[j]; + locnarray[i] = loc[j]; + } + delete [] buff; + delete [] loc; + mylastpos = locate(); + update(); +} +*/ +void QTReader::lineUp() +{ + CBuffer* buff = textarray[numlines-1]; + unsigned int loc; + unsigned int end = locnarray[numlines-1]; + int cbptr = 0; + if (locate() != mylastpos) jumpto(mylastpos); + unsigned int target = locnarray[0]; + if (buffdoc.hasrandomaccess()) + { + unsigned int delta = locate()-pagelocate(); + if (delta < 64) delta = 64; + do + { + delta <<= 1; + if (delta >= target) + { + delta = target; + jumpto(0); + for (int i = 0; i < numlines; i++) + { + loc = locate(); + getline(buff); + } + break; + } + jumpto(target-delta); + do + { + getline(buff); +#ifdef WS + //printf("Trying:%s\n",buff[0]); +#endif + if (locate() > target) continue; + } + while (!buffdoc.iseol()); + loc = locate(); + getline(buff); + } + while (locate() >= target && delta < 4096); + } + else + { + jumpto(0); + loc = locate(); + getline(buff); + } + cbptr = 0; + while (locate() < target) + { + loc = locate(); + getline(buff); + } + pagepos = loc; + for (int i = numlines-1; i > 0; i--) + { + textarray[i] = textarray[i-1]; + locnarray[i] = locnarray[i-1]; + } + textarray[0] = buff; + locnarray[0] = loc; +// delete [] buff; +// delete [] loc; + mylastpos = locate(); + jumpto(end); + update(); +} + +bool QTReader::empty() +{ + return buffdoc.empty(); +} diff --git a/noncore/apps/opie-reader/QTReader.h b/noncore/apps/opie-reader/QTReader.h new file mode 100644 index 0000000..2efb988 --- a/dev/null +++ b/noncore/apps/opie-reader/QTReader.h @@ -0,0 +1,217 @@ +#ifndef __QTREADER_H +#define __QTREADER_H + +#include <qwidget.h> +#include <qpainter.h> +#include <qclipboard.h> +#include "CBuffer.h" +#include "my_list.h" +#include "BuffDoc.h" +#include <qtimer.h> + +class QTReader : public QWidget +{ + Q_OBJECT + + friend class QTReaderApp; + void drawText(QPainter& p, int x, int y, tchar* text); + int m_delay; + unsigned int m_overlap; + bool m_autoScroll; + void autoscroll(); + QTimer* timer; + int m_scrolldy, m_encd; + void focusInEvent(QFocusEvent*); + void focusOutEvent(QFocusEvent*); + void ChangeFont(int); + bool getline(CBuffer*); + int m_charWidth; + int m_charpc; +public: + QTReader( QWidget *parent=0, const char *name=0, WFlags f = 0); + // QTReader( const QString& filename, QWidget *parent=0, const tchar *name=0, WFlags f = 0); + ~QTReader(); + bool empty(); + void toggle_autoscroll(); + void setautoscroll(bool); + void disableAutoscroll() { m_autoScroll = false; } + void copy() + { +/* + size_t nd = locate(); + jumpto(m_mark); + QString text; + while (m_mark < nd) + { + text += buffdoc.getch(); + m_mark++; + } + QApplication::clipboard()->setText(text); + jumpto(nd); +*/ + }; + void clear() {}; + void setText(const QString& n, const QString& s) { m_string = n; load_file((const char*)s); }; + /* + void setText(bool oldfile) + { + if (oldfile) + { + m_string = m_lastfile; + load_file((const tchar*)m_string); + } + else + { + m_string = QString::null; + } + }; + */ + void setstripcr(bool _b) + { + bstripcr = _b; + setfilter(getfilter()); + } + void setstriphtml(bool _b) + { + bstriphtml = _b; + setfilter(getfilter()); + } + void setdehyphen(bool _b) + { + bdehyphen = _b; + setfilter(getfilter()); + } + void setunindent(bool _b) + { + bunindent = _b; + setfilter(getfilter()); + } + void setrepara(bool _b) + { + brepara = _b; + setfilter(getfilter()); + } + void setdblspce(bool _b) + { + bdblspce = _b; + setfilter(getfilter()); + } + void indentplus() + { + if (bindenter < 15) bindenter += 2; + setfilter(getfilter()); + } + void indentminus() + { + if (bindenter > 1) bindenter -= 2; + setfilter(getfilter()); + } + void setpagemode(bool _b) + { + m_bpagemode = _b; + } + void setmono(bool _b) + { + m_bMonoSpaced = _b; + ChangeFont(fontsizes[m_textsize]); + locate(pagepos); + } + void setencoding(int _f) + { + m_encd = _f; + setfilter(getfilter()); + } + CEncoding* getencoding() + { + switch (m_encd) + { + case 5: + return new Ccp1252; + case 4: + return new CPalm; + case 1: + return new CUtf8; + case 2: + return new CUcs16be; + case 3: + return new CUcs16le; + case 0: + default: + return new CAscii; + } + } + CFilterChain* getfilter() + { + CFilterChain * filt = new CFilterChain(getencoding()); + if (bstripcr) filt->addfilter(new stripcr); + if (bstriphtml) filt->addfilter(new striphtml); + if (bdehyphen) filt->addfilter(new dehyphen); + if (bunindent) filt->addfilter(new unindent); + if (brepara) filt->addfilter(new repara); + if (bindenter) filt->addfilter(new indenter(bindenter)); + if (bdblspce) filt->addfilter(new dblspce); + return filt; + } + + +private slots: + void doscroll(); + void drawIt( QPainter * ); + void paintEvent( QPaintEvent * ); +// void resizeEvent( QResizeEvent * p ) { update(); } + void keyPressEvent(QKeyEvent*); + void drawFonts(QPainter*); + private: + void init(); + void mouseReleaseEvent( QMouseEvent* ); +// void mouseDoubleClickEvent( QMouseEvent* ); + QString m_string, m_fontname; + void setfont(QPainter*); + //myoutput stuff + private: + void dopageup(); + void lineDown(); + void lineUp(); + void dopagedn(); + long real_delay(); + int m_textsize; + int m_lastwidth; + CBuffer** textarray; + size_t* locnarray; + unsigned int numlines; + bool bstripcr, bstriphtml, bdehyphen, bunindent, brepara, bdblspce, btight, m_bBold; + bool m_bpagemode, m_bMonoSpaced; + QString m_targetapp, m_targetmsg; + unsigned char bindenter; + QString m_lastfile; + size_t m_lastposn; + public: + int getch() { return buffdoc.getch(); } + bool tight; + bool load_file(const char *newfile, unsigned int lcn=0); + BuffDoc buffdoc; + CList<Bkmk>* getbkmklist() { return buffdoc.getbkmklist(); } + bool locate(unsigned long n); + void jumpto(unsigned long n) { buffdoc.locate(n); } + unsigned long locate() { return buffdoc.locate(); } + unsigned long pagelocate() { return pagepos; } + unsigned long pagepos, mylastpos; + void setfilter(CFilterChain *f) { buffdoc.setfilter(f); locate(pagepos); } + void restore() { jumpto(mylastpos); } + void goUp(); + void refresh() { locate(pagepos); } + void goDown(); + // bool bold; + int textsize() { return m_textsize; } + void textsize(int ts) { m_textsize = ts; } + bool fillbuffer(); + unsigned int screenlines(); + void sizes(unsigned long& fs, unsigned long& ts) { buffdoc.sizes(fs,ts); } + static const char *fonts[]; + unsigned int *fontsizes; + int m_ascent, m_descent, m_linespacing; + QFontMetrics* m_fm; + QString firstword(); +}; + +#endif diff --git a/noncore/apps/opie-reader/QTReaderApp.cpp b/noncore/apps/opie-reader/QTReaderApp.cpp new file mode 100644 index 0000000..620e93e --- a/dev/null +++ b/noncore/apps/opie-reader/QTReaderApp.cpp @@ -0,0 +1,1433 @@ +/********************************************************************** +** Copyright (C) 2000 Trolltech AS. All rights reserved. +** +** This file is part of Qt Palmtop Environment. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#include <qwidgetstack.h> +#include <qpe/qpemenubar.h> +#include <qpe/qpetoolbar.h> +#include <qpe/fontdatabase.h> +#include <qcombobox.h> +#include <qpopupmenu.h> +#include <qaction.h> +#include <qapplication.h> +#include <qlineedit.h> +#include <qtoolbutton.h> +#include <qspinbox.h> +#include <qobjectlist.h> +#include <qpe/global.h> +#include <qpe/applnk.h> +#include <qfileinfo.h> +#include <stdlib.h> //getenv +#include <qprogressbar.h> +#include <qpe/config.h> +#include <qbuttongroup.h> +#include <qradiobutton.h> + +#include "cbkmkselector.h" +#include "infowin.h" + +//#include <qpe/fontdatabase.h> + +#include <qpe/resource.h> +#include <qpe/qpeapplication.h> + +#include "QTReaderApp.h" +#include "fileBrowser.h" + + +unsigned long QTReaderApp::m_uid = 0; + +void QTReaderApp::setScrollState(bool _b) { m_scrollButton->setOn(_b); } + +#include <unistd.h> +#include <stddef.h> +#include <dirent.h> + +void QTReaderApp::listBkmkFiles() +{ + bkmkselector->clear(); + int cnt = 0; + DIR *d; + d = opendir((const char *)Global::applicationFileName("uqtreader","")); + + while(1) + { + struct dirent* de; + struct stat buf; + de = readdir(d); + if (de == NULL) break; + + if (lstat((const char *)Global::applicationFileName("uqtreader",de->d_name),&buf) == 0 && S_ISREG(buf.st_mode)) + { + bkmkselector->insertItem(de->d_name); + cnt++; + } + } + + closedir(d); + + if (cnt > 0) + { + menu->hide(); + editBar->hide(); + if (m_fontVisible) m_fontBar->hide(); + if (regVisible) regBar->hide(); + if (searchVisible) searchBar->hide(); + m_nRegAction = cRmBkmkFile; + editorStack->raiseWidget( bkmkselector ); + } + else + QMessageBox::information(this, "QTReader", "No bookmark files"); +} + +QTReaderApp::QTReaderApp( QWidget *parent, const char *name, WFlags f ) + : QMainWindow( parent, name, f ), bFromDocView( FALSE ) +{ +// qDebug("Application directory = %s", (const tchar *)QPEApplication::documentDir()); +// qDebug("Application directory = %s", (const tchar *)Global::applicationFileName("uqtreader","bkmks.xml")); + + pBkmklist = NULL; + doc = 0; + + m_fBkmksChanged = false; + + QString lang = getenv( "LANG" ); + + m_autogenstr = "^ *[A-Z].*[a-z] *$"; + setToolBarsMovable( FALSE ); + + setIcon( Resource::loadPixmap( "uqtreader" ) ); + + QPEToolBar *bar = new QPEToolBar( this ); + bar->setHorizontalStretchable( TRUE ); + addToolBar(bar, "tool",QMainWindow::Top, true); + menu = bar; + + QPEMenuBar *mb = new QPEMenuBar( bar ); + QPopupMenu *file = new QPopupMenu( this ); + QPopupMenu *format = new QPopupMenu( this ); + // QPopupMenu *edit = new QPopupMenu( this ); + +// bar = new QToolBar( this ); + editBar = bar; + + /* + QAction *a = new QAction( tr( "New" ), Resource::loadPixmap( "new" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( fileNew() ) ); + a->addTo( bar ); + a->addTo( file ); + */ + + editorStack = new QWidgetStack( this ); + setCentralWidget( editorStack ); + + searchVisible = FALSE; + regVisible = FALSE; + m_fontVisible = false; + + pbar = new QProgressBar(this); + pbar->hide(); + + m_infoWin = new infowin(editorStack); + editorStack->addWidget(m_infoWin, get_unique_id()); + connect( m_infoWin, SIGNAL( Close() ), this, SLOT( infoClose() ) ); + +// bkmkselector = new QListBox(editorStack, "Bookmarks"); + bkmkselector = new CBkmkSelector(editorStack, "Bookmarks"); + // connect(bkmkselector, SIGNAL( selected(const QString&) ), this, SLOT( gotobkmk(const QString&) ) ); + connect(bkmkselector, SIGNAL( selected(int) ), this, SLOT( gotobkmk(int) ) ); + connect(bkmkselector, SIGNAL( cancelled() ), this, SLOT( cancelbkmk() ) ); + editorStack->addWidget( bkmkselector, get_unique_id() ); + +/* + importSelector = new FileSelector( "*", editorStack, "importselector", false ); + connect( importSelector, SIGNAL( fileSelected( const DocLnk &) ), this, SLOT( importFile( const DocLnk & ) ) ); + + editorStack->addWidget( importSelector, get_unique_id() ); + + // don't need the close visible, it is redundant... + importSelector->setCloseVisible( FALSE ); +*/ + + reader = new QTReader( editorStack ); + Config config( "uqtreader" ); + config.setGroup( "View" ); + + reader->bstripcr = config.readBoolEntry( "StripCr", true ); + reader->bstriphtml = config.readBoolEntry( "StripHtml", false ); + reader->bdehyphen = config.readBoolEntry( "Dehyphen", false ); + reader->bunindent = config.readBoolEntry( "Unindent", false ); + reader->brepara = config.readBoolEntry( "Repara", false ); + reader->bdblspce = config.readBoolEntry( "DoubleSpace", false ); + reader->bindenter = config.readNumEntry( "Indent", 0 ); + reader->m_textsize = config.readNumEntry( "FontSize", 12 ); + reader->m_bBold = config.readBoolEntry( "Bold", false ); + reader->m_delay = config.readNumEntry( "ScrollDelay", 5184); + reader->m_lastfile = config.readEntry( "LastFile", QString::null ); + reader->m_lastposn = config.readNumEntry( "LastPosn", 0 ); + reader->m_bpagemode = config.readBoolEntry( "PageMode", true ); + reader->m_bMonoSpaced = config.readBoolEntry( "MonoSpaced", false); + reader->m_fontname = config.readEntry( "Fontname", "helvetica" ); + reader->m_encd = config.readNumEntry( "Encoding", 0 ); + reader->m_charpc = config.readNumEntry( "CharSpacing", 100 ); + reader->m_overlap = config.readNumEntry( "Overlap", 0 ); + reader->m_targetapp = config.readEntry( "TargetApp", QString::null ); + reader->m_targetmsg = config.readEntry( "TargetMsg", QString::null ); + reader->init(); + editorStack->addWidget( reader, get_unique_id() ); + + QAction *a = new QAction( tr( "Open" ), Resource::loadPixmap( "fileopen" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( fileOpen() ) ); + a->addTo( bar ); + a->addTo( file ); + + /* + a = new QAction( tr( "Revert" ), Resource::loadPixmap( "close" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( fileRevert() ) ); + a->addTo( file ); + + a = new QAction( tr( "Cut" ), Resource::loadPixmap( "cut" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( editCut() ) ); + a->addTo( editBar ); + a->addTo( edit ); + */ + + a = new QAction( tr( "Info" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( showinfo() ) ); + a->addTo( file ); + + a = new QAction( tr( "Start Block" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( editMark() ) ); + file->insertSeparator(); + a->addTo( file ); + + a = new QAction( tr( "Copy Block" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( editCopy() ) ); + a->addTo( file ); + + a = m_scrollButton = new QAction( tr( "Scroll" ), Resource::loadPixmap( "panel-arrow-down" ), QString::null, 0, this, 0, true ); +// connect( a, SIGNAL( activated() ), this, SLOT( autoScroll() ) ); + a->setOn(false); + connect( a, SIGNAL( toggled(bool) ), this, SLOT( autoScroll(bool) ) ); + file->insertSeparator(); + a->addTo( bar ); + a->addTo( file ); + + /* + a = new QAction( tr( "Find" ), QString::null, 0, this, NULL, true ); + // connect( a, SIGNAL( activated() ), this, SLOT( pagedn() ) ); + a->addTo( file ); + + a = new QAction( tr( "Find Again" ), QString::null, 0, this, NULL, true ); + // connect( a, SIGNAL( activated() ), this, SLOT( pagedn() ) ); + a->addTo( file ); + */ + a = new QAction( tr( "Jump" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( jump() ) ); + a->addTo( file ); + + a = new QAction( tr( "Page/Line scroll" ), QString::null, 0, this, NULL, true ); + connect( a, SIGNAL( toggled(bool) ), this, SLOT( pagemode(bool) ) ); + a->setOn(reader->m_bpagemode); + a->addTo( file ); + + a = new QAction( tr( "Set Overlap" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( setoverlap() ) ); + a->addTo( file ); + + a = new QAction( tr( "Set Dictionary" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( settarget() ) ); + a->addTo( file ); + +/* + a = new QAction( tr( "Import" ), QString::null, 0, this, NULL ); + connect( a, SIGNAL( activated() ), this, SLOT( importFiles() ) ); + a->addTo( file ); +*/ + + a = new QAction( tr( "Up" ), Resource::loadPixmap( "up" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( pageup() ) ); + a->addTo( editBar ); + + a = new QAction( tr( "Down" ), Resource::loadPixmap( "down" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( pagedn() ) ); + a->addTo( editBar ); + + /* + a = new QAction( tr( "Paste" ), Resource::loadPixmap( "paste" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( editPaste() ) ); + a->addTo( editBar ); + a->addTo( edit ); + */ + + a = new QAction( tr( "Find..." ), Resource::loadPixmap( "find" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( editFind() ) ); + file->insertSeparator(); + a->addTo( bar ); + a->addTo( file ); + + + a = new QAction( tr( "Strip CR" ), QString::null, 0, this, NULL, true ); + a->setOn(reader->bstripcr); + connect( a, SIGNAL( toggled(bool) ), this, SLOT( stripcr(bool) ) ); + a->addTo( format ); + // a->setOn(true); + + a = new QAction( tr( "Strip HTML" ), QString::null, 0, this, NULL, true ); + a->setOn(reader->bstriphtml); + connect( a, SIGNAL( toggled(bool) ), this, SLOT( striphtml(bool) ) ); + a->addTo( format ); + + a = new QAction( tr( "Dehyphen" ), QString::null, 0, this, NULL, true ); + a->setOn(reader->bdehyphen); + connect( a, SIGNAL( toggled(bool) ), this, SLOT( dehyphen(bool) ) ); + a->addTo( format ); + + a = new QAction( tr( "Unindent" ), QString::null, 0, this, NULL, true ); + connect( a, SIGNAL( toggled(bool) ), this, SLOT( unindent(bool) ) ); + a->setOn(reader->bunindent); + a->addTo( format ); + + a = new QAction( tr( "Re-paragraph" ), QString::null, 0, this, NULL, true ); + connect( a, SIGNAL( toggled(bool) ), this, SLOT( repara(bool) ) ); + a->setOn(reader->brepara); + a->addTo( format ); + + a = new QAction( tr( "Double Space" ), QString::null, 0, this, NULL, true ); + connect( a, SIGNAL( toggled(bool) ), this, SLOT( dblspce(bool) ) ); + a->setOn(reader->bdblspce); + a->addTo( format ); + + a = new QAction( tr( "Indent+" ), QString::null, 0, this, NULL ); + connect( a, SIGNAL( activated() ), this, SLOT( indentplus() ) ); + a->addTo( format ); + + a = new QAction( tr( "Indent-" ), QString::null, 0, this, NULL ); + connect( a, SIGNAL( activated() ), this, SLOT( indentminus() ) ); + a->addTo( format ); + + a = new QAction( tr( "Bold" ), QString::null, 0, this, NULL, true ); + a->setOn(reader->m_bBold); + connect( a, SIGNAL( toggled(bool) ), this, SLOT( setbold(bool) ) ); + a->addTo( format ); + + // a = new QAction( tr( "Zoom" ), QString::null, 0, this, NULL, true ); + // a = new QAction( tr( "Zoom" ), Resource::loadPixmap( "mag" ), QString::null, 0, this, 0 ); + a = new QAction( tr( "Zoom" ), QString::null, 0, this); + connect( a, SIGNAL( activated() ), this, SLOT( TBDzoom() ) ); + format->insertSeparator(); + a->addTo( format ); + // a->addTo( editBar ); + + + a = new QAction( tr( "Ideogram/Word" ), QString::null, 0, this, NULL, true ); + connect( a, SIGNAL( toggled(bool) ), this, SLOT( monospace(bool) ) ); + a->setOn(reader->m_bMonoSpaced); + format->insertSeparator(); + a->addTo( format ); + + a = new QAction( tr( "Set width" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( setspacing() ) ); + a->addTo( format ); + + QPopupMenu *encoding = new QPopupMenu(this); + format->insertSeparator(); + format->insertItem( tr( "Encoding" ), encoding ); + + QActionGroup* ag = new QActionGroup(this); + + m_EncodingAction[0] = new QAction( tr( "Ascii" ), QString::null, 0, ag, NULL, true ); + + m_EncodingAction[1] = new QAction( tr( "UTF-8" ), QString::null, 0, ag, NULL, true ); + + m_EncodingAction[2] = new QAction( tr( "UCS-2(BE)" ), QString::null, 0, ag, NULL, true ); + + m_EncodingAction[3] = new QAction( tr( "USC-2(LE)" ), QString::null, 0, ag, NULL, true ); + + m_EncodingAction[4] = new QAction( tr( "Palm" ), QString::null, 0, ag, NULL, true ); + + m_EncodingAction[5] = new QAction( tr( "Windows(1252)" ), QString::null, 0, ag, NULL, true ); + + ag->addTo(encoding); + + connect(ag, SIGNAL( selected(QAction*) ), this, SLOT( encodingSelected(QAction*) ) ); + + a = new QAction( tr( "Set Font" ), QString::null, 0, this); + connect( a, SIGNAL( activated() ), this, SLOT( setfont() ) ); + format->insertSeparator(); + a->addTo( format ); + + QPopupMenu *marks = new QPopupMenu( this ); + + a = new QAction( tr( "Mark" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( addbkmk() ) ); + a->addTo( marks ); + + a = new QAction( tr( "Goto" ), QString::null, 0, this, NULL, false ); + connect( a, SIGNAL( activated() ), this, SLOT( do_gotomark() ) ); + a->addTo( marks ); + + a = new QAction( tr( "Delete" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( do_delmark() ) ); + a->addTo( marks ); + + a = new QAction( tr( "Autogen" ), QString::null, 0, this, NULL, false ); + connect( a, SIGNAL( activated() ), this, SLOT( do_autogen() ) ); + marks->insertSeparator(); + a->addTo( marks ); + + a = new QAction( tr( "Clear" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( clearBkmkList() ) ); + a->addTo( marks ); + + a = new QAction( tr( "Save" ), QString::null, 0, this, NULL ); + connect( a, SIGNAL( activated() ), this, SLOT( savebkmks() ) ); + a->addTo( marks ); + + a = new QAction( tr( "Tidy" ), QString::null, 0, this, NULL); + connect( a, SIGNAL( activated() ), this, SLOT( listBkmkFiles() ) ); + marks->insertSeparator(); + a->addTo( marks ); + + mb->insertItem( tr( "File" ), file ); + // mb->insertItem( tr( "Edit" ), edit ); + mb->insertItem( tr( "Format" ), format ); + mb->insertItem( tr( "Marks" ), marks ); + + searchBar = new QToolBar( "Search", this, QMainWindow::Top, TRUE ); + + searchBar->setHorizontalStretchable( TRUE ); + + searchEdit = new QLineEdit( searchBar, "searchEdit" ); +// QFont f("unifont", 16 /*, QFont::Bold*/); +// searchEdit->setFont( f ); + searchBar->setStretchableWidget( searchEdit ); +#ifdef __ISEARCH + connect( searchEdit, SIGNAL( textChanged( const QString & ) ), + this, SLOT( search( const QString& ) ) ); +#else + connect( searchEdit, SIGNAL( returnPressed( ) ), + this, SLOT( search( ) ) ); +#endif + a = new QAction( tr( "Find Next" ), Resource::loadPixmap( "next" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( findNext() ) ); + a->addTo( searchBar ); + + a = new QAction( tr( "Close Find" ), Resource::loadPixmap( "close" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( findClose() ) ); + a->addTo( searchBar ); + + searchBar->hide(); + + regBar = new QToolBar( "Autogen", this, QMainWindow::Top, TRUE ); + + regBar->setHorizontalStretchable( TRUE ); + + regEdit = new QLineEdit( regBar, "regEdit" ); +// regEdit->setFont( f ); + + regBar->setStretchableWidget( regEdit ); + + connect( regEdit, SIGNAL( returnPressed( ) ), + this, SLOT( do_regaction() ) ); + + a = new QAction( tr( "Do Reg" ), Resource::loadPixmap( "enter" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( do_regaction() ) ); + a->addTo( regBar ); + + a = new QAction( tr( "Close Edit" ), Resource::loadPixmap( "close" ), QString::null, 0, this, 0 ); + connect( a, SIGNAL( activated() ), this, SLOT( regClose() ) ); + a->addTo( regBar ); + + regBar->hide(); + + m_fontBar = new QToolBar( "Autogen", this, QMainWindow::Top, TRUE ); + + m_fontBar->setHorizontalStretchable( TRUE ); + + m_fontSelector = new QComboBox(false, m_fontBar); + m_fontBar->setStretchableWidget( m_fontSelector ); + { + FontDatabase f; + m_fontSelector->insertStringList(f.families()); + } // delete the FontDatabase!!! + connect( m_fontSelector, SIGNAL( activated(const QString& ) ), + this, SLOT( do_setfont(const QString&) ) ); + + m_fontBar->hide(); + m_fontVisible = false; + + connect(qApp, SIGNAL( appMessage(const QCString&, const QByteArray& ) ), + this, SLOT( msgHandler(const QCString&, const QByteArray&) ) ); + + + if (!reader->m_lastfile.isEmpty()) + { + openFile( reader->m_lastfile ); + doc = new DocLnk(reader->m_lastfile); + } + m_EncodingAction[reader->m_encd]->setOn(true); + do_setfont(reader->m_fontname); +} + +void QTReaderApp::msgHandler(const QCString& _msg, const QByteArray& _data) +{ + QString msg = QString::fromUtf8(_msg); + +// qDebug("Received:%s", (const char*)msg); + + QDataStream stream( _data, IO_ReadOnly ); + if ( msg == "info(QString)" ) + { + QString info; + stream >> info; + QMessageBox::information(this, "QTReader", info); + } else if ( msg == "warn(QString)" ) + { + QString info; + stream >> info; + QMessageBox::warning(this, "QTReader", info); + } +} + +int QTReaderApp::EncNameToInt(const QString& _enc) +{ + for (int i = 0; i < MAX_ENCODING; i++) + { + if (m_EncodingAction[i]->text() == _enc) return i; + } + return 0; +/* + if (_enc == "Ascii") return 0; + if (_enc == "UTF-8") return 1; + if (_enc == "UCS-2(BE)") return 2; + if (_enc == "USC-2(LE)") return 3; +*/ +} + +void QTReaderApp::encodingSelected(QAction* _a) +{ +// qDebug("es:%x : %s", _a, (const char *)(_a->text())); + reader->setencoding(EncNameToInt(_a->text())); +} + +QTReaderApp::~QTReaderApp() +{ +} + +void QTReaderApp::autoScroll(bool _b) +{ + reader->setautoscroll(_b); +} + +void QTReaderApp::TBD() +{ + QMessageBox::information(this, "QTReader", "Not yet implemented", 1); +} + +void QTReaderApp::TBDzoom() +{ + QMessageBox::information(this, "QTReader", "Zooming is done interactively\nTry left/right cursor keys", 1); +} + +void QTReaderApp::clearBkmkList() +{ + delete pBkmklist; + pBkmklist = NULL; + m_fBkmksChanged = false; +} + +void QTReaderApp::fileOpen() +{ +/* + menu->hide(); + editBar->hide(); + if (regVisible) regBar->hide(); + if (searchVisible) searchBar->hide(); +*/ + if (pBkmklist != NULL) + { + if (m_fBkmksChanged) + { + if (QMessageBox::warning(this, "QTReader", "Save bookmarks?", "Save", "Don't bother") == 0) + savebkmks(); + } + delete pBkmklist; + pBkmklist = NULL; + m_fBkmksChanged = false; + } + reader->disableAutoscroll(); +/* + editorStack->raiseWidget( fileSelector ); + fileSelector->reread(); +*/ + fileBrowser* fb = new fileBrowser(this,"QTReader",TRUE, + 0, +// WStyle_Customize | WStyle_NoBorderEx, + "*", QFileInfo(reader->m_lastfile).dirPath(true)); + + if (fb->exec()) + { + QString fn(fb->fileList[0]); +// fb->populateList(); + if (!fn.isEmpty() && QFileInfo(fn).isFile()) openFile(fn); + } + delete fb; +} + +void QTReaderApp::showinfo() +{ + unsigned long fs, ts, pl; + if (reader->empty()) + { + QMessageBox::information(this, "QTReader", "No file loaded", 1); + } + else + { + reader->sizes(fs,ts); + pl = reader->pagelocate(); + m_infoWin->setFileSize(fs); + m_infoWin->setTextSize(ts); + m_infoWin->setRatio(100-(100*fs + (ts >> 1))/ts); + m_infoWin->setLocation(pl); + m_infoWin->setRead((100*pl + (ts >> 1))/ts); + editorStack->raiseWidget( m_infoWin ); + m_infoWin->setFocus(); + } +} + +void QTReaderApp::infoClose() +{ + showEditTools(); +} + +/* +void QTReaderApp::fileRevert() +{ + clear(); + fileOpen(); +} + +void QTReaderApp::editCut() +{ +#ifndef QT_NO_CLIPBOARD + editor->cut(); +#endif +} +*/ +void QTReaderApp::editMark() +{ + m_savedpos = reader->pagelocate(); +} + +void QTReaderApp::editCopy() +{ + QClipboard* cb = QApplication::clipboard(); + QString text; + int ch; + unsigned long currentpos = reader->pagelocate(); + unsigned long endpos = reader->locate(); + reader->jumpto(m_savedpos); + while (reader->locate() < endpos && (ch = reader->getch()) != UEOF) + { + text += ch; + } + cb->setText(text); +// text = cb->text(); +// if (text) +// qDebug("The clipboard contains: %s", (const tchar*)text); + reader->locate(currentpos); +#ifndef QT_NO_CLIPBOARD +// TBD(); + // reader->copy(); +#endif +} + +void QTReaderApp::pageup() +{ + reader->goUp(); +} + +void QTReaderApp::pagedn() +{ + reader->goDown(); +} + +void QTReaderApp::stripcr(bool _b) +{ + reader->setstripcr(_b); +} +void QTReaderApp::striphtml(bool _b) +{ + reader->setstriphtml(_b); +} +void QTReaderApp::dehyphen(bool _b) +{ + reader->setdehyphen(_b); +} +void QTReaderApp::unindent(bool _b) +{ + reader->setunindent(_b); +} +void QTReaderApp::repara(bool _b) +{ + reader->setrepara(_b); +} +void QTReaderApp::setbold(bool _b) +{ + reader->m_bBold = _b; + reader->ChangeFont(reader->fontsizes[reader->m_textsize]); + reader->refresh(); +} +void QTReaderApp::dblspce(bool _b) +{ + reader->setdblspce(_b); +} +void QTReaderApp::pagemode(bool _b) +{ + reader->setpagemode(_b); +} + +void QTReaderApp::monospace(bool _b) +{ + reader->setmono(_b); +} + +void QTReaderApp::setspacing() +{ + m_nRegAction = cMonoSpace; + char lcn[20]; + sprintf(lcn, "%lu", reader->m_charpc); + regEdit->setText(lcn); + do_regedit(); +} + +void QTReaderApp::setoverlap() +{ + m_nRegAction = cOverlap; + char lcn[20]; + sprintf(lcn, "%lu", reader->m_overlap); + regEdit->setText(lcn); + do_regedit(); +} + +void QTReaderApp::settarget() +{ + m_nRegAction = cSetTarget; + QString text = ((reader->m_targetapp.isEmpty()) ? QString("") : reader->m_targetapp) + + "/" + + ((reader->m_targetmsg.isEmpty()) ? QString("") : reader->m_targetmsg); + regEdit->setText(text); + do_regedit(); +} + +void QTReaderApp::do_overlap(const QString& lcn) +{ + bool ok; + unsigned long ulcn = lcn.toULong(&ok); + if (ok) + { + reader->m_overlap = ulcn; + } + else + QMessageBox::information(this, "QTReader", "Must be a number"); +} + +void QTReaderApp::do_mono(const QString& lcn) +{ + bool ok; + unsigned long ulcn = lcn.toULong(&ok); + if (ok) + { + reader->m_charpc = ulcn; +// reader->setmono(true); + } + else + QMessageBox::information(this, "QTReader", "Must be a number"); +} + +/* +void QTReaderApp::editPaste() +{ +#ifndef QT_NO_CLIPBOARD + editor->paste(); +#endif +} +*/ + +void QTReaderApp::editFind() +{ + searchStart = reader->pagelocate(); +#ifdef __ISEARCH + searchStack = new QStack<searchrecord>; +#endif + searchBar->show(); + searchVisible = TRUE; + searchEdit->setFocus(); +#ifdef __ISEARCH + searchStack->push(new searchrecord("",reader->pagelocate())); +#endif +} + +void QTReaderApp::findNext() +{ + // qDebug("findNext called\n"); +#ifdef __ISEARCH + QString arg = searchEdit->text(); +#else + QRegExp arg = searchEdit->text(); +#endif + CBuffer test; + size_t start = reader->pagelocate(); + reader->jumpto(start); + reader->buffdoc.getline(&test,reader->width()); + dosearch(start, test, arg); +} + +void QTReaderApp::findClose() +{ + searchVisible = FALSE; + searchEdit->setText(""); + searchBar->hide(); +#ifdef __ISEARCH +// searchStack = new QStack<searchrecord>; + while (!searchStack->isEmpty()) + { + delete searchStack->pop(); + } + delete searchStack; +#endif + reader->setFocus(); +} + +void QTReaderApp::regClose() +{ + regVisible = FALSE; + regEdit->setText(""); + regBar->hide(); + reader->setFocus(); +} + +#ifdef __ISEARCH +bool QTReaderApp::dosearch(size_t start, CBuffer& test, const QString& arg) +#else +bool QTReaderApp::dosearch(size_t start, CBuffer& test, const QRegExp& arg) +#endif +{ + bool ret = true; + size_t pos = start; + reader->buffdoc.getline(&test,reader->width()); +#ifdef __ISEARCH + while (strstr(test.data(),(const tchar*)arg) == NULL) +#else +#ifdef _UNICODE + while (arg.match(toQString(test.data())) == -1) +#else + while (arg.match(test.data()) == -1) +#endif +#endif + { + pos = reader->locate(); + if (!reader->buffdoc.getline(&test,reader->width())) + { + if (QMessageBox::warning(this, "Can't find", searchEdit->text(), 1, 2) == 2) + pos = searchStart; + else + pos = start; + ret = false; + findClose(); + break; + } + } + reader->locate(pos); + return ret; +} + +#ifdef __ISEARCH +void QTReaderApp::search(const QString & arg) +{ + searchrecord* ss = searchStack->top(); + CBuffer test; + size_t start = reader->pagelocate(); + bool haspopped = false; + while (arg.left(ss->s.length()) != ss->s) + { + haspopped = true; + start = ss->pos; +// reader->locate(start); + searchStack->pop(); + delete ss; + } + if (haspopped) reader->locate(start); +/* + if (arg.length() < ss->len) + { + start = ss->pos; + reader->locate(start); + searchStack->pop(); + delete ss; + } +*/ + else + { + start = reader->pagelocate(); + reader->jumpto(start); + searchStack->push(new searchrecord(arg,start)); + } + dosearch(start, test, arg); +} +#else +void QTReaderApp::search() +{ + QRegExp arg = searchEdit->text(); + CBuffer test; + size_t start = reader->pagelocate(); +// reader->jumpto(start); + dosearch(start, test, arg); +} +#endif + +void QTReaderApp::openFile( const QString &f ) +{ + openFile(DocLnk(f)); +} + +void QTReaderApp::openFile( const DocLnk &f ) +{ + clear(); + FileManager fm; + if ( fm.exists( f ) ) + { +// QMessageBox::information(0, "Progress", "Calling fileNew()"); + + clear(); + + // editorStack->raiseWidget( reader ); + + // reader->setFocus(); + + // QMessageBox::information(0, "DocLnk", "Begin"); + doc = new DocLnk(f); + // QMessageBox::information(0, "DocLnk done", doc->file()); + // QMessageBox::information(0, "Progress", "Calling setText()"); + // QMessageBox::information(0, "Progress", "Textset"); + + // updateCaption(); + showEditTools(); + reader->setText(doc->name(), doc->file()); + readbkmks(); + } + else + { + QMessageBox::information(this, "QTReader", "File does not exist"); + } + +} + +void QTReaderApp::showEditTools() +{ + if ( !doc ) + close(); +// fileSelector->hide(); + menu->show(); + editBar->show(); + if ( searchVisible ) + searchBar->show(); + if ( regVisible ) + regBar->show(); + if (m_fontVisible) m_fontBar->show(); + + updateCaption(); + editorStack->raiseWidget( reader ); + reader->setFocus(); +} +/* +void QTReaderApp::save() +{ + if ( !doc ) + return; + if ( !editor->edited() ) + return; + + QString rt = editor->text(); + QString pt = rt; + + if ( doc->name().isEmpty() ) { + unsigned ispace = pt.find( ' ' ); + unsigned ienter = pt.find( '\n' ); + int i = (ispace < ienter) ? ispace : ienter; + QString docname; + if ( i == -1 ) { + if ( pt.isEmpty() ) + docname = "Empty Text"; + else + docname = pt; + } else { + docname = pt.left( i ); + } + doc->setName(docname); + } + FileManager fm; + fm.saveFile( *doc, rt ); +} +*/ + +void QTReaderApp::clear() +{ + if (doc != 0) + { +// QMessageBox::information(this, "QTReader", "Deleting doc", 1); + delete doc; +// QMessageBox::information(this, "QTReader", "Deleted doc", 1); + doc = 0; + } + reader->clear(); +} + +void QTReaderApp::updateCaption() +{ + if ( !doc ) + setCaption( tr("QTReader") ); + else { + QString s = doc->name(); + if ( s.isEmpty() ) + s = tr( "Unnamed" ); + setCaption( s + " - " + tr("QTReader") ); + } +} + +void QTReaderApp::setDocument(const QString& fileref) +{ + bFromDocView = TRUE; +//QMessageBox::information(0, "setDocument", fileref); + openFile(DocLnk(fileref)); +// showEditTools(); +} + +void QTReaderApp::closeEvent( QCloseEvent *e ) +{ + if (editorStack->visibleWidget() == reader) + { + if (m_fontVisible) + { + m_fontBar->hide(); + m_fontVisible = false; + } + if (regVisible) + { + regBar->hide(); + regVisible = false; + return; + } + if (searchVisible) + { + searchBar->hide(); + searchVisible = false; + return; + } + if (m_fBkmksChanged && pBkmklist != NULL) + { + if (QMessageBox::warning(this, "QTReader", "Save bookmarks?", "Save", "Don't bother") == 0) + savebkmks(); + delete pBkmklist; + pBkmklist = NULL; + m_fBkmksChanged = false; + } + bFromDocView = FALSE; + saveprefs(); + e->accept(); + } + else + { + showEditTools(); + } +} + +void QTReaderApp::do_gotomark() +{ + m_nRegAction = cGotoBkmk; + listbkmk(); +} + +void QTReaderApp::do_delmark() +{ + m_nRegAction = cDelBkmk; + listbkmk(); +} + +void QTReaderApp::listbkmk() +{ + bkmkselector->clear(); + int cnt = 0; + if (pBkmklist != NULL) + { + if (m_fBkmksChanged) pBkmklist->sort(); + for (CList<Bkmk>::iterator i = pBkmklist->begin(); i != pBkmklist->end(); i++) + { +#ifdef _UNICODE + bkmkselector->insertItem(toQString(i->name())); +#else + bkmkselector->insertItem(i->name()); +#endif + cnt++; + } + } + if (cnt > 0) + { + menu->hide(); + editBar->hide(); + if (m_fontVisible) m_fontBar->hide(); + if (regVisible) regBar->hide(); + if (searchVisible) searchBar->hide(); + editorStack->raiseWidget( bkmkselector ); + } + else + QMessageBox::information(this, "QTReader", "No bookmarks in memory"); +} + +void QTReaderApp::do_autogen() +{ + m_nRegAction = cAutoGen; + regEdit->setText(m_autogenstr); + do_regedit(); +} + +void QTReaderApp::do_regedit() +{ +// editBar->hide(); + regBar->show(); + regVisible = true; + regEdit->setFocus(); +} + +void QTReaderApp::gotobkmk(int ind) +{ + switch (m_nRegAction) + { + case cGotoBkmk: + reader->locate((*pBkmklist)[ind]->value()); + break; + case cDelBkmk: +// qDebug("Deleting:%s\n",(*pBkmklist)[ind]->name()); + pBkmklist->erase(ind); + m_fBkmksChanged = true; + break; + case cRmBkmkFile: + unlink((const char *)Global::applicationFileName("uqtreader",bkmkselector->text(ind))); + break; + } + showEditTools(); +} + +void QTReaderApp::cancelbkmk() +{ + showEditTools(); +} + +void QTReaderApp::jump() +{ + m_nRegAction = cJump; + char lcn[20]; + sprintf(lcn, "%lu", reader->pagelocate()); + regEdit->setText(lcn); + do_regedit(); +} + +void QTReaderApp::do_jump(const QString& lcn) +{ + bool ok; + unsigned long ulcn = lcn.toULong(&ok); + if (ok) + reader->locate(ulcn); + else + QMessageBox::information(this, "QTReader", "Must be a number"); +} + +void QTReaderApp::do_regaction() +{ + regBar->hide(); + regVisible = false; + switch(m_nRegAction) + { + case cAutoGen: + do_autogen(regEdit->text()); + break; + case cAddBkmk: + do_addbkmk(regEdit->text()); + break; + case cJump: + do_jump(regEdit->text()); + break; + case cMonoSpace: + do_mono(regEdit->text()); + break; + case cOverlap: + do_overlap(regEdit->text()); + break; + case cSetTarget: + do_settarget(regEdit->text()); + break; + } + reader->restore(); +// editBar->show(); + reader->setFocus(); +} + +void QTReaderApp::do_settarget(const QString& _txt) +{ + int ind = _txt.find('/'); + if (ind == -1) + { + reader->m_targetapp = ""; + reader->m_targetmsg = ""; + QMessageBox::information(this, "QTReader", "Format is\nappname/messagename"); + } + else + { + reader->m_targetapp = _txt.left(ind); + reader->m_targetmsg = _txt.right(_txt.length()-ind-1); + } +} + +void QTReaderApp::setfont() +{ + for (int i = 1; i <= m_fontSelector->count(); i++) + { + if (m_fontSelector->text(i) == reader->m_fontname) + { + m_fontSelector->setCurrentItem(i); + break; + } + } + m_fontBar->show(); + m_fontVisible = true; +} + +void QTReaderApp::do_setfont(const QString& lcn) +{ + QFont f(lcn, 10 /*, QFont::Bold*/); + bkmkselector->setFont( f ); + regEdit->setFont( f ); + searchEdit->setFont( f ); + reader->m_fontname = lcn; + reader->ChangeFont(reader->fontsizes[reader->m_textsize]); + reader->refresh(); + m_fontBar->hide(); + m_fontVisible = false; + showEditTools(); +} + +void QTReaderApp::do_autogen(const QString& regText) +{ + unsigned long fs, ts; + reader->sizes(fs,ts); + // qDebug("Reg:%s\n", (const tchar*)(regEdit->text())); + m_autogenstr = regText; + QRegExp re(regText); + CBuffer buff; + if (pBkmklist != NULL) delete pBkmklist; + pBkmklist = new CList<Bkmk>; + m_fBkmksChanged = true; + pbar->show(); +pbar->resize(width(), editBar->height()); + pbar->reset(); + qApp->processEvents(); + reader->setFocus(); + reader->jumpto(0); + int lastpc = 0; + int i = 0; + while (i >= 0) + { + unsigned int lcn = reader->locate(); + int pc = (100*lcn)/ts; + if (pc != lastpc) + { + pbar->setProgress(pc); + qApp->processEvents(); + if (reader->locate() != lcn) reader->jumpto(lcn); + reader->setFocus(); + lastpc = pc; + } + i = reader->buffdoc.getpara(buff); +#ifdef _UNICODE + if (re.match(toQString(buff.data())) != -1) +#else + if (re.match(buff.data()) != -1) +#endif + pBkmklist->push_back(Bkmk(buff.data(),lcn)); + } + pbar->setProgress(100); + qApp->processEvents(); + pbar->hide(); +} + +void QTReaderApp::saveprefs() +{ +// reader->saveprefs("uqtreader"); + Config config( "uqtreader" ); + config.setGroup( "View" ); + + reader->m_lastposn = reader->pagelocate(); + + config.writeEntry( "StripCr", reader->bstripcr ); + config.writeEntry( "StripHtml", reader->bstriphtml ); + config.writeEntry( "Dehyphen", reader->bdehyphen ); + config.writeEntry( "Unindent", reader->bunindent ); + config.writeEntry( "Repara", reader->brepara ); + config.writeEntry( "DoubleSpace", reader->bdblspce ); + config.writeEntry( "Indent", reader->bindenter ); + config.writeEntry( "FontSize", (int)(reader->fontsizes[reader->m_textsize]) ); + config.writeEntry( "Bold", reader->m_bBold ); + config.writeEntry( "ScrollDelay", reader->m_delay); + config.writeEntry( "LastFile", reader->m_lastfile ); + config.writeEntry( "LastPosn", (int)(reader->pagelocate()) ); + config.writeEntry( "PageMode", reader->m_bpagemode ); + config.writeEntry( "MonoSpaced", reader->m_bMonoSpaced ); + config.writeEntry( "Fontname", reader->m_fontname ); + config.writeEntry( "Encoding", reader->m_encd ); + config.writeEntry( "CharSpacing", reader->m_charpc ); + config.writeEntry( "Overlap", (int)(reader->m_overlap) ); + config.writeEntry( "TargetApp", reader->m_targetapp ); + config.writeEntry( "TargetMsg", reader->m_targetmsg ); +} + +void QTReaderApp::indentplus() +{ + reader->indentplus(); +} + +void QTReaderApp::indentminus() +{ + reader->indentminus(); +} + +/* +void QTReaderApp::oldFile() +{ + qDebug("oldFile called"); + reader->setText(true); + qDebug("settext called"); + showEditTools(); + qDebug("showedit called"); +} +*/ + +/* +void info_cb(Fl_Widget* o, void* _data) +{ + + if (infowin == NULL) + { + + infowin = new Fl_Window(160,240); + filename = new Fl_Output(45,5,110,14,"Filename"); + filesize = new Fl_Output(45,25,110,14,"Filesize"); + textsize = new Fl_Output(45,45,110,14,"Textsize"); + comprat = new CBar(45,65,110,14,"Ratio %"); + posn = new Fl_Output(45,85,110,14,"Location"); + frcn = new CBar(45,105,110,14,"% Read"); + about = new Fl_Multiline_Output(5,125,150,90); + about->value("TWReader - $Name$\n\nA file reader program for the Agenda\n\nReads text, PalmDoc and ppms format files"); + Fl_Button *jump_accept = new Fl_Button(62,220,35,14,"Okay"); + infowin->set_modal(); + } + if (((reader_ui *)_data)->g_filename[0] != '\0') + { + unsigned long fs,ts; + tchar sz[20]; + ((reader_ui *)_data)->input->sizes(fs,ts); + unsigned long pl = ((reader_ui *)_data)->input->locate(); + + filename->value(((reader_ui *)_data)->g_filename); + + sprintf(sz,"%u",fs); + filesize->value(sz); + + sprintf(sz,"%u",ts); + textsize->value(sz); + + comprat->value(100-(100*fs + (ts >> 1))/ts); + + sprintf(sz,"%u",pl); + posn->value(sz); + + frcn->value((100*pl + (ts >> 1))/ts); + } + infowin->show(); +} +*/ + +void QTReaderApp::savebkmks() +{ + if (pBkmklist != NULL) + { + BkmkFile bf((const char *)Global::applicationFileName("uqtreader",reader->m_string), true); + bf.write(*pBkmklist); + } + m_fBkmksChanged = false; +} + +void QTReaderApp::readbkmks() +{ + if (pBkmklist != NULL) + { + delete pBkmklist; + } + BkmkFile bf((const char *)Global::applicationFileName("uqtreader",reader->m_string)); + pBkmklist = bf.readall(); + m_fBkmksChanged = false; + if (pBkmklist == NULL) + { + pBkmklist = reader->getbkmklist(); + } + if (pBkmklist != NULL) + pBkmklist->sort(); +} + +void QTReaderApp::addbkmk() +{ + m_nRegAction = cAddBkmk; + regEdit->setText(reader->firstword()); + do_regedit(); +} + +void QTReaderApp::do_addbkmk(const QString& text) +{ + if (text.isEmpty()) + { + QMessageBox::information(this, "QTReader", "Need a name for the bookmark\nSelect add again", 1); + } + else + { + if (pBkmklist == NULL) pBkmklist = new CList<Bkmk>; +#ifdef _UNICODE + CBuffer buff; + int i = 0; + for (i = 0; i < text.length(); i++) + { + buff[i] = text[i].unicode(); + } + buff[i] = 0; + pBkmklist->push_front(Bkmk(buff.data(), reader->pagelocate())); +#else + pBkmklist->push_front(Bkmk((const tchar*)text,reader->pagelocate())); +#endif + m_fBkmksChanged = true; + } +} diff --git a/noncore/apps/opie-reader/QTReaderApp.h b/noncore/apps/opie-reader/QTReaderApp.h new file mode 100644 index 0000000..48575e9 --- a/dev/null +++ b/noncore/apps/opie-reader/QTReaderApp.h @@ -0,0 +1,206 @@ +/********************************************************************** +** Copyright (C) 2000 Trolltech AS. All rights reserved. +** +** This file is part of Qt Palmtop Environment. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ +#ifndef __QTREADERAPP_H +#define __QTREADERAPP_H + +//#define __ISEARCH + +#define MAX_ENCODING 6 + +#include <qmainwindow.h> +#include "QTReader.h" +#include <qlist.h> +#include <qpe/filemanager.h> +#include <qmap.h> +#include <qlineedit.h> +#include <qstack.h> +#include <qlistbox.h> +#include "Queue.h" + +class QWidgetStack; +class QToolButton; +class QPopupMenu; +class QToolBar; +class CBkmkSelector; +class QProgressBar; +class QAction; + +#ifdef __ISEARCH +struct searchrecord +{ + QString s; + size_t pos; + searchrecord(const QString& _s, size_t _pos) : s(_s), pos(_pos) {} +}; +#endif + +class infowin; + +class QTReaderApp : public QMainWindow +{ + Q_OBJECT + + unsigned long m_savedpos; + + public: + QTReaderApp( QWidget *parent = 0, const char *name = 0, WFlags f = 0 ); + ~QTReaderApp(); + + void openFile( const QString & ); + + void setScrollState(bool _b); + + protected: + void closeEvent( QCloseEvent *e ); + void readbkmks(); + void do_mono(const QString&); + void do_jump(const QString&); + void do_overlap(const QString&); + void do_settarget(const QString&); + int EncNameToInt(const QString&); + void saveprefs(); + +private slots: + void do_setfont(const QString&); + void encodingSelected(QAction*); + void msgHandler(const QCString&, const QByteArray&); + void monospace(bool); + void jump(); + void setoverlap(); + void settarget(); + void setspacing(); + void setfont(); + void clearBkmkList(); + void listBkmkFiles(); + void editMark(); + void autoScroll(bool); + void addbkmk(); + void savebkmks(); +// void importFiles(); + void infoClose(); + // void oldFile(); + void showinfo(); + void setDocument(const QString&); + void TBD(); + void TBDzoom(); + + void indentplus(); + void indentminus(); + + void fileOpen(); + + void editCopy(); + void editFind(); + + void pageup(); + void pagedn(); + + void findNext(); + void findClose(); + + void regClose(); + +#ifdef __ISEARCH +// void search( const QString& ); +#else + void search(); +#endif + + void openFile( const DocLnk & ); + void showEditTools(); + + void stripcr(bool); + void striphtml(bool); + void dehyphen(bool); + void unindent(bool); + void repara(bool); + void setbold(bool); + void dblspce(bool); + void pagemode(bool); + // void gotobkmk(const QString& bm); + void gotobkmk(int); + void cancelbkmk(); + void do_gotomark(); + void do_delmark(); + void do_autogen(); + void do_regaction(); + + private: + void listbkmk(); + void do_regedit(); + void colorChanged( const QColor &c ); + void clear(); + void updateCaption(); + void do_autogen(const QString&); + void do_addbkmk(const QString&); + + private: + + QAction* m_scrollButton; + + QAction* m_EncodingAction[MAX_ENCODING]; + + CBkmkSelector* bkmkselector; + + size_t searchStart; +#ifdef __ISEARCH + QStack<searchrecord>* searchStack; + bool dosearch(size_t start, CBuffer& test, const QString& arg); +#else + bool dosearch(size_t start, CBuffer& test, const QRegExp& arg); +#endif + QWidgetStack *editorStack; + QTReader* reader; + QComboBox* m_fontSelector; + QToolBar *menu, *editBar, *searchBar, *regBar, *m_fontBar; + QLineEdit *searchEdit, *regEdit; + DocLnk *doc; + bool searchVisible; + bool regVisible; + bool m_fontVisible; + bool bFromDocView; + static unsigned long m_uid; + long unsigned get_unique_id() { return m_uid++; } + /* + void resizeEvent( QResizeEvent * r) + { + qDebug("resize:(%u,%u)", r->oldSize().width(), r->oldSize().height()); + qDebug("resize:(%u,%u)", r->size().width(), r->size().height()); + // bgroup->move( width()-bgroup->width(), 0 ); + } + */ + CList<Bkmk>* pBkmklist; + infowin* m_infoWin; + QProgressBar* pbar; + bool m_fBkmksChanged; + int m_nRegAction; + QString m_autogenstr; +}; + +const int cAutoGen = 0; +const int cAddBkmk = 1; +const int cDelBkmk = 2; +const int cGotoBkmk = 3; +const int cRmBkmkFile = 4; +const int cJump = 5; +const int cMonoSpace = 6; +const int cOverlap = 7; +const int cSetTarget = 8; +#endif diff --git a/noncore/apps/opie-reader/QtrListView.cpp b/noncore/apps/opie-reader/QtrListView.cpp new file mode 100644 index 0000000..67040f8 --- a/dev/null +++ b/noncore/apps/opie-reader/QtrListView.cpp @@ -0,0 +1,24 @@ +#include "QtrListView.h" + +void QtrListView::keyPressEvent(QKeyEvent* e) +{ + switch (e->key()) + { + case Key_Space: + e->accept(); + emit OnCentreButton(currentItem()); + break; +// case Key_Enter: +// case Key_Return: + case Key_F33: + e->accept(); + emit OnOKButton(currentItem()); + break; + case Key_Escape: + e->accept(); + emit OnCancelButton(); + break; + default: + QListView::keyPressEvent(e); + } +} diff --git a/noncore/apps/opie-reader/QtrListView.h b/noncore/apps/opie-reader/QtrListView.h new file mode 100644 index 0000000..c1b7f4d --- a/dev/null +++ b/noncore/apps/opie-reader/QtrListView.h @@ -0,0 +1,20 @@ +#ifndef __QTRLISTVIEW_H +#define __QTRLISTVIEW_H + +#include <qlistview.h> + +class QtrListView : public QListView +{ + Q_OBJECT + + virtual void keyPressEvent(QKeyEvent* e); + public: + QtrListView(QWidget* parent, char* name) : QListView(parent, name) {}; + + signals: + void OnOKButton(QListViewItem*); + void OnCentreButton(QListViewItem*); + void OnCancelButton(); +}; + +#endif diff --git a/noncore/apps/opie-reader/Queue.h b/noncore/apps/opie-reader/Queue.h new file mode 100644 index 0000000..f1bd4b4 --- a/dev/null +++ b/noncore/apps/opie-reader/Queue.h @@ -0,0 +1,21 @@ +#ifndef __QUEUE_H +#define __QUEUE_H + +#include "my_list.h" + +template<class T> +class CQueue : public CList<T> +{ + public: + bool empty() { return (front == NULL); } + void push(const T& t) { push_back(t); } + T pop() + { + T data = front->data; + node* n = front; + front = front->next; + delete n; + return data; + } +}; +#endif diff --git a/noncore/apps/opie-reader/README b/noncore/apps/opie-reader/README new file mode 100644 index 0000000..d091010 --- a/dev/null +++ b/noncore/apps/opie-reader/README @@ -0,0 +1,162 @@ +What is QT Reader? +================== + +QT Reader is an e-text reading program which understands several +varieties of PalmDoc format (types 1,2 and 4), zTxt, plain text and +gzipped text. + +In addition it supports its own very highly compressed format which is +based on ppm (regarded by many as the best available compression +technique) with modifications by Fabrice Bellard for speed and memory +efficiency and by myself to support random access on smaller +devices. I call this modified format ppms (for ppm, segmented). + +The ppms program which is used to produce ppms files from plain text +is available from http://www.timwentford.uklinux.net where there is +also a comparison of file sizes produced by several compression +methods. This is summarised below: + +Compression method Size in bytes Memory required to decompress +Plain text 573714 N/A +Makedoc (PalmDoc format) 329543 2k +ppms (default) 184187 350k +ppms (best) 151733 800k +bzip2 -1 180175 340k +bzip2 -9 154280 2.2M + +The default settings used here were chosen to suit the Agenda VR3. I +would expect the Zaurus to be able to use settings which give 170kb +file size and 500k memory without any problem. The format encodes the +settings used so the user may choose whatever suits them. I choose +based on the amount of memory required and on whether or not pageup +performance is acceptable. + +General Use +=========== + +Start it up and then choose "File/Open" from the menu. Select a +palmdoc, plain text, gzipped text or ppms file from the file selector +and use the cursor keys to page up/down (up/down keys) and to make the +text size comfortable (left/right keys) and thats it for most +uses. See below for more advanced use. + +What the Menu Options Do +======================== + +File +==== + +File operations live in this menu. + +Open Brings up the file selector to allow you to choose a + new file to read. +Info Displays info about the currently open file. Needs + reformatting. +Start Block Marks the text at the top of the currently displayed + page ready for copying. +Copy Block Copies all text from the mark to the bottom of the + currently displayed page to the clipboard. +Scroll Starts/stops autoscroll. The speed can be adjusted + using the up/down keys while autoscroll is on (page + up and down are still functional and can be activated + by using the up and down arrows on the task bar). +Jump Jumps to a specific offset in the file. If you note + down the current location from the File/Info display + you can then jump to the same position again using + this function (or you could bokmark it 8^)). +Page/Line scroll When this is On pressing the arrows (keys or + icons on the task bar) moves you a page at a time. + When this is off, pressing the arrows moves you a + line at a time. +Set Overlap Sets the number of lines of overlap between pages + when scrolling by page. +Set Dictionary When you tap on the screen the word under the + pointer is copied to the clipboard ready for pasting + into (e.g.) a dictionary program. Using this function + allows the word to be sent to compatible dictionary + programs direct. The format is exename/messagename + where exename is the name of the executable for the + dictionary program and messagename is the name of the + message it is expecting. You can get some idea of how + it works by using some debug functionality which I + deliberately left in QTReader. Set this to + uqtreader/info. + To deactivate it again, set it to /. +Find Brings up the search requester where you can enter a + regular expression to search (again) for. + +Format +====== + +Used to alter the way the text is reformatted before display. + +Strip CR Removes those pesky DOS crs from the file. +Strip HTML Uses a very simple minded filter to remove html mark-up. +Dehyphen Removes hyphens from e-texts which have been formatted to + fit on different sized displays by hyphenating words + which no longer appear at the end of the line. +Unindent Removes leading spaces from the beginning of paragraphs. +Re-paragraph Removes/adds line breaks as necessary to make the text + look nice on the display. +Double Space Adds an extra space between paragraphs. +Indent+ Increases the number of extra leading spaces inserted + before paragraphs. +Indent- Decreases the number of extra leading spaces inserted + before paragraphs. +Bold Sets the font to bold (if its supported by the currently + selected font). + +For e-texts from fictionwise I don't need any of these enabled. For +Project Gutenberg e-texts I enable Strip CR, Re-paragraph and either 3 lots +of indent+ and/or double space. + +Zoom Menu option not implemented but pops up an info box + telling you that left/right cursor keys will zoom + out/in. +Ideogram/Char grouping When selected, treats each character as a word + and enforces uniform character spacing - suitable for + many eastern character sets. When not selected, looks for + spaces in the text to identify words - suitable for most + western texts. (I'm not a language expert so forgive my, + probably inaccurate, generalisations). +Set Width Sets the character spacing as a percentage of the text + height to be used when in ideogram mode. Start at 100 and + experiment to find what you like best. +Encoding Allows you to choose from a variety of codings. Ascii is + actually unprocessed text so its precise behaviour may + depend on the machines locale setting. Palm and code page + 1252 are very similar and are useful if you have an etext + aimed at Palms or Windows machines which use an extended + character set - though you will need to use a unicode + enabled font to show all the characters. The U... fonts + are different varieties of unicode encodings. If you + don't know what that means you probably don't need them + (they allow texts to access the full range of characters + required for non US English languages). +Set Font Allows you to choose which font the text is displayed + in. Helvetica or smoothtimes are probably best for ascii type + texts, unifont or cyberbit (if you have installed them) + are best for extended character sets (other unicode fonts + may also be available but these are all I've found, so far). +Marks +===== + +Mark Saves the current position as a bookmark +Goto Allows selection of a bookmark to jump to. +Delete Deletes an unwanted bookmark from the current text. +Autogen Displays a box for entering a regular + expression which will be used to determine which + paragraphs (not lines) will be marked to allow jumping to + directly using the Goto option. The format options + described above are applied before the regular expression + matching is done. + This operation is performed in the background allowing + you to continue paging up/down the e-text. +Clear Deletes all in-memory bookmarks from the current document. +Save Saves the "in-memory" bookmarks to disk. +Tidy Deletes bookmark file for a document. The operations + above work on an in-memory copy of the bookmarks. This + option makes that copy more permanent (you will also be + prompted to save the bookmarks when closing a text if the + in-memory copy is different to the saved copy). + diff --git a/noncore/apps/opie-reader/Text.h b/noncore/apps/opie-reader/Text.h new file mode 100644 index 0000000..4c689be --- a/dev/null +++ b/noncore/apps/opie-reader/Text.h @@ -0,0 +1,28 @@ +#ifndef __Text_h +#define __Text_h +#include <stdio.h> +#include <sys/stat.h> +#include "CExpander.h" + +class Text: public CExpander { + FILE* file; +public: + Text() : file(NULL) {}; + virtual ~Text() { if (file != NULL) fclose(file); } + virtual int openfile(const tchar *src) + { + if (file != NULL) fclose(file); + return ((file = fopen(src,"rb")) == NULL); + } + virtual int getch() { return fgetc(file); } + virtual unsigned int locate() { return ftell(file); } + virtual void locate(unsigned int n) { fseek(file,n,SEEK_SET); } + virtual bool hasrandomaccess() { return true; } + virtual void sizes(unsigned long& _file, unsigned long& _text) + { + struct stat _stat; + fstat(fileno(file),&_stat); + _text = _file = _stat.st_size; + } +}; +#endif diff --git a/noncore/apps/opie-reader/ZText.h b/noncore/apps/opie-reader/ZText.h new file mode 100644 index 0000000..2848af7 --- a/dev/null +++ b/noncore/apps/opie-reader/ZText.h @@ -0,0 +1,35 @@ +#ifndef __Text_h +#define __Text_h +#include <stdio.h> +#include <zlib.h> +#include <sys/stat.h> + +#include "CExpander.h" + +class Text: public CExpander { + gzFile file; + unsigned long fsize; +public: + Text() : file(NULL) {}; + virtual ~Text() + { + if (file != NULL) gzclose(file); + } + virtual int openfile(const char *src) + { + if (file != NULL) gzclose(file); + struct stat _stat; + stat(src,&_stat); + fsize = _stat.st_size; + return ((file = gzopen(src,"rb")) == NULL); + } + virtual int getch() { return gzgetc(file); } + virtual unsigned int locate() { return gztell(file); } + virtual void locate(unsigned int n) { gzseek(file,n,SEEK_SET); } + virtual bool hasrandomaccess() { return true; } + virtual void sizes(unsigned long& _file, unsigned long& _text) + { + _text = _file = fsize; + } +}; +#endif diff --git a/noncore/apps/opie-reader/arith.h b/noncore/apps/opie-reader/arith.h new file mode 100644 index 0000000..19ca646 --- a/dev/null +++ b/noncore/apps/opie-reader/arith.h @@ -0,0 +1,43 @@ +/*
+ * Encodage & décodage arithmétique
+ */
+
+#ifndef ARITH_H
+
+#define ARITH_H
+
+#include "utypes.h"
+#include <stdio.h>
+
+class PPM_ReadBuf
+{
+ FILE *my_file_in;
+public:
+ PPM_ReadBuf(FILE* f) : my_file_in(f) {}
+ UINT readbuf(UCHAR *buf,UINT len)
+ {
+ UINT len1;
+ len1=fread(buf,1,len,my_file_in);
+ return len1;
+ }
+};
+
+class ArithClass
+{
+
+UCHAR *ainbuf;
+UCHAR *apinbuf,*aendinbuf;
+UINT ainbufsize;
+USHORT avalue,alow,ahigh;
+PPM_ReadBuf* areadbuf;
+UCHAR abitcnt;
+USHORT abitbuf;
+
+ public:
+void Arith_DecodeInit(PPM_ReadBuf* readbuf,UCHAR *buf,UINT bufsize);
+UINT Arith_DecodeVal(UINT size);
+void Arith_Decode(UINT min,UINT max,UINT size);
+void Arith_DecodeEnd(void);
+
+};
+#endif
diff --git a/noncore/apps/opie-reader/arith_d.cpp b/noncore/apps/opie-reader/arith_d.cpp new file mode 100644 index 0000000..c43d697 --- a/dev/null +++ b/noncore/apps/opie-reader/arith_d.cpp @@ -0,0 +1,94 @@ +/* décodage arithmétique
+ * optimisé pour une arithmétique 16 bits
+ */
+#include <stdlib.h>
+#include "arith.h"
+
+
+/*
+ * Initialisation du décodeur.
+ * bufsize doit être multiple de 2 et supérieur à 4
+ */
+
+void ArithClass::Arith_DecodeInit(PPM_ReadBuf* readbuf,UCHAR *buf,UINT bufsize) {
+
+ /* gestion buffer */
+
+ ainbuf=buf;
+ ainbufsize=bufsize;
+ areadbuf=readbuf;
+ aendinbuf=ainbuf+ainbufsize;
+ areadbuf->readbuf(ainbuf,ainbufsize);
+ apinbuf=ainbuf;
+
+ /* intervalle et position dans l'intervalle */
+ alow=0;
+ ahigh=0xFFFF;
+ avalue=(*apinbuf++)<<8;
+ avalue|=(*apinbuf++);
+
+ /* remplissage du buffer 16 bits */
+
+ abitbuf=(*apinbuf++)<<8;
+ abitbuf|=(*apinbuf++);
+ abitcnt=16;
+}
+
+#define DIV16(a,b) ( (UINT)(a)/(UINT)(b) )
+#define MUL16(a,b) ( (UINT)(a)*(UINT)(b) )
+
+/*
+ * Décodage: première étape
+ */
+
+UINT ArithClass::Arith_DecodeVal(UINT asize) {
+ USHORT range,c;
+
+ range=ahigh-alow+1;
+ c=avalue-alow+1;
+ if (range!=0) {
+ if (c==0) return DIV16(((UINT)asize<<16)-1,range);
+ else return DIV16(MUL16(c,asize)-1,range);
+ } else {
+ if (c==0) return (asize-1);
+ else return (MUL16(c,asize)-1)>>16;
+ }
+}
+
+/*
+ * Décodage: deuxième étape
+ */
+
+void ArithClass::Arith_Decode(UINT amin,UINT amax,UINT asize) {
+ USHORT range;
+
+ range = ahigh - alow;
+ if (amax!=asize) ahigh=alow+DIV16(MUL16(range,amax)+amax,asize)-1;
+ if (amin!=0) alow+=DIV16(MUL16(range,amin)+amin,asize);
+ for ( ; ; ) {
+ if ( alow>=0x4000 && ahigh<0xC000 ) {
+ avalue -= 0x4000; alow -= 0x4000; ahigh -= 0x4000;
+ } else if ( ahigh>=0x8000 && alow<0x8000 ) break;
+
+ alow+=alow;
+ ahigh+=ahigh+1;
+ avalue=(avalue<<1)|( (abitbuf&0x8000)!=0 );
+ abitbuf<<=1;
+ if ( (--abitcnt)==0 ) {
+ abitbuf=(*apinbuf++)<<8;
+ abitbuf|=(*apinbuf++);
+ abitcnt=16;
+ if (apinbuf>=aendinbuf) {
+ areadbuf->readbuf(ainbuf,ainbufsize);
+ apinbuf=ainbuf;
+ }
+ }
+ }
+}
+
+/*
+ * fin du décodage: rien à faire
+ */
+
+void ArithClass::Arith_DecodeEnd(void) {
+}
diff --git a/noncore/apps/opie-reader/cbkmkselector.h b/noncore/apps/opie-reader/cbkmkselector.h new file mode 100644 index 0000000..1a49c5a --- a/dev/null +++ b/noncore/apps/opie-reader/cbkmkselector.h @@ -0,0 +1,41 @@ +#include <qwidget.h> +#include <qlistbox.h> +#include <qpushbutton.h> +#include <qlayout.h> + +class CBkmkSelector : public QWidget +{ + + Q_OBJECT + + QListBox* bkmkselector; + +signals: + void selected(int i); + void cancelled(); +private slots: + void slotSelected(QListBoxItem* t) { emit selected(bkmkselector->index(t)); } + void slotSelected(int t) { emit selected(t); } + void slotCancel() { emit cancelled(); } +public: + CBkmkSelector( QWidget *parent=0, const char *name=0, WFlags f = 0) : + QWidget(parent, name, f) + { + +// QFont f("unifont", 16); +// setFont( f ); + + QVBoxLayout* grid = new QVBoxLayout(this); + bkmkselector = new QListBox(this, "Bookmarks"); + QPushButton* exitButton = new QPushButton("Cancel", this); + connect(bkmkselector, SIGNAL( selected(int) ), this, SLOT( slotSelected(int) ) ); + connect(bkmkselector, SIGNAL( clicked(QListBoxItem*) ), this, SLOT( slotSelected(QListBoxItem*) ) ); + connect(exitButton, SIGNAL( released() ), this, SLOT( slotCancel() ) ); + grid->addWidget(bkmkselector,1); + grid->addWidget(exitButton); + } + void clear() { bkmkselector->clear(); } + void insertItem(const QString& item) { bkmkselector->insertItem(item); } + QString text(int index) const { return bkmkselector->text(index); } +}; + diff --git a/noncore/apps/opie-reader/config.h b/noncore/apps/opie-reader/config.h new file mode 100644 index 0000000..5150270 --- a/dev/null +++ b/noncore/apps/opie-reader/config.h @@ -0,0 +1,21 @@ +#ifndef __CONFIG_H +#define __CONFIG_H + +#define _UNICODE + +#ifdef _UNICODE +#include <limits.h> + +#define UTF8 + +typedef unsigned short tchar; +const tchar UEOF = USHRT_MAX; + +#else +typedef char tchar; +const int UEOF = -1; +#endif + +#include "ustring.h" + +#endif diff --git a/noncore/apps/opie-reader/fileBrowser.cpp b/noncore/apps/opie-reader/fileBrowser.cpp new file mode 100644 index 0000000..def988f --- a/dev/null +++ b/noncore/apps/opie-reader/fileBrowser.cpp @@ -0,0 +1,185 @@ +/**************************************************************************** + +Derived from a file browser which was + +** copyright 2001 ljp ljp@llornkcor.com + +Extensive modification by Tim Wentford to allow it to work in rotated mode + +****************************************************************************/ +#include "fileBrowser.h" + +#include "QtrListView.h" +#include <qpushbutton.h> +#include <qfile.h> +#include <qmessagebox.h> +#include <unistd.h> +#include <qlayout.h> + +fileBrowser::fileBrowser( QWidget* parent, const char* name, bool modal, WFlags fl , const QString filter, const QString iPath ) + : QDialog( parent, name, modal, fl ) +{ +// showMaximized(); + if ( !name ) + setName( "fileBrowser" ); + if (parent != NULL) resize( parent->width(), parent->height() ); + setCaption(tr( "Browse for file" ) ); + filterStr=filter; + + buttonOk = new QPushButton( this, "buttonOk" ); + buttonOk->setFixedSize( 25, 25 ); + buttonOk->setText( tr( "/" ) ); + + dirLabel = new QLabel(this, "DirLabel"); + dirLabel->setText(currentDir.canonicalPath()); + + ListView = new QtrListView( this, "ListView" ); + ListView->addColumn( tr( "Name" ) ); + ListView->setSorting( 2, FALSE); + ListView->addColumn( tr( "Size" ) ); + ListView->setSelectionMode(QListView::Single); + + ListView->setAllColumnsShowFocus( TRUE ); + + // signals and slots connections + connect( buttonOk, SIGNAL( clicked() ), this, SLOT( OnRoot() ) ); + connect( ListView, SIGNAL(doubleClicked( QListViewItem*)), SLOT(listDoubleClicked(QListViewItem *)) ); + connect( ListView, SIGNAL(clicked( QListViewItem*)), SLOT(listClicked(QListViewItem *)) ); + connect( ListView, SIGNAL(OnOKButton( QListViewItem*)), SLOT(listClicked(QListViewItem *)) ); + connect( ListView, SIGNAL(OnCentreButton( QListViewItem*)), SLOT(listClicked(QListViewItem *)) ); + connect( ListView, SIGNAL(OnCancelButton()), SLOT(OnCancel()) ); + + QVBoxLayout* grid = new QVBoxLayout(this); + QHBoxLayout* hgrid = new QHBoxLayout(grid); + hgrid->addWidget(dirLabel,1); + hgrid->addWidget(buttonOk); + grid->addWidget(ListView,1); + + if (QFileInfo(iPath).exists()) + { + currentDir.setPath(iPath); + chdir(iPath.latin1()); + } + else + { + currentDir.setPath(QDir::currentDirPath()); + chdir(QDir::currentDirPath().latin1()); + } + + populateList(); +} + +void fileBrowser::resizeEvent(QResizeEvent* e) +{ + ListView->setColumnWidth(1,(ListView->width())/4); + ListView->setColumnWidth(0,ListView->width()-20-ListView->columnWidth(1)); +} + +fileBrowser::~fileBrowser() +{ +} + + +void fileBrowser::populateList() +{ + ListView->clear(); +//qDebug(currentDir.canonicalPath()); +// currentDir.setFilter( QDir::Files | QDir::Dirs | QDir::Hidden | QDir::NoSymLinks ); + currentDir.setFilter( QDir::All ); + currentDir.setSorting(/* QDir::Size*/ /*| QDir::Reversed | */QDir::DirsFirst); + currentDir.setMatchAllDirs(TRUE); + + currentDir.setNameFilter(filterStr); +// currentDir.setNameFilter("*.txt;*.etx"); + QString fileL, fileS; + const QFileInfoList *list = currentDir.entryInfoList(QDir::All); + QFileInfoListIterator it(*list); + QFileInfo *fi; + while ( (fi=it.current()) ) + { + if (fi->fileName() != ".") + { + fileS.sprintf( "%10li", fi->size() ); + fileL.sprintf( "%s",fi->fileName().data() ); + if( fi->isDir() ) + { + fileL+="/"; + } + else + { +// qDebug("Not a dir: "+currentDir.canonicalPath()+fileL); + } + new QListViewItem( ListView,fileL,fileS ); + } + ++it; + } + ListView->setSorting( 2, FALSE); + dirLabel->setText("Current Directory:\n"+currentDir.canonicalPath()); +} + +void fileBrowser::upDir() +{ +// qDebug(currentDir.canonicalPath()); +} + +void fileBrowser::listClicked(QListViewItem *selectedItem) +{ + if (selectedItem == NULL) return; + QString strItem=selectedItem->text(0); + +// qDebug("%s", (const char*)strItem); + + + QString strSize=selectedItem->text(1); + + strSize.stripWhiteSpace(); + + bool ok; + + QFileInfo fi(strItem); + while (fi.isSymLink()) fi.setFile(fi.readLink()); + if (fi.isDir()) + { + strItem=QDir::cleanDirPath(currentDir.canonicalPath()+"/"+strItem); + + if(QDir(strItem).exists()) + { + currentDir.cd(strItem, TRUE); + populateList(); + } + } else + OnOK(); + chdir(strItem.latin1()); +// + +} + +// you may want to switch these 2 functions. I like single clicks +void fileBrowser::listDoubleClicked(QListViewItem *selectedItem) +{ +} + +void fileBrowser::OnOK() { + + QListViewItemIterator it1( ListView); + for ( ; it1.current(); ++it1 ) { + if ( it1.current()->isSelected() ) { + selectedFileName=QDir::cleanDirPath(currentDir.canonicalPath()+"/"+it1.current()->text(0)); +// qDebug("selected filename is "+selectedFileName); + fileList.append( selectedFileName ); + } + } + accept(); +} + +void fileBrowser::OnRoot() +{ + currentDir.cd("/", TRUE); + populateList(); + chdir("/"); +} + +void fileBrowser::OnCancel() +{ + reject(); +} diff --git a/noncore/apps/opie-reader/fileBrowser.h b/noncore/apps/opie-reader/fileBrowser.h new file mode 100644 index 0000000..d222791 --- a/dev/null +++ b/noncore/apps/opie-reader/fileBrowser.h @@ -0,0 +1,70 @@ +/* +Derived from the file browser published by ljp@llornkcor.com but extensively +modified to work in rotated views on the Zaurus +*/ + +/**************************************************************************** +** Form interface generated from reading ui file 'fileBrowzer.ui' +** +** Created: Fri Dec 14 08:16:02 2001 +** by: The User Interface Compiler (uic) +** +** WARNING! All changes made in this file will be lost! +blah,blah,blah +****************************************************************************/ +#ifndef FILEBROWSER_H +#define FILEBROWSER_H + +//#include <qvariant.h> +#include <qdialog.h> +#include <qfile.h> +#include <qdir.h> +#include <qstringlist.h> +#include <qlabel.h> +#include <qstring.h> + +class QVBoxLayout; +class QHBoxLayout; +class QGridLayout; +class QtrListView; +class QListViewItem; +class QPushButton; + +class fileBrowser : public QDialog +{ + Q_OBJECT + +public: + void populateList(); + fileBrowser( QWidget* parent = 0, const char* name = 0, bool modal = FALSE, WFlags fl = 0 ,const QString filter=0, const QString iPath=0); + ~fileBrowser(); + + QPushButton* buttonOk; + QtrListView* ListView; + QPushButton* buttonCancel; + QLabel *dirLabel; + QString selectedFileName, filterStr; + QDir currentDir; + QFile file; + QStringList fileList; + +//QListViewItem * item; +public slots: + +private: + +private slots: + void upDir(); + void listDoubleClicked(QListViewItem *); + void listClicked(QListViewItem *); + void OnRoot(); + void OnCancel(); + +protected slots: + +protected: + void OnOK(); + virtual void resizeEvent(QResizeEvent* e); +}; + +#endif // FILEBROWSER_H diff --git a/noncore/apps/opie-reader/infowin.cpp b/noncore/apps/opie-reader/infowin.cpp new file mode 100644 index 0000000..f9a6f5f --- a/dev/null +++ b/noncore/apps/opie-reader/infowin.cpp @@ -0,0 +1,41 @@ +#include "infowin.h" +#include "version.h" + +#define VERSION_STRING "QT Reader v" ## MAJOR ## "." ## MINOR ## " (" ## RELEASE_TYPE ## ")\nA small e-text reader" + +infowin::infowin( QWidget *parent=0, const char *name=0, WFlags f = 0) : + QWidget(parent, name, f) +{ + grid = new QGridLayout(this, 6, 2); + QLabel* l; + l = new QLabel("Compressed file size", this); + grid->addWidget(l, 0, 0); + fileSize = new QLabel("0", this); + fileSize->setAlignment( AlignVCenter | AlignRight ); + grid->addWidget(fileSize, 0, 1); + l = new QLabel("Original text size", this); + grid->addWidget(l, 1, 0); + textSize = new QLabel("0", this); + textSize->setAlignment( AlignVCenter | AlignRight ); + grid->addWidget(textSize, 1, 1); + l = new QLabel("Compression Ratio", this); + grid->addWidget(l, 2, 0); + ratio = new QLabel("0", this); + grid->addWidget(ratio, 2, 1); + ratio->setAlignment( AlignVCenter | AlignRight ); + l = new QLabel("Current location", this); + grid->addWidget(l, 3, 0); + location = new QLabel("0", this); + location->setAlignment( AlignVCenter | AlignRight ); + grid->addWidget(location, 3, 1); + l = new QLabel("Per centage read", this); + grid->addWidget(l, 4, 0); + read = new QLabel("0", this); + read->setAlignment( AlignVCenter | AlignRight ); + grid->addWidget(read, 4, 1); + l = new QLabel(VERSION_STRING, this); + grid->addWidget(l, 5, 0); + QPushButton* exitbutton = new QPushButton("Cancel", this); + connect( exitbutton, SIGNAL( released() ), this, SLOT( infoClose() ) ); + grid->addWidget(exitbutton, 5, 1); +} diff --git a/noncore/apps/opie-reader/infowin.h b/noncore/apps/opie-reader/infowin.h new file mode 100644 index 0000000..9ddce36 --- a/dev/null +++ b/noncore/apps/opie-reader/infowin.h @@ -0,0 +1,52 @@ +#ifndef __INFOWIN_H +#define __INFOWIN_H + +#include <qlayout.h> +#include <qpushbutton.h> +#include <qgrid.h> +#include <qlabel.h> + +class infowin : public QWidget +{ +Q_OBJECT + QLabel* fileSize; + QLabel* textSize; + QLabel* ratio; + QLabel* location; + QLabel* read; + QGridLayout* grid; +public: + infowin::infowin( QWidget *parent=0, const char *name=0, WFlags f = 0); +/* + void addcancel(QPushButton* exitbutton) + { + grid->addWidget(exitbutton, 5, 1); + } +*/ + void setFileSize(int sz) { fileSize->setNum(sz); } + void setTextSize(int sz) { textSize->setNum(sz); } + void setRatio(int sz) { ratio->setText(QString().setNum(sz)+"%"); } + void setLocation(int sz) { location->setNum(sz); } + void setRead(int sz) { read->setText(QString().setNum(sz)+"%"); } +/* + virtual void keyPressEvent(QKeyEvent* e) + { + printf("Received:%d\n", e->key()); + switch (e->key()) + { + case Key_Escape: + e->accept(); + emit Close(); + break; + default: + e->ignore(); + } + } +*/ +private slots: + void infoClose() { emit Close(); } + signals: + void Close(); +}; + +#endif diff --git a/noncore/apps/opie-reader/main.cpp b/noncore/apps/opie-reader/main.cpp new file mode 100644 index 0000000..e37f12c --- a/dev/null +++ b/noncore/apps/opie-reader/main.cpp @@ -0,0 +1,38 @@ +#include <qpe/qpeapplication.h> +//#include <qmainwindow.h> +#include "QTReaderApp.h" + + + + + +/* +class myapp : public QPEApplication +{ + public slots: + void receive( const QCString& msg, const QByteArray& data ) + { + + QDataStream stream( data, IO_ReadOnly ); + if ( msg == "someMessage(int,int,int)" ) { + int a,b,c; + stream >> a >> b >> c; + ... + } else if ( msg == "otherMessage(QString)" ) { + ... + } + + } +} +*/ + +int main( int argc, char ** argv ) +{ + QPEApplication a( argc, argv ); + + QTReaderApp m; + a.showMainDocumentWidget( &m ); + + return a.exec(); +} + diff --git a/noncore/apps/opie-reader/my_list.h b/noncore/apps/opie-reader/my_list.h new file mode 100644 index 0000000..b3f0cc0 --- a/dev/null +++ b/noncore/apps/opie-reader/my_list.h @@ -0,0 +1,172 @@ +#ifndef __MY_LIST_H +#define __MY_LIST_H + +template<class T> +class CList +{ + struct node + { + T data; + node* next; + node(T _data, node* _next = NULL) : data(_data), next(_next) {} + node() : next(NULL) {}; + }; + protected: + node* front; + node* back; + public: + CList() : front(NULL), back(NULL) {} + ~CList() + { + if (front != NULL) + { + while (front != NULL) + { + node *p = front; + front = p->next; + delete p; + } + } + } + T* operator[](int n) + { + node* current = front; + while (n-- > 0) + { + if ((current = current->next) == NULL) + return NULL; + } + return &(current->data); + } + void push_front(const T& t) + { + node* n = new node(t,front); + if (front == NULL) + { + front = back = n; + } + else + front = n; + } + void push_back(const T& t) + { + node* n = new node(t); + if (front == NULL) + { + front = back = n; + } + else + { + back->next = n; + back = n; + } + } + void erase(unsigned int n) + { + node* p = front; + node* last = front; + while (n-- > 0) + { + last = p; + p = p->next; + if (p == NULL) return; + } + if (p == front) + { + front = p->next; + } + else + { + last->next = p->next; + } + if (p == back) + { + back = last; + } + delete p; + } + void sort() + { + int i,j,inc,n; + T v; + T* item; + node* t; + t = front; + n = 0; + while (t != NULL) + { + n++; + t = t->next; + } + if (n >= 2) + { + item = new T[n]; + i = 0; + t = front; + for (t = front, i = 0; t != NULL; t = t->next, i++) + { + item[i] = t->data; + } + + for (inc = 1; inc <= n; inc = 3*inc+1); + + do + { + inc /= 3; + for (i = inc; i < n; i++) + { + v = item[i]; + for (j = i; v < item[j-inc] && j >= inc; j -= inc) + { + item[j] = item[j-inc]; + } + item[j] = v; + } + } + while (inc > 1); + for (t = front, i = 0; t != NULL; t = t->next, i++) + { + t->data = item[i]; + } + // back = *(item[n-1]); + delete [] item; + } + } + class iterator + { + node* current; + public: + iterator(node* _c) : current(_c) {} + iterator& operator++() + { + current = current->next; + return *this; + } + iterator& operator++(int) + { + current = current->next; + return *this; + } + T operator*() + { + return current->data; + } + T* operator->() + { + return &(current->data); + } + bool operator!=(iterator t) + { + return (current != t.current); + } + }; + iterator begin() + { + return iterator(front); + } + iterator end() + { + return iterator(NULL); + } +}; +#endif diff --git a/noncore/apps/opie-reader/opie-reader.control b/noncore/apps/opie-reader/opie-reader.control new file mode 100644 index 0000000..e8c98bb --- a/dev/null +++ b/noncore/apps/opie-reader/opie-reader.control @@ -0,0 +1,9 @@ +Files: bin/uqtreader apps/Applications/uqtreader.desktop pics/uqtreader.png pics/panel-arrow-down.png +Priority: optional +Section: applications +Maintainer: Tim Wentford <timwentford@hotmail.com> +Architecture: arm +Version: 0_3r_beta_UTF8 +Depends: +License: GPL +Description: E-Book reader diff --git a/noncore/apps/opie-reader/opie-reader.pro b/noncore/apps/opie-reader/opie-reader.pro new file mode 100644 index 0000000..c4a87a4 --- a/dev/null +++ b/noncore/apps/opie-reader/opie-reader.pro @@ -0,0 +1,48 @@ +TEMPLATE = app +CONFIG = qt warn_on release +HEADERS = Aportis.h \ + BuffDoc.h \ + CBuffer.h \ + CExpander.h \ + CFilter.h \ + QTReader.h \ + QTReaderApp.h \ + Text.h \ + ZText.h \ + arith.h \ + my_list.h \ + ppm.h \ + ppm_expander.h \ + cbkmkselector.h \ + fileBrowser.h \ + ztxt.h \ + QtrListView.h \ + infowin.h \ + version.h \ + pdb.h \ + utypes.h \ + ustring.h \ + CEncoding.h \ + config.h +SOURCES = Aportis.cpp \ + BuffDoc.cpp \ + CBuffer.cpp \ + QTReader.cpp \ + QTReaderApp.cpp \ + arith_d.cpp \ + main.cpp \ + ppm.cpp \ + ppm_expander.cpp \ + ztxt.cpp \ + QtrListView.cpp \ + infowin.cpp \ + pdb.cpp \ + CEncoding.cpp \ + fileBrowser.cpp +INTERFACES = +DESTDIR = $(OPIEDIR)/bin +INCLUDEPATH += $(OPIEDIR)/include +DEPENDPATH += $(OPIEDIR)/include +TARGET = uqtreader +LIBS += -lqpe + diff --git a/noncore/apps/opie-reader/pdb.cpp b/noncore/apps/opie-reader/pdb.cpp new file mode 100644 index 0000000..68b904e --- a/dev/null +++ b/noncore/apps/opie-reader/pdb.cpp @@ -0,0 +1,57 @@ +#include "pdb.h" + +size_t Cpdb::recordpos(int n) +{ + UInt16 mxn = ntohs(head.recordList.numRecords); + if (n >= mxn) + { + return file_length; + } + else + { + size_t dataoffset = sizeof(DatabaseHdrType) - sizeof(UInt16); + dataoffset += /*dataoffset%4 + */ sizeof(RecordListType) * n; + fseek(fin, dataoffset, SEEK_SET); + RecordListType hdr; + fread(&hdr, 1, sizeof(hdr), fin); + return ntohl(hdr.nextRecordListID); + } + +} + +size_t Cpdb::recordlength(int n) +{ + return recordpos(n+1)-recordpos(n); +} + +void Cpdb::gotorecordnumber(int n) +{ + fseek(fin, recordpos(n), SEEK_SET); +} + +bool Cpdb::openfile(const char *src) +{ + + // printf("In openfile\n"); + int ret = 0; + // printf("closing fin:%x\n",fin); + if (fin != NULL) fclose(fin); + // printf("opening fin\n"); + fin = fopen(src,"rb"); + + if (fin==0) + { + return false; + } + + // just holds the first few chars of the file + // char buf[0x100]; + fseek(fin,0,SEEK_END); + file_length = ftell(fin); + + fseek(fin,0,SEEK_SET); + + fread(&head, 1, sizeof(head), fin); + + return true; +} diff --git a/noncore/apps/opie-reader/pdb.h b/noncore/apps/opie-reader/pdb.h new file mode 100644 index 0000000..143c5cb --- a/dev/null +++ b/noncore/apps/opie-reader/pdb.h @@ -0,0 +1,90 @@ + +/* + * This header file defines some structures and types normally found in the + * Palm SDK. However, I don't want to require the presense of the SDK for a + * small utility since most Palm owners won't have it. + * + * $Id$ + * + */ + +#ifndef __PDB_H__ +#define __PDB_H__ + +#include <netinet/in.h> +#include <stdio.h> + +/* Normal Palm typedefs */ +typedef unsigned char UInt8; +typedef unsigned short UInt16; +typedef unsigned long UInt32; +typedef UInt32 LocalID; + +/* Max length of DB name */ +#define dmDBNameLength 0x20 + + +/************************************************************ + * Structure of a Record entry + *************************************************************/ +typedef struct { + LocalID localChunkID; // local chunkID of a record + UInt8 attributes; // record attributes; + UInt8 uniqueID[3]; // unique ID of record; should + // not be 0 for a legal record. +} RecordEntryType; + + +/************************************************************ + * Structure of a record list extension. This is used if all + * the database record/resource entries of a database can't fit into + * the database header. + *************************************************************/ +typedef struct { + LocalID nextRecordListID; // local chunkID of next list + UInt16 numRecords; // number of records in this list + UInt16 firstEntry; // array of Record/Rsrc entries + // starts here +} RecordListType; + + +/************************************************************ + * Structure of a Database Header + *************************************************************/ +typedef struct { + UInt8 name[dmDBNameLength]; // name of database + UInt16 attributes; // database attributes + UInt16 version; // version of database + UInt32 creationDate; // creation date of database + UInt32 modificationDate; // latest modification date + UInt32 lastBackupDate; // latest backup date + UInt32 modificationNumber; // modification number of database + LocalID appInfoID; // application specific info + LocalID sortInfoID; // app specific sorting info + UInt32 type; // database type + UInt32 creator; // database creator + UInt32 uniqueIDSeed; // used to generate unique IDs. + // Note that only the low order + // 3 bytes of this is used (in + // RecordEntryType.uniqueID). + // We are keeping 4 bytes for + // alignment purposes. + RecordListType recordList; // first record list +} DatabaseHdrType; + + +class Cpdb +{ + protected: + size_t file_length; + FILE* fin; + size_t recordpos(int); + size_t recordlength(int); + void gotorecordnumber(int); + DatabaseHdrType head; + bool openfile(const char* src); + Cpdb() : fin(NULL) {} + ~Cpdb() { if (fin != NULL) fclose(fin); } +}; +#endif + diff --git a/noncore/apps/opie-reader/ppm.cpp b/noncore/apps/opie-reader/ppm.cpp new file mode 100644 index 0000000..e8bf110 --- a/dev/null +++ b/noncore/apps/opie-reader/ppm.cpp @@ -0,0 +1,756 @@ +#include <stdlib.h> +#include <stdio.h> +#include "arith.h" +#include "ppm.h" + +/**************************************************************************** + * Gestion des noeuds + ****************************************************************************/ + +/* + * Désallocation du noeud p + */ + +void ppm_worker::Node_Free(UINT p) { + node_heap[node_free_last].free_next=p; + node_heap[p].free_next=NIL; + node_free_last=p; + node_free_nb++; +} + +/* + * Allocation d'un noeud + * s'il ne reste plus de place, on désalloue le contexte le moins utilisé. + */ + +UINT ppm_worker::Node_Alloc(void) { + UINT p; + if (node_free_nb<=2) Context_DeleteLast(); + p=node_free_first; + node_free_first=node_heap[node_free_first].free_next; + node_free_nb--; +#ifdef DEBUG + printf("Node_Alloc: p=%d\n",p); +#endif + return p; +} + +/**************************************************************************** + * Gestion des contextes + ****************************************************************************/ + + +/* + * Mise au début de la liste des contextes du contexte c + */ +void ppm_worker::Context_MoveFirst(UINT c) { + NODE *ctx; + + if (c!=ctx_first) { + ctx=&node_heap[c]; + /* suppression du contexte dans la liste */ + if (c==ctx_last) { + ctx_last=ctx->hdr.ctx_prev; + } else { + node_heap[ctx->hdr.ctx_prev].hdr.ctx_next=ctx->hdr.ctx_next; + node_heap[ctx->hdr.ctx_next].hdr.ctx_prev=ctx->hdr.ctx_prev; + } + /* insertion au début de la liste */ + node_heap[ctx_first].hdr.ctx_prev=c; + ctx->hdr.ctx_next=ctx_first; + ctx_first=c; + } +} + +/* + * Destruction du contexte le moins utilisé (ctx_last) + */ +void ppm_worker::Context_DeleteLast(void) { + NODE *n; + UINT h,h_next,node,node_next; + USHORT *p; + + n=&node_heap[ctx_last]; + + /* libération dans la table de hachage. Comme on ne dispose pas de + * pointeur hash_prev dans les contextes, il faut parcourir toute + * la liste. Heureusement, celle-ci est de longueur faible en moyenne + */ + h_next=n->hdr.hash_next; + h=h_next; + while (h<HASH_ADDRESS) h=node_heap[h].hdr.hash_next; + p=&hash_table[h-HASH_ADDRESS]; + while (*p!=ctx_last) p=&node_heap[*p].hdr.hash_next; + *p=h_next; + + /* libération des noeuds & modification de ctx_last */ + + if (n->hdr.sf_max>=2) { + node=n->hdr.sf.l.sf_next; + while (1) { + node_next=node_heap[node].sf.sf_next; + Node_Free(node); + if (node_next==NIL) break; + node=node_next; + } + } + + node=ctx_last; + ctx_last=n->hdr.ctx_prev; + Node_Free(node); + ctx_nb--; +} + +/* + * Création d'un nouveau contexte avec un seul symbole sym de fréquence 1 + * Utilisation implicite de sym_context et sym_hash. + * Libération de mémoire si nécessaire, et mise en premier dans la liste + */ +void ppm_worker::Context_New(int sym,int order) { + NODE *ctx; + UINT i,c; + +#ifdef DEBUG + printf("Context_New: sym=%d o=%d\n",sym,order); +#endif + + c=Node_Alloc(); + ctx=&node_heap[c]; + + /* mise du contexte en tête de la liste */ + ctx->hdr.ctx_next=ctx_first; + node_heap[ctx_first].hdr.ctx_prev=c; + ctx_first=c; + ctx_nb++; + + /* insertion dans la table de hachage */ + ctx->hdr.hash_next=hash_table[sym_hash[order]]; + hash_table[sym_hash[order]]=ctx_first; + + /* initialisation du contexte */ + ctx->hdr.order=order; + for(i=0;i<order;i++) ctx->hdr.sym[i]=sym_context[i+1]; + + ctx->hdr.sf_max=0; + ctx->hdr.sf.sf[0].sym=sym; + ctx->hdr.sf.sf[0].freq=1; +#ifdef DEBUG + Context_Print(ctx_first); +#endif +} + +/* + * Ajout d'un nouveau symbole au contexte c + */ + +void ppm_worker::Context_NewSym(int sym,UINT c) { + NODE *n,*m; + UINT p,sf_max; + +#ifdef DEBUG + printf("Context_NewSym: sym=%d c=%d\n",sym,c); + Context_Print(c); +#endif + + n=&node_heap[c]; + sf_max=n->hdr.sf_max; + n->hdr.sf_max++; + if (sf_max==0) { + n->hdr.sf.sf[1].sym=sym; + n->hdr.sf.sf[1].freq=1; + } else if (sf_max==1) { + p=Node_Alloc(); + m=&node_heap[p]; + m->sf.sf[0]=n->hdr.sf.sf[0]; + m->sf.sf[1]=n->hdr.sf.sf[1]; + m->sf.sf[2].sym=sym; + m->sf.sf[2].freq=1; + m->sf.sf_next=NIL; + n->hdr.sf.l.sf_next=p; + n->hdr.sf.l.freq_tot=((UINT)m->sf.sf[0].freq+(UINT)m->sf.sf[1].freq+1); + } else { + n->hdr.sf.l.freq_tot++; + m=&node_heap[n->hdr.sf.l.sf_next]; + while (sf_max>=NODE_SFNB) { + sf_max-=NODE_SFNB; + m=&node_heap[m->sf.sf_next]; + } + sf_max++; + if (sf_max==NODE_SFNB) { + p=Node_Alloc(); + m->sf.sf_next=p; + m=&node_heap[p]; + m->sf.sf_next=NIL; + sf_max=0; + } + m->sf.sf[sf_max].sym=sym; + m->sf.sf[sf_max].freq=1; + } +#ifdef DEBUG + Context_Print(c); +#endif +} + + +#ifdef STAT +int hash_nb=1; +int hash_cnt=0; +#endif + +/* + * Recherche d'un contexte, utilisation de façon implicite de sym_context + * et de sym_hash. + * C'est une procédure très critique qui doit être particulièrement optimisée + */ + +UINT ppm_worker::Context_Search(int order) { + UCHAR *sym; + UINT i,p; + NODE *n; +#ifdef DEBUG + printf("Context_Search: o=%d\n",order); +#endif + + p=hash_table[sym_hash[order]]; + sym=&sym_context[1]; +#ifdef STAT + hash_nb++; +#endif + while (p<HASH_ADDRESS) { +#ifdef STAT + hash_cnt++; +#endif + n=&node_heap[p]; + if (n->hdr.order==order) { + if (order==0) return p; + i=0; + while (sym[i]==n->hdr.sym[i]) { + i++; + if (i==order) return p; + } + } + p=n->hdr.hash_next; + } + return HASH_ADDRESS; +} + +/* + * Cette macro est HORRIBLE mais permet de simplifier beaucoup le parcours + * des listes de couples symbole,fréquence tout en ayant un code rapide. + * Une alternative élégante mais lente aurait été de passer une fonction + * en paramètre contenant le code à exécuter + */ + +#define SF_Read(n,p,code_to_execute) \ +{\ + UINT nb,i;\ + nb=(UINT)n->hdr.sf_max+1;\ + if (nb<=HDR_SFNB) {\ + p=&n->hdr.sf.sf[0];\ + } else {\ + p=&node_heap[n->hdr.sf.l.sf_next].sf.sf[0];\ + while (nb>NODE_SFNB) {\ + for(i=0;i<NODE_SFNB;i++) {\ + code_to_execute;\ + p++;\ + }\ + p=&node_heap[ *((USHORT *)p) ].sf.sf[0];\ + nb-=NODE_SFNB;\ + }\ + }\ + for(i=0;i<nb;i++) {\ + code_to_execute;\ + p++;\ + }\ +} + + +/* + * Renormalisation d'un contexte, ie, division de toutes les fréquences + * par 2 et élimination des symboles de fréquence nulle + * Note: le contexte obtenu n'est jamais vide. + * Une amélioration prévue mais non implémentée serait de trier le contexte + * dans l'ordre des fréquences décroissantes pour accélérer la recherche. + * Les gains en vitesse seraient de toute façon assez faibles car les + * contextes sont de toute façon à peu près triés vu leur méthode de + * construction: les caractères sont ajoutés à la fin de la liste + */ +void ppm_worker::Context_Renorm(UINT ctx) { + NODE *n,*m; + UINT a,b,c,i,freq_tot,sf_nb; + SYMFREQ s,*p,tab_sf[SYM_NB]; + +#ifdef DEBUG + printf("Context_Renorm: c=%d\n",ctx); + Context_Print(ctx); +#endif + + n=&node_heap[ctx]; + freq_tot=0; + sf_nb=0; + + SF_Read(n,p, { + s=*p; + s.freq=s.freq/2; + if (s.freq!=0) { + freq_tot+=s.freq; + tab_sf[sf_nb]=s; + sf_nb++; + } + } ); + + + /* libération des noeuds utilisés pour stocker les symboles */ + if (n->hdr.sf_max>=HDR_SFNB) { + a=n->hdr.sf.l.sf_next; + do { + b=node_heap[a].sf.sf_next; + Node_Free(a); + a=b; + } while (a!=NIL); + } + + /* reconstruction de la liste des "sf_nb" symboles d'apres le tableau + * "tab_sf" + */ + + n->hdr.sf_max=sf_nb-1; + if (sf_nb<=HDR_SFNB) { + for(i=0;i<sf_nb;i++) n->hdr.sf.sf[i]=tab_sf[i]; + } else { + a=Node_Alloc(); + n->hdr.sf.l.sf_next=a; + n->hdr.sf.l.freq_tot=freq_tot; + m=&node_heap[a]; + i=0; + c=0; + while (1) { + m->sf.sf[c]=tab_sf[i]; + i++; + if (i==sf_nb) break; + c++; + if (c==NODE_SFNB) { + c=0; + a=Node_Alloc(); + m->sf.sf_next=a; + m=&node_heap[a]; + } + } + m->sf.sf_next=NIL; + } + +#ifdef DEBUG + Context_Print(ctx); +#endif +} + + +/* + * Mise à jour des index dans la table de hachage et des caractères du + * contexte courant. + * La fonction de hachage a été choisie de façon empirique en controlant + * qu'elle donne en moyenne de bons résultats. + */ +void ppm_worker::Hash_Update(int sym) { + UINT i,k; + + for(i=ORDER_MAX;i>=2;i--) + sym_context[i]=sym_context[i-1]; + sym_context[1]=sym; + + for(i=ORDER_MAX;i>=2;i--) { + k=sym_hash[i-1]; + sym_hash[i]=( (k<<6)-k+sym ) & (HASH_SIZE-1); + } + sym_hash[1]=sym+1; +} + + +/**************************************************************************** + * Système d'exclusion des symboles + ****************************************************************************/ + + +/* + * Remise à zéro du tableau d'exclusion des symboles + */ +void ppm_worker::Sym_ExcludeReset(void) { + UINT i; + + sym_excl_code++; + if (sym_excl_code==0) { + for(i=0;i<SYM_NB;i++) sym_excl[i]=0; + sym_excl_code=1; + } +} + + +/**************************************************************************** + * Initialisation et Libération mémoire + ****************************************************************************/ + +/* + * Initialisation des structures de données du compresseur/décompresseur + * retourne 0 si tout va bien + */ +int ppm_worker::PPM_Init(unsigned short NODE_NBMAX) { + UINT i; + node_heap= new NODE[NODE_NBMAX]; + hash_table= new USHORT[HASH_SIZE]; + if (node_heap==NULL || hash_table==NULL) { + if (node_heap!=NULL) delete [] node_heap; + if (hash_table!=NULL) delete [] hash_table; + return 1; + } + /* noeuds: tous vides */ + for(i=0;i<=(NODE_NBMAX-2);i++) node_heap[i].free_next=i+1; + node_heap[NODE_NBMAX-1].free_next=NIL; + node_free_first=0; + node_free_last=NODE_NBMAX-1; + node_free_nb=NODE_NBMAX; + + /* contextes */ + for(i=0;i<HASH_SIZE;i++) hash_table[i]=HASH_ADDRESS+i; + + /* cette initialisation n'est pas sûre mais simplifie beaucoup le code: + * on suppose que le premier contexte sera alloué dans le noeud 0 + */ + ctx_first=0; + ctx_last=0; + ctx_nb=0; + + /* contexte courant */ + for(i=0;i<=ORDER_MAX;i++) sym_context[i]=0; + for(i=0;i<=ORDER_MAX;i++) sym_hash[i]=0; + + /* système d'exclusion des caractères */ + sym_excl_code=0xFF; + + return 0; +} + +/* + * Fin de la compression/décompression: on libère la mémoire + */ +void ppm_worker::PPM_End(void) { + free(hash_table); + free(node_heap); +} + +/**************************************************************************** + * Décodage et décompression + ****************************************************************************/ + +/* + * Décodage: cf Encode_NewSym + */ +int ppm_worker::Decode_NewSym(void) { + UINT i,freq_tot,freq_cum,f; + UCHAR code; + + code=sym_excl_code; + freq_tot=0; + for(i=0;i<SYM_NB;i++) if (sym_excl[i]!=code) freq_tot++; + f=arith.Arith_DecodeVal(freq_tot+SYM_SPECIAL_NB); + if (f>=freq_tot) { + /* cas d'un symbole spécial */ + arith.Arith_Decode(f,f+1,freq_tot+SYM_SPECIAL_NB); + return SYM_NB+f-freq_tot; + } else { + i=0; + freq_cum=0; + while (1) { + if (sym_excl[i]!=code) { + freq_cum++; + if (freq_cum>f) break; + } + i++; + } + arith.Arith_Decode(freq_cum-1,freq_cum,freq_tot+SYM_SPECIAL_NB); + return i; + } +} + +/* + * Décodage: cf Decode_NoExclude + */ +int ppm_worker::Decode_NoExclude(UINT ctx) { + NODE *n; + UCHAR code; + UINT i,f,freq_tot,freq_cum,freq_sym,sf_nb; + SYMFREQ *p,s; + + + n=&node_heap[ctx]; + code=sym_excl_code; + + /* Calcul de la somme des fréquences des caractères */ + if (n->hdr.sf_max<HDR_SFNB) { + freq_tot=0; + for(i=0;i<=n->hdr.sf_max;i++) freq_tot+=n->hdr.sf.sf[i].freq; + } else { + freq_tot=n->hdr.sf.l.freq_tot; + } + + /* décodage */ + sf_nb=(UINT) n->hdr.sf_max+1; + f=arith.Arith_DecodeVal(freq_tot+sf_nb); + if (f>=freq_tot) { + /* gestion du code ESCAPE */ + + /* marquage des caractères utilisés */ + SF_Read(n,p, { sym_excl[p->sym]=code; }); + + /* décodage ESCAPE */ + arith.Arith_Decode(freq_tot,freq_tot+sf_nb,freq_tot+sf_nb); + return SYM_ESCAPE; + } + + /* recherche du caractère en calculant la fréquence */ + freq_cum=0; + SF_Read(n,p, { + s=*p; + freq_cum+=s.freq; + if (freq_cum>f) goto decode_sym; + } ); + + decode_sym: + + freq_sym=s.freq; + p->freq=freq_sym+1; + if (n->hdr.sf_max>=HDR_SFNB) n->hdr.sf.l.freq_tot=freq_tot+1; + + arith.Arith_Decode(freq_cum-freq_sym,freq_cum,freq_tot+sf_nb); + + /* test de la renormalisation */ + if (freq_sym==(RENORM_FREQSYM-1) || freq_tot>=RENORM_FREQTOT) { + Context_Renorm(ctx); + } + return s.sym; +} + + +/* + * Décodage: cf Encode_Exclude + */ + +int ppm_worker::Decode_Exclude(UINT ctx) { + UINT sf_nb,freq_sym,freq_cum,freq_tot,f; + NODE *n; + SYMFREQ s,*p; + UCHAR code; + + n=&node_heap[ctx]; + code=sym_excl_code; + + freq_tot=0; + sf_nb=0; + + SF_Read( n,p, { + s=*p; + if (sym_excl[s.sym]!=code) + { + freq_tot+=s.freq; + sf_nb++; + } + } ); + + + f=arith.Arith_DecodeVal(freq_tot+sf_nb); + + if (f>=freq_tot) { + + /* ESCAPE */ + + SF_Read(n,p, { sym_excl[p->sym]=code; } ); + + arith.Arith_Decode(freq_tot,freq_tot+sf_nb,freq_tot+sf_nb); + + return SYM_ESCAPE; + } else { + + /* recherche du caractère */ + + freq_cum=0; + SF_Read(n,p, { + s=*p; + if (sym_excl[s.sym]!=code) { + freq_cum+=s.freq; + if (freq_cum>f) goto decode_sym; + } + } ); + + decode_sym: + + /* incrémentation de la fréquence */ + + freq_sym=p->freq; + p->freq=freq_sym+1; + if (n->hdr.sf_max>=HDR_SFNB) n->hdr.sf.l.freq_tot++; + + /* décodage du caractère */ + + arith.Arith_Decode(freq_cum-freq_sym,freq_cum,freq_tot+sf_nb); + + if (freq_sym==(RENORM_FREQSYM-1) || freq_tot>=RENORM_FREQTOT) { + Context_Renorm(ctx); + } + + return s.sym; + } +} + + +/* + * Décodage d'un symbole + */ +int ppm_worker::PPM_Decode(void) { + int i,order,sym; + UINT ctx,ctx_tab[ORDER_MAX+1],ctx_last; + + + /* recherche de l'ordre maximum */ + + Sym_ExcludeReset(); + order=ORDER_MAX; + ctx_last=NIL; + while (1) { + ctx=Context_Search(order); + ctx_tab[order]=ctx; + if (ctx<HASH_ADDRESS) { + Context_MoveFirst(ctx); + if (ctx_last==NIL) + sym=Decode_NoExclude(ctx); + else + sym=Decode_Exclude(ctx); + if (sym!=SYM_ESCAPE) break; + ctx_last=ctx; + } + order--; + if (order==-1) { + sym=Decode_NewSym(); + if (sym>=SYM_NB) return sym; + break; + } + } + + for(i=order+1;i<=ORDER_MAX;i++) { + if (ctx_tab[i]>=HASH_ADDRESS) + Context_New(sym,i); + else + Context_NewSym(sym,ctx_tab[i]); + } + + Hash_Update(sym); + + return sym; +} + +/* + * Décompression: idem + */ + +#ifdef STAT + +/**************************************************************************** + * Statistiques + ****************************************************************************/ + + +void ppm_worker::PrintStat(void) { + fprintf(stderr,"free=%d ctx_nb=%d hash_moy=%0.2f\n", + node_free_nb,ctx_nb, + (float)hash_cnt/(float)hash_nb); + +} + +/* + * Impression d'un caractère + */ +void ppm_worker::Sym_Print(int c) { + if (c>=32 && c<=126) printf("%c",c); else printf("\\%2X",c); +} + +/* + * Impression couple SYMFREQ + */ + +void ppm_worker::SF_Print(SYMFREQ s) { + Sym_Print(s.sym); + printf(":%d ",s.freq); +} + +/* + * Impression du contenu d'un contexte + * utilisé pour les tests + */ + +void ppm_worker::Context_Print(UINT c) { + NODE *n; + int i,sf_max,sf_nb,sf_freq; + + n=&node_heap[c]; + + sf_max=n->hdr.sf_max; + sf_nb=sf_max+1; + if (sf_max>=2) sf_freq=n->hdr.sf.l.freq_tot; + else { + sf_freq=0; + for(i=0;i<=sf_max;i++) sf_freq+=n->hdr.sf.sf[i].freq; + } + + printf("Ctx=%d: hash_n=%d ctx_p=%d ctx_n=%d o=%d sf_nb=%d sf_freq=%d\n", + c,n->hdr.hash_next,n->hdr.ctx_prev,n->hdr.ctx_next, + n->hdr.order,sf_nb,sf_freq); + for(i=0;i<n->hdr.order;i++) Sym_Print(n->hdr.sym[i]); + printf(": "); + if (sf_max<=1) { + for(i=0;i<=sf_max;i++) SF_Print(n->hdr.sf.sf[i]); + } else { + n=&node_heap[n->hdr.sf.l.sf_next]; + i=0; + while (1) { + SF_Print(n->sf.sf[i]); + if (sf_max==0) break; + i++; + sf_max--; + if (i==NODE_SFNB) { + i=0; + n=&node_heap[n->sf.sf_next]; + } + } + } + printf("\n"); +} + + +/* + * Nombre total de contextes et nombre de contextes de longueur données. + * Utilisé pour les statistiques + */ + +void ppm_worker::Context_Statistic(void) { + UINT i,p; + int tab[SYM_NB+1],tot,cnt; + + for(i=0;i<=SYM_NB;i++) tab[i]=0; + tot=0; + + p=ctx_first; + do { + cnt=node_heap[p].hdr.sf_max+1; + tab[cnt]++; + tot++; + p=node_heap[p].hdr.ctx_next; + } while (p!=ctx_last); + + + printf("Context_Statistic: "); + for(i=1;i<=SYM_NB;i++) { + printf("%d:%d (%0.2f%%),",i,tab[i],(float)tab[i]/(float)tot*100.0); + } + printf("\n"); +} + +#endif + diff --git a/noncore/apps/opie-reader/ppm.h b/noncore/apps/opie-reader/ppm.h new file mode 100644 index 0000000..4df9085 --- a/dev/null +++ b/noncore/apps/opie-reader/ppm.h @@ -0,0 +1,179 @@ +#include "utypes.h" + +#ifndef PPM_H + +#define PPM_H + +#include "arith.h" + +/* pour le calcul éventuel de quelques statistiques */ +/* #define STAT */ + +/* mise en mode debogage */ +/* #define DEBUG */ + +/* nombre de noeuds maximum: peut être modifié, mais doit être tel que: + * HASH_SIZE+NODE_NBMAX<65530 + */ +//#define NODE_NBMAX 40000 + +/* + * taille des buffers d'entrée/sortie + */ +#define BUFSIZE 1024 + +/* + * Taille de la table de hachage + */ +#define HASH_SIZE 16384 + +/* ordre maximale de prédiction utilisé (Phi) */ +#define ORDER_MAX 4 + +/* fréquence maximale d'un symbole */ +#define RENORM_FREQSYM 250 + +/* fréquence maximale pour la somme des fréquences des symboles d'un contexte */ +#define RENORM_FREQTOT 15000 + +/* nombre de couples symbole,fréquence dans les structures de noeuds + * ajusté pour faire au total 16 octets */ +#define NODE_SFNB 7 +#define HDR_SFNB 2 + +/* nombre de symboles à coder sans compter les symboles spéciaux */ +#define SYM_NB 256 + +/* nombre de symboles spéciaux: pour extension si besoin de signalisation */ +#define SYM_SPECIAL_NB 1 + +/* code associé au symbole ESCAPE (jamais codé de façon explicite) */ +#define SYM_ESCAPE 256 + +/* code de fin de fichier */ +#define SYM_EOF 256 + +/* valeur NULL pour les pointeurs stockés dans des USHORT */ +#define NIL 0xFFFF + +/* codage de NIL utilisé pour retrouver l'adresse dans la table de hachage + * d'un contexte en regardant seulement CTXHDR.hash_next */ +#define HASH_ADDRESS (65530-HASH_SIZE) + + +/* stockage d'un couple symbole, fréquence */ +typedef struct { + UCHAR sym; /* numéro du symbole */ + UCHAR freq; /* fréquence du symbole */ +} SYMFREQ; + + +/* header pour gérer un contexte */ +typedef struct { + USHORT ctx_next; /* contexte suivant (moins utilisé) */ + USHORT ctx_prev; /* contexte précédent (plus utilisé) */ + USHORT hash_next; /* contexte suivant dans une entrée de la table + * de hachage */ + UCHAR order; /* ordre du contexte */ + UCHAR sym[ORDER_MAX]; /* symboles constituant le contexte */ + UCHAR sf_max; /* nombre de symboles-1 dans la liste L */ + union { + SYMFREQ sf[HDR_SFNB]; /* s'il y a moins de HDR_SFNB symboles dans + * le contexte, on les stocke directement ici + */ + struct { + USHORT freq_tot; /* sinon on stocke la fréquence totale (c) */ + USHORT sf_next; /* et un pointeur sur le premier noeud + * constituant la liste L des symboles associés + * au contexte */ + } l; + } sf; +} CTXHDR; + +/* structure pour gérer NODE_SFNB éléments de la liste des symboles associés + * à un contexte */ +typedef struct { + SYMFREQ sf[NODE_SFNB]; /* les couples symbole, fréquence */ + USHORT sf_next; /* pointeur sur l'éventuel bloc suivant */ +} CTXSYMFREQ; + +/* + * structure de base pour la gestion de la mémoire: le noeud + */ + +typedef union _NODE { + CTXHDR hdr; /* si le noeud contient un header de contexte */ + CTXSYMFREQ sf; /* si le noeud contient une partie de la liste L */ + USHORT free_next; /* si le noeud est vide: pointeur sur un noeud vide + * suivant */ +} NODE; + +class ppm_worker +{ + +/* gestion des noeuds */ +NODE *node_heap; /* heap contenant tous les noeuds */ +UINT node_free_nb; /* nombre de noeuds vides */ +UINT node_free_first; /* premier noeud de la liste des noeuds vides */ +UINT node_free_last; /* dernier noeud de la liste des noeuds vides */ + +/* gestion de la liste des contextes les plus utilisés */ +USHORT *hash_table; /* table de hachage pour rechercher un contexte */ +UINT ctx_first; /* premier contexte: le plus utilisé */ +UINT ctx_last; /* dernier contexte: le moins utilisé */ +UINT ctx_nb; /* nombre de contextes */ + +/* données caractérisant le contexte courant */ +UCHAR sym_context[ORDER_MAX+1]; /* symboles précédants le symbole en cours + * de codage */ +int sym_hash[ORDER_MAX+1]; /* index dans la table de hachage + * correspondants aux différentes longueurs + * de contextes + */ + +/* système d'exclusion des caractères */ +UCHAR sym_excl[SYM_NB]; /* tableau pour l'exclusion */ +UCHAR sym_excl_code; /* code courant pour l'exclusion */ + + +/* déclaration des fonctions de base */ + +/* noeuds */ +void Node_Free(UINT p); +UINT Node_Alloc(void); + +/* contextes */ +void Context_DeleteLast(void); +void Context_MoveFirst(UINT c); +void Context_New(int sym,int order); +void Context_NewSym(int sym,UINT c); +UINT Context_Search(int order); +void Context_Renorm(UINT ctx); +void Hash_Update(int sym); + void Sym_ExcludeReset(void); + +/* codage */ +/* +void Encode_NewSym(int sym); +int Encode_NoExclude(int sym,UINT ctx); +int Decode_Exclude(UINT ctx); +int PPM_Decode(void); +*/ + +/* décodage */ +int Decode_NewSym(void); +int Decode_NoExclude(UINT ctx); +int Decode_Exclude(UINT ctx); + +#ifdef STAT +void PrintStat(void); +#endif + public: + ArithClass arith; + int PPM_Init(unsigned short); + void PPM_End(void); + int PPM_Decode(void); +}; + +#endif + diff --git a/noncore/apps/opie-reader/ppm_expander.cpp b/noncore/apps/opie-reader/ppm_expander.cpp new file mode 100644 index 0000000..4f0a277 --- a/dev/null +++ b/noncore/apps/opie-reader/ppm_expander.cpp @@ -0,0 +1,108 @@ +/* + * Interface pour le programme de compression + * (c) 1995 Fabrice Bellard + */ + +#include <stdlib.h> +//#include <unistd.h> +#include <stdio.h> +#include <string.h> +#include <time.h> + +/*************************************************************************** + * Interface avec les routines de compression + */ + +#define METHOD_NB 2 /* nombre total de méthodes de compression */ + +#define METHOD_STORE 0 +#define METHOD_PPM 1 + + +#define DEFAULT_SUFFIX ".st" /* extension par défault */ +/* signature en début de fichier */ +#define STAT_MAGIC_SIZE 4 +char stat_magic[STAT_MAGIC_SIZE]={'P','P','M','S'}; + +#include "ppm_expander.h" + +ppm_expander::~ppm_expander() { + if (needppmend) ppm.PPM_End(); + ppm.arith.Arith_DecodeEnd(); + if (buf_in!=NULL) delete [] buf_in; + if (buf_out!=NULL) delete [] buf_out; + if (my_read_buf != NULL) delete my_read_buf; + if (my_file_in != NULL) fclose(my_file_in); +} + +int ppm_expander::openfile(const char* infile) +{ + my_file_in=fopen(infile,"rb"); + my_read_buf = new PPM_ReadBuf(my_file_in); + return home(); +} + +void ppm_expander::sizes(unsigned long& file, unsigned long& text) +{ + struct stat _stat; + fstat(fileno(my_file_in),&_stat); + file = _stat.st_size; + text = numblocks*blocksize; +} + +int ppm_expander::home() +{ + fseek(my_file_in,0, SEEK_SET); + unsigned char header[STAT_MAGIC_SIZE]; + size_t len=fread(header,1,STAT_MAGIC_SIZE,my_file_in); + if (strncmp((char*)header,stat_magic,STAT_MAGIC_SIZE)!=0) { + return 1; + } + if (len!=(STAT_MAGIC_SIZE)) { + return 1; + } + if (fread(&maxnode,sizeof(maxnode),1,my_file_in) != 1) return 1; + if (fread(&blocksize,sizeof(blocksize),1,my_file_in) != 1) return 1; + if (fread(&numblocks,sizeof(numblocks),1,my_file_in) != 1) return 1; + //fprintf(stderr,"<%u,%u,%u>\n",maxnode,blocksize,numblocks); + int err = locate(0,0); + outbytes = 0; + return err; +} + +void ppm_expander::locate(unsigned int n) { + locate(n/blocksize, n%blocksize); + outbytes = n; +} + +int ppm_expander::locate(unsigned short block, unsigned int n) +{ + if (needppmend) + { + ppm.PPM_End(); + needppmend = false; + } + size_t fpos; + fseek(my_file_in,STAT_MAGIC_SIZE+sizeof(maxnode)+sizeof(blocksize)+sizeof(numblocks)+block*sizeof(fpos),SEEK_SET); + if (fread(&fpos,sizeof(fpos),1,my_file_in) != 1) return 1; + fseek(my_file_in,fpos,SEEK_SET); + + ppm.arith.Arith_DecodeInit(my_read_buf,buf_in,bufsize); + int err=ppm.PPM_Init(maxnode); + needppmend = true; + curblock = block; + for (int i = 0; i < n; i++) getch(); +} + +int ppm_expander::getch() { + if (curblock >= numblocks) return EOF; + int c=ppm.PPM_Decode(); + if (c == SYM_EOF) + { + if (++curblock >= numblocks) return EOF; + locate(curblock,0); + c = ppm.PPM_Decode(); + } + outbytes++; + return (c==SYM_EOF) ? EOF : c; +} diff --git a/noncore/apps/opie-reader/ppm_expander.h b/noncore/apps/opie-reader/ppm_expander.h new file mode 100644 index 0000000..ce95db7 --- a/dev/null +++ b/noncore/apps/opie-reader/ppm_expander.h @@ -0,0 +1,46 @@ +#ifndef __ppm_expander_h +#define __ppm_expander_h + +#include "CExpander.h" +#include <sys/stat.h> + + +#include "utypes.h" +#include "ppm.h" +#include "arith.h" + + +#define SYM_EOF 256 + +class ppm_expander : public CExpander { + UCHAR *buf_in,*buf_out; + unsigned int bufsize; + unsigned int outbytes; + unsigned long blocksize; + unsigned short numblocks; + unsigned short curblock; + unsigned short maxnode; + bool needppmend; + int home(); + FILE* my_file_in; + PPM_ReadBuf* my_read_buf; + ppm_worker ppm; + public: + ppm_expander() : needppmend(false), my_file_in(NULL), my_read_buf(NULL) + { + bufsize = 1024; + buf_in = new UCHAR[bufsize]; + buf_out = new UCHAR[bufsize]; + outbytes = 0; + } + virtual int openfile(const char* infile); + virtual int getch(); + int locate(unsigned short block, unsigned int n); + virtual ~ppm_expander(); + virtual unsigned int locate() { return outbytes; } + virtual void locate(unsigned int n); + virtual bool hasrandomaccess() { return (numblocks > 1); } + virtual void sizes(unsigned long& file, unsigned long& text); +}; + +#endif diff --git a/noncore/apps/opie-reader/update.sh b/noncore/apps/opie-reader/update.sh new file mode 100755 index 0000000..05dc175 --- a/dev/null +++ b/noncore/apps/opie-reader/update.sh @@ -0,0 +1,11 @@ +#!/bin/bash +cp /home/tim/uqtreader/uqtreader.desktop /opt/Qtopia/apps/Applications/ +cp /home/tim/bin/uqtreader /opt/Qtopia/bin/ +cp /home/tim/uqtreader/uqtreader.png /opt/Qtopia/pics/ +cp /home/tim/qtreader/panel-arrow-down.png /opt/Qtopia/pics/ +cp /home/tim/uqtreader/uqtreader.desktop /opt/Qtopia/sharp/apps/Applications/ +cp /home/tim/bin/uqtreader /opt/Qtopia/sharp/bin/ +cp /home/tim/uqtreader/uqtreader.png /opt/Qtopia/sharp/pics/ +cp /home/tim/qtreader/panel-arrow-down.png /opt/Qtopia/sharp/pics/ +#source /home/tim/bin/setz.sh +#mkipks qpe-qtreader.control diff --git a/noncore/apps/opie-reader/ustring.h b/noncore/apps/opie-reader/ustring.h new file mode 100644 index 0000000..a4dc048 --- a/dev/null +++ b/noncore/apps/opie-reader/ustring.h @@ -0,0 +1,71 @@ +#include <qstring.h> + +#ifdef _UNICODE +inline size_t ustrlen(const tchar* _p) +{ + if (_p == NULL) return 0; + const tchar *p = _p; + while (*p != 0) + { + p++; +/* + if (p - _p == 20) + { + printf("ustrlen::String too long:"); + for (int i = 0; i < 20; i++) printf("%c",_p[i]); + printf("\n"); + } +*/ + } + return p - _p; +} + +inline int ustrcmp(const tchar* _p1, const tchar* _p2) +{ + if (_p1 == 0) return 1; + if (_p2 == 0) return -1; + const tchar* p1 = _p1, *p2 = _p2; + while (*p1 != 0) + { +/* + if (p1 - _p1 == 20) + { + printf("ustrcmp::String too long:"); + for (int i = 0; i < 20; i++) printf("%c",_p1[i]); + printf("\n"); + } +*/ + if (*p1 < *p2) return -1; + if (*p1 > *p2) return 1; + if (*p2 == 0) return 1; + p1++, p2++; + } + if (*p2 != 0) return -1; + return 0; +} + +inline QString toQString(tchar *_p) +{ + if (_p == NULL) return 0; + int i = 0; + tchar *p = _p; + QString ret; + while (*p != 0) ret[i++] = *(p++); + return ret; +} + +inline QString toQString(tchar *_p, unsigned int len) +{ + if (_p == NULL) return 0; + unsigned int i = 0; + tchar *p = _p; + QString ret; + while (*p != 0 && i < len) ret[i++] = *(p++); + return ret; +} +#else + +inline size_t ustrlen(const tchar* _p) { return strlen(_p); } +inline int ustrcmp(const tchar* _p1, const tchar* _p2) { return strcmp(_p1, _p2); } + +#endif diff --git a/noncore/apps/opie-reader/utypes.h b/noncore/apps/opie-reader/utypes.h new file mode 100644 index 0000000..b7c59f3 --- a/dev/null +++ b/noncore/apps/opie-reader/utypes.h @@ -0,0 +1,14 @@ +/* + * Quelques types utiles + */ + +#ifndef UTYPES_H + +#define UTYPES_H + +typedef unsigned char UCHAR; +typedef unsigned short USHORT; +typedef unsigned int UINT; + +#endif + diff --git a/noncore/apps/opie-reader/version.h b/noncore/apps/opie-reader/version.h new file mode 100644 index 0000000..bd32e4d --- a/dev/null +++ b/noncore/apps/opie-reader/version.h @@ -0,0 +1,3 @@ +#define MAJOR "0" +#define MINOR "3r" +#define RELEASE_TYPE "beta(U)" diff --git a/noncore/apps/opie-reader/ztxt.cpp b/noncore/apps/opie-reader/ztxt.cpp new file mode 100644 index 0000000..c30e4fd --- a/dev/null +++ b/noncore/apps/opie-reader/ztxt.cpp @@ -0,0 +1,159 @@ +#include <stdio.h> +#include <string.h> +#include "ztxt.h" + +ztxt::ztxt() : bInit(false), expandedtextbuffer(NULL), compressedtextbuffer(NULL) { /*printf("constructing:%x\n",fin);*/ } + + +int ztxt::openfile(const char *src) +{ + if (!Cpdb::openfile(src)) + { + return -1; + } + +//printf("Okay %u\n", 4); + + if (head.type != ZTXT_ID) return -1; + + gotorecordnumber(0); + fread(&hdr0, 1, sizeof(hdr0), fin); +//printf("Okay %u\n", 5); + buffersize = ntohl(hdr0.size); + compressedtextbuffer = new UInt8[buffersize]; + expandedtextbuffer = new UInt8[buffersize]; +//printf("Okay %u\n", 6); + + home(); +//printf("Okay %u\n", 7); + +// printf("Returning 0\n"); + + return 0; +} + +int ztxt::getch() +{ + if (bufferpos >= buffercontent) + { + size_t reclen = recordlength(++bufferrec); + if (reclen == 0) return -1; + gotorecordnumber(bufferrec); + fread(compressedtextbuffer, reclen, sizeof(char), fin); + + zstream.next_in = compressedtextbuffer; + zstream.next_out = expandedtextbuffer; + zstream.avail_out = buffersize; + zstream.avail_in = reclen; + + int ret = inflate(&zstream, Z_SYNC_FLUSH); + buffercontent = buffersize - zstream.avail_out; + bufferpos = 0; + + } + currentpos++; + return expandedtextbuffer[bufferpos++]; +} + +unsigned int ztxt::locate() +{ + return currentpos; +} + +void ztxt::locate(unsigned int n) +{ + + if (hasrandomaccess()) + { + bufferrec = n / ntohs(hdr0.recordSize) + 1; + if (bufferrec == 1) + { + inflateEnd(&zstream); + } + size_t reclen = recordlength(bufferrec); + if (reclen == 0) return; + gotorecordnumber(bufferrec); + fread(compressedtextbuffer, reclen, sizeof(char), fin); + + zstream.next_in = compressedtextbuffer; + zstream.next_out = expandedtextbuffer; + zstream.avail_out = buffersize; + zstream.avail_in = reclen; + + if (bufferrec == 1) + { + zstream.zalloc = Z_NULL; + zstream.zfree = Z_NULL; + zstream.opaque = Z_NULL; + + inflateInit(&zstream); + } + + + int ret = inflate(&zstream, Z_SYNC_FLUSH); + buffercontent = buffersize - zstream.avail_out; + bufferpos = 0; + currentpos = n - n % ntohs(hdr0.recordSize); + while (currentpos < n) getch(); + } + else + { + home(); + while (currentpos < n && getch() != EOF); + } +} + +void ztxt::home() +{ + if (bInit) + { + inflateEnd(&zstream); + } + bInit = true; + size_t reclen = recordlength(1); + gotorecordnumber(1); + fread(compressedtextbuffer, reclen, sizeof(char), fin); + + zstream.next_in = compressedtextbuffer; + zstream.next_out = expandedtextbuffer; + zstream.avail_out = buffersize; + zstream.avail_in = reclen; + + zstream.zalloc = Z_NULL; + zstream.zfree = Z_NULL; + zstream.opaque = Z_NULL; + +// printf("Initialising\n"); + + inflateInit(&zstream); + + int ret = inflate(&zstream, Z_SYNC_FLUSH); +// printf("Inflate : %d\n", ret); + bufferpos = 0; + bufferrec = 1; + currentpos = 0; + buffercontent = buffersize - zstream.avail_out; +// printf("buffercontent:%u\n", buffercontent); +} + +CList<Bkmk>* ztxt::getbkmklist() +{ + UInt16 recno = ntohs(hdr0.bookmarkRecord); + +// printf("Bookmarks - record %d contains %d\n", recno, ntohs(hdr0.numBookmarks)); + + if (recno == 0) return NULL; + + CList<Bkmk>* t = new CList<Bkmk>; + size_t cur = ftell(fin); + gotorecordnumber(recno); + for (int i = 0; i < ntohs(hdr0.numBookmarks); i++) + { + zTXTbkmk bkmk; + if (fread(&bkmk, sizeof(bkmk), 1, fin) != 1) break; +// printf("Bookmark number:%d:%.20s\n", i, bkmk.title); + t->push_back(Bkmk(bkmk.title, ntohl(bkmk.offset))); + } + fseek(fin, cur, SEEK_SET); + return t; +} diff --git a/noncore/apps/opie-reader/ztxt.h b/noncore/apps/opie-reader/ztxt.h new file mode 100644 index 0000000..b8ad29c --- a/dev/null +++ b/noncore/apps/opie-reader/ztxt.h @@ -0,0 +1,102 @@ +#ifndef __ztxt_h +#define __ztxt_h + +#include "CExpander.h" +#include <zlib.h> +#include "pdb.h" +/* + * Stuff common to both Weasel Reader and makeztxt + * + * $Id$ + * + */ + +#ifndef _WEASEL_COMMON_H_ +#define _WEASEL_COMMON_H_ 1 + + +/* Padding is no good */ +#if defined(__GNUC__) && defined(__UNIX__) +# pragma pack(2) +#endif + +/* The default creator is Weasel Reader 'GPlm' */ +#define GPLM_CREATOR_ID "GPlm" +/* Databases of type 'zTXT' */ +#define ZTXT_TYPE_ID "zTXT" +/* Size of one database record */ +#define RECORD_SIZE 8192 +/* Allow largest WBIT size for data. Lower with command line options + in makeztxt */ +#define MAXWBITS 15 +/* Max length for a bookmark/annotation title */ +#define MAX_BMRK_LENGTH 20 + + +/***************************************************** + * This is the zTXT document header (record #0) * + * ----zTXT version 1.42---- * + *****************************************************/ +typedef struct zTXT_record0Type { + UInt16 version; /* zTXT format version */ + UInt16 numRecords; /* Number of data (TEXT) records */ + UInt32 size; /* Size in bytes of uncomp. data */ + UInt16 recordSize; /* Size of a single data record */ + UInt16 numBookmarks; /* Number of bookmarks in DB */ + UInt16 bookmarkRecord; /* Record containing bookmarks */ + UInt16 numAnnotations; /* Number of annotation records */ + UInt16 annotationRecord; /* Record # of annotation index */ + UInt8 randomAccess; /* 1 if compressed w/Z_FULL_FLUSH */ + UInt8 padding[0x20 - 19]; /* Pad to a size of 0x20 bytes */ +} zTXT_record0; + +struct zTXTbkmk +{ + UInt32 offset; + tchar title[MAX_BMRK_LENGTH]; +}; + +#endif + + +const UInt32 ZTXT_ID = 0x5458547a; + +class ztxt : public CExpander, Cpdb +{ + bool bInit; + UInt32 buffersize; + UInt32 buffercontent; + UInt8* expandedtextbuffer; + UInt8* compressedtextbuffer; + z_stream zstream; + size_t bufferpos; + UInt16 bufferrec; + zTXT_record0 hdr0; + size_t currentpos; + void home(); + public: + virtual void sizes(unsigned long& _file, unsigned long& _text) + { + _file = file_length; + _text = ntohl(hdr0.size); + } + virtual bool hasrandomaccess() { return (hdr0.randomAccess != 0); } + virtual ~ztxt() + { + if (expandedtextbuffer != NULL) delete [] expandedtextbuffer; + if (compressedtextbuffer != NULL) delete [] compressedtextbuffer; + if (bInit) + { + inflateEnd(&zstream); + } + } + ztxt(); + virtual int openfile(const char *src); + virtual int getch(); + virtual unsigned int locate(); + virtual void locate(unsigned int n); + virtual CList<Bkmk>* getbkmklist(); +}; + +#endif + |