8 files changed, 48 insertions, 37 deletions

diff --git a/noncore/apps/opie-reader/BuffDoc.h b/noncore/apps/opie-reader/BuffDoc.h
index 29d0329..61531c0 100644
--- a/noncore/apps/opie-reader/BuffDoc.h
+++ b/noncore/apps/opie-reader/BuffDoc.h
@@ -43,33 +43,33 @@ class BuffDoc
     void suspend() { if (exp != NULL) exp->suspend(); }
     void unsuspend() { if (exp != NULL) exp->unsuspend(); }
 #else
     void suspend() {}
     void unsuspend() {}
 #endif
     ~BuffDoc()
         {
             delete filt;
             delete exp;
         }
     BuffDoc()
         {
             exp = NULL;
             filt = NULL;
             lastword.empty();
-        //    //    qDebug("Buffdoc created");
+        //    odebug << "Buffdoc created" << oendl;
         }
     bool empty() { return (exp == NULL); }
     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);
     tchar getch()
         {
             tchar ch = UEOF;
             CStyle sty;
diff --git a/noncore/apps/opie-reader/CEncoding.h b/noncore/apps/opie-reader/CEncoding.h
index 463fba9..df0104a 100644
--- a/noncore/apps/opie-reader/CEncoding.h
+++ b/noncore/apps/opie-reader/CEncoding.h
@@ -48,27 +48,27 @@ public:
 };
 
 class CAscii : public CEncoding
 {
 public:
     void getch(tchar& ch, CStyle& sty);
 };
 
 #include "CEncoding_tables.h"
 
 class CGeneral8Bit : public CEncoding
 {
     int m_index;
  public:
     CGeneral8Bit(int _i) : m_index(_i)
         {
-        //    qDebug("8Bit:%d", _i);
-        //    qDebug("%s", unicodetable::iterator(_i)->mime);
+//      odebug << "8Bit: " << _i << oendl;
+//      odebug << unicodetable::iterator(_i)->mime << oendl;
         }
     void getch(tchar& ch, CStyle& sty)
         {
             parent->getch(ch, sty);
             ch = unicodetable::unicodevalue(m_index, ch);
         }
 };
 
 #endif
diff --git a/noncore/apps/opie-reader/CExpander.h b/noncore/apps/opie-reader/CExpander.h
index 7b21d3e..9fae245 100644
--- a/noncore/apps/opie-reader/CExpander.h
+++ b/noncore/apps/opie-reader/CExpander.h
diff --git a/noncore/apps/opie-reader/Filedata.h b/noncore/apps/opie-reader/Filedata.h
index 096dd31..1b85b71 100644
--- a/noncore/apps/opie-reader/Filedata.h
+++ b/noncore/apps/opie-reader/Filedata.h
@@ -13,37 +13,37 @@ class CFiledata
             data = (unsigned char*)d;
             m_own = false;
         }
     CFiledata(time_t dt, tchar* nm)
         {
             int nlen = ustrlen(nm)+1;
             data = new unsigned char[sizeof(time_t)+sizeof(tchar)*nlen];
             *((time_t *)data) = dt;
             memcpy(data+sizeof(time_t), nm, sizeof(tchar)*nlen);
             m_own = true;
         }
     ~CFiledata()
         {
             if (m_own && data != NULL)
                 {
                     delete [] data;
-        //      qDebug("~Filedata: deleting");
+//      odebug << "~Filedata: deleting" << oendl;
                 }
             else
             {
-        //      qDebug("~Filedata: not deleting");
+//      odebug << "~Filedata: not deleting" << oendl;
             }
         }
     tchar* name() const { return (tchar*)(data+sizeof(time_t)); }
     time_t date() { return *((time_t *)data); }
     void setdate(time_t _t) { *((time_t *)data) = _t; }
     unsigned char* content() { return data; }
     size_t length() const { return sizeof(time_t)+sizeof(tchar)*(ustrlen(name())+1); }
     bool operator==(const CFiledata& rhs)
         {
             return ((length() == rhs.length()) && (memcmp(data, rhs.data, length()) == 0));
         }
     bool samename(const CFiledata& rhs)
         {
             return (ustrcmp((tchar *)(data+sizeof(time_t)),(tchar *)(rhs.data+sizeof(time_t))) == 0);
         }
 };
diff --git a/noncore/apps/opie-reader/FontControl.h b/noncore/apps/opie-reader/FontControl.h
index 5681496..e56b619 100644
--- a/noncore/apps/opie-reader/FontControl.h
+++ b/noncore/apps/opie-reader/FontControl.h
@@ -91,53 +91,53 @@ class FontControl
         {
 /*
             if (--m_size < 0)
             {
                 m_size = 0;
                 return false;
             }
             else return true;
 */
             if (g_size-- == m_size)
             {
                 if (--m_size < 0)
                 {
                     m_size = 0;
                 }
             }
-        //    qDebug("Font:%d Graphics:%d", m_size, g_size);
+//      odebug << "Font:" << m_size << " Graphics:" << g_size << oendl;
             return true;
         }
     bool increasesize()
         {
 /*
             if (++m_size >= m_maxsize)
             {
                 m_size = m_maxsize - 1;
                 return false;
             }
             else return true;
 */
             if (g_size++ == m_size)
             {
                 if (++m_size >= m_maxsize)
                 {
                     m_size = m_maxsize - 1;
                 }
             }
-        //    qDebug("Font:%d Graphics:%d", m_size, g_size);
+//      odebug << "Font:" << m_size << " Graphics:" << g_size << oendl;
             return true;
         }
     bool ChangeFont(QString& n)
         {
             return ChangeFont(n, currentsize());
         }
     bool ChangeFont(QString& n, int tgt);
     void setlead(int _lead)
         {
             m_leading = _lead;
         }
     int getlead()
         {
             return m_leading;
         }
     void setextraspace(int _lead)
diff --git a/noncore/apps/opie-reader/Palm2QImage.cpp b/noncore/apps/opie-reader/Palm2QImage.cpp
index 9339595..b0d4e00 100644
--- a/noncore/apps/opie-reader/Palm2QImage.cpp
+++ b/noncore/apps/opie-reader/Palm2QImage.cpp
@@ -1,28 +1,35 @@
 /* -*- mode: c; indent-tabs-mode: nil; -*- */
+
+/* OPIE */
+#include <opie2/odebug.h>
+
+/* QT */
+#include <qimage.h>
+
+/* STD */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifndef _WINDOWS
 #include <unistd.h>     /* for link */
 #endif
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdarg.h>
 
-#include <qimage.h>
 
 /***********************************************************************/
 /***********************************************************************/
 /*****                                                             *****/
 /*****   Code to decode the Palm image format to JPEG              *****/
 /*****                                                             *****/
 /***********************************************************************/
 /***********************************************************************/
 
 #define READ_BIGENDIAN_SHORT(p) (((p)[0] << 8)|((p)[1]))
 #define READ_BIGENDIAN_LONG(p)  (((p)[0] << 24)|((p)[1] << 16)|((p)[2] << 8)|((p)[3]))
 
 #define PALM_IS_COMPRESSED_FLAG        0x8000
 #define PALM_HAS_COLORMAP_FLAG        0x4000
 #define PALM_HAS_TRANSPARENCY_FLAG    0x2000
 #define PALM_DIRECT_COLOR_FLAG        0x0400
@@ -128,181 +135,185 @@ QImage* Palm2QImage
   *imagedatastart, *palmimage;
   ColorMapEntry *colormap;
 
   palmimage = image_bytes_in;
   width = READ_BIGENDIAN_SHORT(palmimage + 0);
   height = READ_BIGENDIAN_SHORT(palmimage + 2);
   bytes_per_row = READ_BIGENDIAN_SHORT(palmimage + 4);
   flags = READ_BIGENDIAN_SHORT(palmimage + 6);
   bits_per_pixel = palmimage[8];
   version = palmimage[9];
   next_depth_offset = READ_BIGENDIAN_SHORT(palmimage + 10);
   transparent_index = palmimage[12];
   compression_type = palmimage[13];
   /* bytes 14 and 15 are reserved by Palm and always 0 */
   
 #if 0
-//  qDebug ("Palm image is %dx%d, %d bpp, version %d, flags 0x%x, compression %d", width, height, bits_per_pixel, version, flags, compression_type);
+//  odebug << "Palm image is " << width << "x" << height
+//         << ", " << bits_per_pixel << " bpp, version " << version
+//         << ", flags 0x" << flags << ", compression " << compression_type << oendl;
 #endif
 
   if (compression_type == PALM_COMPRESSION_PACKBITS) {
-//    qDebug ("Image uses packbits compression; not yet supported");
+//    odebug << "Image uses packbits compression; not yet supported" << oendl;
     return NULL;
   } else if ((compression_type != PALM_COMPRESSION_NONE) &&
     (compression_type != PALM_COMPRESSION_RLE) &&
       (compression_type != PALM_COMPRESSION_SCANLINE)) {
-//    qDebug ("Image uses unknown compression, code 0x%x", compression_type);
+//    odebug << "Image uses unknown compression, code 0x" << compression_type << oendl;
     return NULL;
   }
 
   /* as of PalmOS 4.0, there are 6 different kinds of Palm pixmaps:
      
      1, 2, or 4 bit grayscale
      8-bit StaticColor using the Palm standard colormap
      8-bit PseudoColor using a user-specified colormap
      16-bit DirectColor using 5 bits for red, 6 for green, and 5 for blue
      
      Each of these can be compressed with one of four compression schemes,
      "RLE", "Scanline", "PackBits", or none.
      
      We begin by constructing the colormap.
      */
 
   if (flags & PALM_HAS_COLORMAP_FLAG) {
-//    qDebug("Palm images with custom colormaps are not currently supported.\n");
+//    odebug << "Palm images with custom colormaps are not currently supported." << oendl;
     return NULL;
   } else if (bits_per_pixel == 1) {
     colormap = Palm1BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 2) {
     colormap = Palm2BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 4) {
     colormap = Palm4BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 8) {
     colormap = Palm8BitColormap;
     imagedatastart = palmimage + 16;
   } else if (bits_per_pixel == 16 && (flags & PALM_DIRECT_COLOR_FLAG)) {
     colormap = NULL;
     palm_red_bits = palmimage[16];
     palm_green_bits = palmimage[17];
     palm_blue_bits = palmimage[18];
-//    qDebug("Bits:%d, %d, %d", palm_red_bits, palm_green_bits, palm_blue_bits);
+//    odebug << "Bits:" << palm_red_bits << ", " << palm_green_bits << ", " << palm_blue_bits << oendl;
     if (palm_blue_bits > 8 || palm_green_bits > 8 || palm_red_bits > 8) {
-//      qDebug("Can't handle this format DirectColor image -- too wide in some color (%d:%d:%d)\n", palm_red_bits, palm_green_bits, palm_blue_bits);
+//      odebug << "Can't handle this format DirectColor image -- too wide in some color ("
+//             << palm_red_bits << ":" << palm_green_bits << ":" << palm_blue_bits << oendl;
       return NULL;
     }
     if (bits_per_pixel > (8 * sizeof(unsigned long))) {
-//      qDebug ("Can't handle this format DirectColor image -- too many bits per pixel (%d)\n", bits_per_pixel);
+//      odebug << "Can't handle this format DirectColor image -- too many bits per pixel ("
+//             << bits_per_pixel << ")" << oendl;
       return NULL;
     }
     imagedatastart = palmimage + 24;
   } else {
-//    qDebug("Unknown bits-per-pixel of %d encountered.\n", bits_per_pixel);
+//    odebug << "Unknown bits-per-pixel of " << bits_per_pixel << " encountered" << oendl;
     return NULL;
   }
 
 #ifndef USEQPE
   QImage* qimage = new QImage(width, height, 32);
 #else
       QImage* qimage = new QImage(width, height, 16);
 #endif
 
   /* row by row, uncompress the Palm image and copy it to the JPEG buffer */
   rowbuf = new unsigned char[bytes_per_row * width];
   lastrow = new unsigned char[bytes_per_row * width];
 
   for (i=0, palm_ptr = imagedatastart , x_ptr = imagedata;  i < height;  ++i) {
-//        qDebug("inval:%x palm_ptr:%x x_ptr:%x bpr:%x", inval, palm_ptr, x_ptr, bytes_per_row);
+//        odebug << "inval:" << inval << " palm_ptr:" << palm_ptr << " x_ptr:" << x_ptr
+//               << " bpr:" << bytes_per_row << oendl;
 
     /* first, uncompress the Palm image */
     if ((flags & PALM_IS_COMPRESSED_FLAG) && (compression_type == PALM_COMPRESSION_RLE)) {
       for (j = 0;  j < bytes_per_row;  ) {
         incount = *palm_ptr++;
         inval = *palm_ptr++;
         memset(rowbuf + j, inval, incount);
         j += incount;
       }
     } else if ((flags & PALM_IS_COMPRESSED_FLAG) && (compression_type == PALM_COMPRESSION_SCANLINE)) {
       for (j = 0;  j < bytes_per_row;  j += 8) {
         incount = *palm_ptr++;
         inval = ((bytes_per_row - j) < 8) ? (bytes_per_row - j) : 8;
         for (inbit = 0;  inbit < inval;  inbit += 1) {
           if (incount & (1 << (7 - inbit)))
             rowbuf[j + inbit] = *palm_ptr++;
           else
             rowbuf[j + inbit] = lastrow[j + inbit];
         }
       }
       memcpy (lastrow, rowbuf, bytes_per_row);
     } else if (((flags & PALM_IS_COMPRESSED_FLAG) &&
                 (compression_type == PALM_COMPRESSION_NONE)) ||
                ((flags & PALM_IS_COMPRESSED_FLAG) == 0))
     {
         memcpy (rowbuf, palm_ptr, bytes_per_row);
         palm_ptr += bytes_per_row;
     }
     else {
-        qDebug("Case 4");
-        qDebug("Is compressed:%s", ((flags & PALM_IS_COMPRESSED_FLAG) == 0) ? "false" : "true");
-        qDebug("Has colourmap:%s", ((flags & PALM_HAS_COLORMAP_FLAG) == 0) ? "false" : "true");
-        qDebug("Has transparency:%s", ((flags & PALM_HAS_TRANSPARENCY_FLAG) == 0) ? "false" : "true");
-        qDebug("Direct colour:%s", ((flags & PALM_DIRECT_COLOR_FLAG) == 0) ? "false" : "true");
-        qDebug("four byte field:%s", ((flags & PALM_4_BYTE_FIELD_FLAG) == 0) ? "false" : "true");
+        odebug << "Case 4" << oendl;
+        odebug << "Is compressed:" << (((flags & PALM_IS_COMPRESSED_FLAG) == 0) ? "false" : "true") << oendl;
+        odebug << "Has colourmap:" << (((flags & PALM_HAS_COLORMAP_FLAG) == 0) ? "false" : "true") << oendl;
+        odebug << "Has transparency:" << (((flags & PALM_HAS_TRANSPARENCY_FLAG) == 0) ? "false" : "true") << oendl;
+        odebug << "Direct colour:" << (((flags & PALM_DIRECT_COLOR_FLAG) == 0) ? "false" : "true") << oendl;
+        odebug << "four byte field:" << (((flags & PALM_4_BYTE_FIELD_FLAG) == 0) ? "false" : "true") << oendl;
       memcpy (rowbuf, palm_ptr, bytes_per_row);
       palm_ptr += bytes_per_row;
     }
     /* next, write it to the GDK bitmap */
     if (colormap) {
       mask = (1 << bits_per_pixel) - 1;
       for (inbit = 8 - bits_per_pixel, inbyte = rowbuf, j = 0; j < width; ++j) {
         inval = ((*inbyte) & (mask << inbit)) >> inbit;
         /* correct for oddity of the 8-bit color Palm pixmap... */
         if ((bits_per_pixel == 8) && (inval == 0xFF)) inval = 231;
         /* now lookup the correct color and set the pixel in the GTK bitmap */
         QRgb colour = qRgb(colormap[inval].red, colormap[inval].green, colormap[inval].blue);
         qimage->setPixel(j, i, colour);
         if (!inbit) {
           ++inbyte;
           inbit = 8 - bits_per_pixel;
         } else {
           inbit -= bits_per_pixel;
         }
       }
     } else if (!colormap &&
       bits_per_pixel == 16) {
       for (inbyte = rowbuf, j = 0; j < width; ++j) {
         inval = ((unsigned short)inbyte[0] << (unsigned short)8) | inbyte[1];
 
 /*
-        qDebug ("pixel is %d,%d (%d:%d:%d)",
-                      j, i,
-                      ((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits),
-                      ((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits),
-                      ((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits));
+    odebug << "pixel is " << j << "," << i << " ("
+           << (((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits)) << ":"
+           << (((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits)) << ":"
+           << (((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits)) << ")" << oendl;
 */
         QRgb colour = qRgb(
             ((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits), 
             ((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits),
             ((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits));
         qimage->setPixel(j, i, colour);
         inbyte += 2;
       }
     }
   }
 
   delete [] rowbuf;
   delete [] lastrow;
 
   return qimage;
 }
 
 QImage* hRule(int w, int h, unsigned char r, unsigned char g, unsigned char b)
 {
-////    qDebug("hrule [%d, %d]", w, h);
+//    odebug << "hrule [" << w << ", " << h << "]" << oendl;
     QPixmap* qimage = new QPixmap(w, h);
     qimage->fill(QColor(r,g,b));
     QImage* ret = new QImage(qimage->convertToImage());
     delete qimage;
     return ret;
 }
diff --git a/noncore/apps/opie-reader/QTReader.h b/noncore/apps/opie-reader/QTReader.h
index dfbdfb9..f89de63 100644
--- a/noncore/apps/opie-reader/QTReader.h
+++ b/noncore/apps/opie-reader/QTReader.h
@@ -123,49 +123,49 @@ public:
         m_bpagemode = _b;
       }
     void setmono(bool _b)
       {
         m_bMonoSpaced = _b;
         ChangeFont(m_fontControl.currentsize());
         locate(pagelocate());
       }
     void setencoding(int _f)
         {
             m_encd = _f;
             setfilter(getfilter());
         }
     MarkupType PreferredMarkup();
     CEncoding* getencoding()
         {
-        //    qDebug("m_encd:%d", m_encd);
+//      odebug << "m_encd:" << m_encd << oendl;
             switch (m_encd)
             {
                 case 4:
-        //          qDebug("palm");
+//          odebug << "palm" << oendl;
                     return new CPalm;
                 case 1:
-        //          qDebug("utf8");
+//          odebug << "utf8" << oendl;
                     return new CUtf8;
                 case 2:
-        //          qDebug("ucs16be");
+//          odebug << "ucs16be" << oendl;
                     return new CUcs16be;
                 case 3:
-        //          qDebug("ucs16le");
+//          odebug << "ucs16le" << oendl;
                     return new CUcs16le;
                 case 0:
-        //          qDebug("ascii");
+//          odebug << "ascii" << oendl;
                     return new CAscii;
                 default:
                     return new CGeneral8Bit(m_encd-MAX_ENCODING+1);
             }
         }
   CFilterChain* getfilter()
   {
     CFilterChain * filt = new CFilterChain(getencoding());
     if (bstripcr) filt->addfilter(new stripcr);
 
     if (btextfmt || (bautofmt && (PreferredMarkup() == cTEXT))) filt->addfilter(new textfmt);
     if (bpeanut || (bautofmt && (PreferredMarkup() == cPML))) filt->addfilter(new PeanutFormatter);
     if (bstriphtml || (bautofmt && (PreferredMarkup() == cHTML))) filt->addfilter(new striphtml);
 
     if (bdehyphen) filt->addfilter(new dehyphen);
     if (bunindent) filt->addfilter(new unindent);
diff --git a/noncore/apps/opie-reader/QTReaderApp.h b/noncore/apps/opie-reader/QTReaderApp.h
index ab6f60e..fe3eebf 100644
--- a/noncore/apps/opie-reader/QTReaderApp.h
+++ b/noncore/apps/opie-reader/QTReaderApp.h
@@ -386,34 +386,34 @@ private slots:
     QMenuBar *mb;

 #else

     QMenuBar *mb;

 #endif

     QFloatBar *searchBar, *regBar/*, *m_fontBar*/;
     QToolBar /* *searchBar, *regBar,*/ *m_fontBar;
     QLineEdit *searchEdit, *regEdit;
     bool searchVisible;
     bool regVisible;
     bool m_fontVisible, m_twoTouch;
     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());
+//      odebug << "resize:(" << r->oldSize().width() << "," << r->oldSize().height() << ")" << oendl;
+//      odebug << "resize:(" << r->size().width() << "," << r->size().height() << ")" << oendl;
       //    bgroup->move( width()-bgroup->width(), 0 );
       }
     */
     CList<Bkmk>* pBkmklist;
     CList<Bkmk>* pOpenlist;
     infowin*  m_infoWin;
     GraphicWin* m_graphicwin;
     QProgressBar* pbar;
     bool m_fBkmksChanged;
 //    int m_nRegAction;
     regedit_type m_nRegAction;
     bkmk_action m_nBkmkAction;
     QString m_autogenstr;
     bool m_dontSave;
 };