9 files changed, 57 insertions, 32 deletions

diff --git a/core/apps/embeddedkonsole/TEScreen.cpp b/core/apps/embeddedkonsole/TEScreen.cpp
index 1db34d2..30ff49d 100644
--- a/core/apps/embeddedkonsole/TEScreen.cpp
+++ b/core/apps/embeddedkonsole/TEScreen.cpp
@@ -36,87 +36,87 @@
     Since the operations are called by a specific emulation decoder, one may
     collect their different operations here.
 
     The state manipulated by the operations is mainly kept in `image', though
     it is a little more complex bejond this. See the header file of the class.
 
     \sa TEWidget \sa VT102Emulation
 */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 // #include <kdebug.h>
 
 #include <assert.h>
 #include <string.h>
 #include <ctype.h>
 
 #include <qpe/config.h>
 #include "TEScreen.h"
 
 #define HERE printf("%s(%d): here\n",__FILE__,__LINE__)
 
 //FIXME: this is emulation specific. Use FALSE for xterm, TRUE for ANSI.
 //FIXME: see if we can get this from terminfo.
 #define BS_CLEARS FALSE
 
 #define loc(X,Y) ((Y) * columns + (X))
 
 /*! creates a `TEScreen' of `lines' lines and `columns' columns.
 */
 
-TEScreen::TEScreen(int lines, int columns)
+TEScreen::TEScreen(int _lines, int _columns) :
+  lines(_lines),
+  columns(_columns),
+  tabstops(0),
+  histCursor(0),
+  horzCursor(0)
 {
-  this->lines   = lines;
-  this->columns = columns;
 //  odebug << "Columns " << columns << "" << oendl; 
   
-  image      = (ca*) malloc(lines*columns*sizeof(ca));
-  tabstops   = NULL; initTabStops();
-
-  histCursor = 0;
-  horzCursor = 0;
+  image = new ca[lines*columns];
+  initTabStops();
 
   clearSelection();
   reset();
 }
 
 /*! Destructor
 */
 
 TEScreen::~TEScreen()
 {
-  free(image);
-  if (tabstops) free(tabstops);
+  delete [] image;
+  delete [] tabstops;
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /* Normalized                    Screen Operations                           */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 // Cursor Setting --------------------------------------------------------------
 
 /*! \section Cursor
 
     The `cursor' is a location within the screen that is implicitely used in
     many operations. The operations within this section allow to manipulate
     the cursor explicitly and to obtain it's value.
 
     The position of the cursor is guarantied to be between (including) 0 and
     `columns-1' and `lines-1'.
 */
 
 /*!
     Move the cursor up.
 
     The cursor will not be moved beyond the top margin.
 */
 
 void TEScreen::cursorUp(int n)
 //=CUU
 {
   if (n == 0) n = 1; // Default
   int stop = cuY < tmargin ? 0 : tmargin;
   cuX = QMIN(columns-1,cuX); // nowrap!
@@ -367,87 +367,87 @@ void TEScreen::restoreCursor()
   cu_fg   = sa_cu_fg;
   cu_bg   = sa_cu_bg;
   effectiveRendition();
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                             Screen Operations                             */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 /*! Assing a new size to the screen.
 
     The topmost left position is maintained, while lower lines
     or right hand side columns might be removed or filled with
     spaces to fit the new size.
 
     The region setting is reset to the whole screen and the
     tab positions reinitialized.
 */
 
 void TEScreen::resizeImage(int new_lines, int new_columns)
 {
     if (cuY > new_lines-1)  {
 // attempt to preserve focus and lines
         bmargin = lines-1; //FIXME: margin lost
         for (int i = 0; i < cuY-(new_lines-1); i++) {
             addHistLine(); scrollUp(horzCursor,1);
         }
     }
 
       // make new image
-    ca* newimg = (ca*)malloc( new_lines * new_columns * sizeof( ca));
+    ca* newimg = new ca[new_lines * new_columns];
 
     clearSelection();
 
       // clear new image
     for (int y = 0; y < new_lines; y++)
         for (int x = 0; x < new_columns; x++) {
             newimg[y*new_columns+x].c = ' ';
             newimg[y*new_columns+x].f = DEFAULT_FORE_COLOR;
             newimg[y*new_columns+x].b = DEFAULT_BACK_COLOR;
             newimg[y*new_columns+x].r = DEFAULT_RENDITION;
         }
     int cpy_lines   = QMIN(new_lines,  lines);
     int cpy_columns = QMIN(new_columns,columns);
       // copy to new image
     for (int y = 0; y < cpy_lines; y++)
         for (int x = 0; x < cpy_columns; x++) {
             newimg[y*new_columns+x].c = image[loc(x,y)].c;
             newimg[y*new_columns+x].f = image[loc(x,y)].f;
             newimg[y*new_columns+x].b = image[loc(x,y)].b;
             newimg[y*new_columns+x].r = image[loc(x,y)].r;
         }
-    free(image);
+    delete [] image;
     image = newimg;
     lines = new_lines;
     columns = new_columns;
     cuX = QMIN(cuX,columns-1);
     cuY = QMIN(cuY,lines-1);
 
       // FIXME: try to keep values, evtl.
     tmargin=0;
     bmargin=lines-1;
     initTabStops();
     clearSelection();
 }
 
 /*
    Clarifying rendition here and in TEWidget.
 
    currently, TEWidget's color table is
      0       1       2 .. 9    10 .. 17
      dft_fg, dft_bg, dim 0..7, intensive 0..7
 
    cu_fg, cu_bg contain values 0..8;
    - 0    = default color
    - 1..8 = ansi specified color
 
    re_fg, re_bg contain values 0..17
    due to the TEWidget's color table
 
    rendition attributes are
 
       attr           widget screen
       -------------- ------ ------
       RE_UNDERLINE     XX     XX    affects foreground only
@@ -478,65 +478,65 @@ void TEScreen::effectiveRendition()
   if (cu_re & RE_REVERSE)
   {
     ef_fg = cu_bg;
     ef_bg = cu_fg;
   }
   else
   {
     ef_fg = cu_fg;
     ef_bg = cu_bg;
   }
   if (cu_re & RE_BOLD)
   {
     if (ef_fg < BASE_COLORS)
       ef_fg += BASE_COLORS;
     else
       ef_fg -= BASE_COLORS;
   }
 }
 
 /*!
     returns the image.
 
     Get the size of the image by \sa getLines and \sa getColumns.
 
     NOTE that the image returned by this function must later be
     freed.
 
 */
 
 ca* TEScreen::getCookedImage()
 {
  int x,y;
-  ca* merged = (ca*)malloc(lines*columns*sizeof(ca));
+  ca* merged = new ca[lines*columns];
   ca dft(' ',DEFAULT_FORE_COLOR,DEFAULT_BACK_COLOR,DEFAULT_RENDITION);
 
   if (histCursor > hist.getLines()) {
     histCursor = hist.getLines();
   }
 
   for (y = 0; (y < lines) && (y < (hist.getLines()-histCursor)); y++)
   {
     int len = QMIN(columns,hist.getLineLen(y+histCursor));
     int yp  = y*columns;
     int yq  = (y+histCursor)*columns;
 
     hist.getCells(y+histCursor,0,len,merged+yp);
     for (x = len; x < columns; x++) merged[yp+x] = dft;
     for (x = 0; x < columns; x++)
     {   int p=x + yp; int q=x + yq;
         if ( ( q >= sel_TL ) && ( q <= sel_BR ) )
           reverseRendition(&merged[p]); // for selection
     }
   }
   if (lines >= hist.getLines()-histCursor)
   {
     for (y = (hist.getLines()-histCursor); y < lines ; y++)
     {
        int yp  = y*columns;
        int yq  = (y+histCursor)*columns;
        int yr =  (y-hist.getLines()+histCursor)*columns;
        for (x = 0; x < columns; x++)
        { int p = x + yp; int q = x + yq; int r = x + yr;
          merged[p] = image[r];
          if ( q >= sel_TL && q <= sel_BR )
            reverseRendition(&merged[p]); // for selection
@@ -594,66 +594,68 @@ void TEScreen::clear()
 
 /*! Moves the cursor left one column.
 */
 
 void TEScreen::BackSpace()
 {
   cuX = QMAX(0,cuX-1);
   if (BS_CLEARS) image[loc(cuX,cuY)].c = ' ';
 }
 
 /*!
 */
 
 void TEScreen::Tabulate()
 {
   // note that TAB is a format effector (does not write ' ');
   cursorRight(1); while(cuX < columns-1 && !tabstops[cuX]) cursorRight(1);
 }
 
 void TEScreen::clearTabStops()
 {
   for (int i = 0; i < columns; i++) tabstops[i-1] = FALSE;
 }
 
 void TEScreen::changeTabStop(bool set)
 {
   if (cuX >= columns) return;
   tabstops[cuX] = set;
 }
 
 void TEScreen::initTabStops()
 {
-  if (tabstops) free(tabstops);
-  tabstops = (bool*)malloc(columns*sizeof(bool));
+  if (tabstops)
+    delete [] tabstops;
+
+  tabstops = new bool[columns];
   // Arrg! The 1st tabstop has to be one longer than the other.
   // i.e. the kids start counting from 0 instead of 1.
   // Other programs might behave correctly. Be aware.
   for (int i = 0; i < columns; i++) tabstops[i] = (i%8 == 0 && i != 0);
 }
 
 /*!
    This behaves either as IND (Screen::Index) or as NEL (Screen::NextLine)
    depending on the NewLine Mode (LNM). This mode also
    affects the key sequence returned for newline ([CR]LF).
 */
 
 void TEScreen::NewLine()
 {
   if (getMode(MODE_NewLine)) Return();
   index();
 }
 
 /*! put `c' literally onto the screen at the current cursor position.
 
     VT100 uses the convention to produce an automatic newline (am)
     with the *first* character that would fall onto the next line (xenl).
 */
 
 void TEScreen::checkSelection(int from, int to)
 {
   if (sel_begin == -1) return;
   int scr_TL = loc(0, hist.getLines());
   //Clear entire selection if it overlaps region [from, to]
   if ( (sel_BR > (from+scr_TL) )&&(sel_TL < (to+scr_TL)) )
   {
     clearSelection();
diff --git a/inputmethods/dasher/PPMLanguageModel.cpp b/inputmethods/dasher/PPMLanguageModel.cpp
index 137b07f..d767d16 100644
--- a/inputmethods/dasher/PPMLanguageModel.cpp
+++ b/inputmethods/dasher/PPMLanguageModel.cpp
@@ -30,73 +30,74 @@ CPPMLanguageModel::CPPMnode *CPPMLanguageModel::CPPMnode::find_symbol(int sym)
                 found=found->next;
         }
         return 0;
 }
 
 
 CPPMLanguageModel::CPPMnode * CPPMLanguageModel::CPPMnode::add_symbol_to_node(int sym,int *update)
 {
         CPPMnode *born,*search;
         search=find_symbol(sym);
         if (!search) {
                 born = new CPPMnode(sym);
                 born->next=child;
                 child=born;
                 //   node->count=1;
                         return born;    
         } else {
                 if (*update) {   // perform update exclusions
                         search->count++;
                         *update=0;
                 }
                 return search;
         }
         
 }
 
 
 /////////////////////////////////////////////////////////////////////
 // CPPMLanguageModel defs
 /////////////////////////////////////////////////////////////////////
 
 CPPMLanguageModel::CPPMLanguageModel(CAlphabet *_alphabet,int _normalization)
-        : CLanguageModel(_alphabet,_normalization)
+        : CLanguageModel(_alphabet,_normalization), root(0), m_rootcontext(0)
 {
         root=new CPPMnode(-1);
         m_rootcontext=new CPPMContext(root,0);
 }
 
 
 CPPMLanguageModel::~CPPMLanguageModel()
 {
+        delete m_rootcontext;
         delete root;
 }
 
 
 bool CPPMLanguageModel::GetProbs(CContext *context,vector<unsigned int> &probs,double )
         // get the probability distribution at the context
 {
         // seems like we have to have this hack for VC++
         CPPMContext *ppmcontext=static_cast<CPPMContext *> (context);
         
         
         int modelchars=GetNumberModelChars();
         int norm=CLanguageModel::normalization();
         probs.resize(modelchars);
         CPPMnode *temp,*s; 
         int loop,total;
         int sym; 
         // ulong spent=0; 
         ulong size_of_slice;
         bool *exclusions=new bool [modelchars];
         ulong uniform=modelchars;
         ulong tospend=norm-uniform;
         temp=ppmcontext->head;
         for (loop=0; loop <modelchars; loop++) {   /* set up the exclusions array */
                 probs[loop]=0;
                 exclusions[loop]=0;
         }
         while (temp!=0) {
                         //Usprintf(debug,TEXT("tospend %u\n"),tospend);
                         //DebugOutput(TEXT("round\n"));
                 total=0;
                 s=temp->child;
diff --git a/noncore/apps/opie-reader/Bkmks.cpp b/noncore/apps/opie-reader/Bkmks.cpp
index 440d8be..28f6318 100644
--- a/noncore/apps/opie-reader/Bkmks.cpp
+++ b/noncore/apps/opie-reader/Bkmks.cpp
@@ -1,54 +1,70 @@
 #include <qmessagebox.h>
 
 #include "Bkmks.h"
 
 #include "StyleConsts.h"
 #include "Markups.h"
 #include "my_list.h"
 #include "version.h"
 #include "names.h"
 
 const unsigned long BkmkFile::magic = ((unsigned long)'q' << 24) | ((unsigned long)'t' << 16) | ((unsigned long)'r' << 8) | ((unsigned long)BKMKTYPE);
 
-Bkmk::Bkmk(const unsigned char* _nm, unsigned short _nmlen, const unsigned char* _anno, unsigned short _annolen, unsigned int _p)
+Bkmk::Bkmk(const unsigned char* _nm, unsigned short _nmlen, const unsigned char* _anno, unsigned short _annolen, unsigned int _p) :
+  m_name(0),
+  m_namelen(0),
+  m_anno(0),
+  m_annolen(0),
+  m_position(0)
 {
     init(_nm, _nmlen, _anno, _annolen, _p);
 }
 
 Bkmk::Bkmk(const tchar* _nm, const unsigned char* _anno, unsigned short annolen, unsigned int _p) : m_position(_p)
 {
     init(_nm, sizeof(tchar)*(ustrlen(_nm)+1), _anno, annolen, _p);
 }
 
+Bkmk::Bkmk(const Bkmk& rhs) :
+  m_name(0),
+  m_namelen(0),
+  m_anno(0),
+  m_annolen(0),
+  m_position(0)
+{
+    init(rhs.name(), sizeof(tchar)*(ustrlen(rhs.name())+1), rhs.anno(),
+         sizeof(tchar)*(ustrlen(rhs.anno())+1), rhs.value());
+}
+
 Bkmk::Bkmk(const tchar* _nm, const tchar* _anno, unsigned int _p) : m_position(_p)
 {
     if (_anno == NULL)
     {
         tchar t = 0;
         init(_nm, sizeof(tchar)*(ustrlen(_nm)+1), &t, sizeof(t), _p);
     }
     else
     {
         init(_nm, sizeof(tchar)*(ustrlen(_nm)+1), _anno, sizeof(tchar)*(ustrlen(_anno)+1), _p);
     }
 }
 
 Bkmk::Bkmk(const tchar* _nm, const tchar* _anno, unsigned int _p, unsigned int _p2) : m_position(_p)
 {
     if (_anno == NULL)
     {
         tchar t = 0;
         init(_nm, sizeof(tchar)*(ustrlen(_nm)+1), &t, sizeof(t), _p);
     }
     else
     {
         init(_nm, sizeof(tchar)*(ustrlen(_nm)+1), _anno, sizeof(tchar)*(ustrlen(_anno)+1), _p);
     }
     m_position2 = _p2;
     m_red = m_green = m_blue = 127;
 }
 
 void Bkmk::init(const void* _nm, unsigned short _nmlen, const void* _anno, unsigned short _annolen, unsigned int _p)
 {
     m_namelen = _nmlen;
     if (m_namelen > 0)
diff --git a/noncore/apps/opie-reader/Bkmks.h b/noncore/apps/opie-reader/Bkmks.h
index c2275e2..985e158 100644
--- a/noncore/apps/opie-reader/Bkmks.h
+++ b/noncore/apps/opie-reader/Bkmks.h
@@ -1,63 +1,60 @@
 #ifndef __Bkmks_h
 #define __Bkmks_h
 
 #include "config.h"
 #include "Filedata.h"
 #include <stdio.h>
 
 template<class T>
 class CList;
 
 class Bkmk
 {
     friend class BkmkFile;
     unsigned char* m_name;
     unsigned short m_namelen;
     unsigned char* m_anno;
     unsigned short m_annolen;
     unsigned int m_position;
     unsigned int m_position2;
     unsigned char m_red,m_green,m_blue, m_level;
     void init(const void*, unsigned short, const void*, unsigned short, unsigned int);
  public:
-    Bkmk() : m_name(NULL), m_namelen(0), m_anno(NULL), m_annolen(0), m_position(0) {};
+    Bkmk() : m_name(0), m_namelen(0), m_anno(0), m_annolen(0), m_position(0) {};
     Bkmk(const unsigned char* _nm, unsigned short _nmlen, const unsigned char* _anno, unsigned short _annolen, unsigned int _p);
     Bkmk(const tchar* _nm, const unsigned char* _anno, unsigned short _annolen, unsigned int _p);
     Bkmk(const tchar* _nm, const tchar* _anno, unsigned int _p);
     Bkmk(const tchar* _nm, const tchar* _anno, unsigned int _p, unsigned int _p2);
-    Bkmk(const Bkmk& rhs) : m_name(NULL), m_anno(NULL)
-        {
-            *this = rhs;
-        }
+    Bkmk(const Bkmk& rhs);
     ~Bkmk();
     unsigned int value() const { return m_position; }
     void value(unsigned int _v) { m_position = _v; }
     unsigned int value2() const { return m_position2; }
     void value2(unsigned int _v) { m_position2 = _v; }
     unsigned char red() { return m_red; }
     unsigned char green() { return m_green; }
     unsigned char blue() { return m_blue; }
     void red(unsigned char _v) { m_red = _v; }
     void green(unsigned char _v) { m_green = _v; }
     void blue(unsigned char _v) { m_blue = _v; }
     unsigned char level() { return m_level; }
     void level(unsigned char _v) { m_level = _v; }
     tchar *name() const { return (tchar*)m_name; }
     tchar *anno() const { return (tchar*)m_anno; }
     bool operator<(const Bkmk& rhs) { return (m_position < rhs.m_position); }
     Bkmk& operator=(const Bkmk& rhs);
     bool operator==(const Bkmk& rhs);
     void setAnno(tchar* t);
     void setAnno(unsigned char* t, unsigned short len);
     unsigned char* filedata()
         {
             CFiledata fd(anno());
             return m_anno+fd.length();
         }
     unsigned short filedatalen()
         {
             CFiledata fd(anno());
             return m_annolen - fd.length();
         }
 };
 
diff --git a/noncore/apps/opie-reader/StyleConsts.cpp b/noncore/apps/opie-reader/StyleConsts.cpp
index 77c9d3b..c19fa3d 100644
--- a/noncore/apps/opie-reader/StyleConsts.cpp
+++ b/noncore/apps/opie-reader/StyleConsts.cpp
@@ -1,38 +1,45 @@
 
 #include <qimage.h>
 #include "StyleConsts.h"
 
 GraphicLink::~GraphicLink() { delete graphic; }
 
+pmstore::pmstore(bool _canScale, QImage* p, bool isLnk, unsigned long tgt) :
+  count(1),
+  m_isScaleable(_canScale)
+{
+    graphic = new GraphicLink(p, isLnk, tgt);
+}
+
 pmstore::~pmstore()
 { 
 ////    qDebug("Deleting image");
     delete graphic;
 }
 
 CStyle::~CStyle()
 {
     if (graphic != NULL)
     {
         if (--(graphic->count) == 0)
         {
             delete graphic;
         }
     }
 }
 
 CStyle::CStyle(const CStyle& rhs) : graphic(NULL)
 {
     *this = rhs;
 }
 
 CStyle& CStyle::operator=(const CStyle& rhs)
 {
     if (rhs.graphic != NULL)
     {
         (rhs.graphic->count)++;
         if (graphic != NULL)
         {
             if (--(graphic->count) == 0)
             {
                 delete graphic;
diff --git a/noncore/apps/opie-reader/StyleConsts.h b/noncore/apps/opie-reader/StyleConsts.h
index 4b7ff4b..5fd9669 100644
--- a/noncore/apps/opie-reader/StyleConsts.h
+++ b/noncore/apps/opie-reader/StyleConsts.h
@@ -1,64 +1,62 @@
 #ifndef __STYLECONSTS_H
 #define __STYLECONSTS_H
 
 typedef unsigned short StyleType;
 
 #ifdef _WINDOWS
 #include <string.h>
 #endif
 #include <string.h>
 #include <stdlib.h>
 #include <qglobal.h>
 class QImage;
 
 struct GraphicLink
 {
     QImage* graphic;
     bool isLink;
     unsigned long link;
     GraphicLink(QImage* p, bool isLnk, unsigned long tgt) :
         graphic(p), isLink(isLnk), link(tgt) {}
     ~GraphicLink();
 };
 
-struct pmstore
+class pmstore
 {
+  public:
     unsigned int count;
     bool m_isScaleable;
     GraphicLink*     graphic;
-    pmstore(bool _canScale, QImage* p, bool isLnk, unsigned long tgt) : count(1), m_isScaleable(_canScale)
-        {
-            graphic = new GraphicLink(p, isLnk, tgt);
-        }
+    pmstore(bool _canScale, QImage* p, bool isLnk, unsigned long tgt);
     ~pmstore();
 };
 
 enum EalignmentType
 {
     m_AlignLeft,
     m_AlignRight,
     m_AlignCentre,
     m_AlignJustify,
     m_AlignNone
 };
 
 class CBasicStyle
 {
     friend class CStyle;
     bool m_bold,
       m_italic;
     unsigned long m_table;
     int m_fontsize;
     EalignmentType m_align;
     unsigned char red, green, blue;
     unsigned char bred, bgreen, bblue;
     unsigned char pred, pgreen, pblue;
     unsigned long data;
     unsigned long offset;
     bool isLink;
     //    bool isVisited;
     bool m_underline;
     bool m_strikethru;
     bool m_monospaced;
     unsigned char m_leftmargin, m_rightmargin;
     signed char m_extraspace;
diff --git a/noncore/apps/opie-write/qrichtext.cpp b/noncore/apps/opie-write/qrichtext.cpp
index c27eb1e..f040f1e 100644
--- a/noncore/apps/opie-write/qrichtext.cpp
+++ b/noncore/apps/opie-write/qrichtext.cpp
@@ -6031,73 +6031,72 @@ QTextFormat QTextFormat::makeTextFormat( const QStyleSheetItem *style, const QMa
                 QString s = style.mid( 16 ).stripWhiteSpace();
                 format.fn.setUnderline( s == "underline" );
             } else if ( style.startsWith("vertical-align:" ) ) {
                 QString s = style.mid( 15 ).stripWhiteSpace();
                 if ( s == "sub" )
                     format.setVAlign( QTextFormat::AlignSubScript );
                 else if ( s == "super" )
                     format.setVAlign( QTextFormat::AlignSuperScript );
                 else
                     format.setVAlign( QTextFormat::AlignNormal );
             } else if ( style.startsWith("color:" ) ) {
                 format.col.setNamedColor( style.mid(6) );
                 format.linkColor = FALSE;
             }
         }
     }
 
     format.update();
     return format;
 }
 
 struct QPixmapInt
 {
     QPixmapInt() : ref( 0 ) {}
     QPixmap pm;
             int    ref;
 };
 
 static QMap<QString, QPixmapInt> *pixmap_map = 0;
 
 QTextImage::QTextImage( QTextDocument *p, const QMap<QString, QString> &attr, const QString& context,
                         QMimeSourceFactory &factory )
-    : QTextCustomItem( p )
+    : QTextCustomItem( p ), reg( 0 )
 {
     width = height = 0;
     if ( attr.contains("width") )
         width = attr["width"].toInt();
     if ( attr.contains("height") )
         height = attr["height"].toInt();
 
-    reg = 0;
     QString imageName = attr["src"];
 
     if (!imageName)
         imageName = attr["source"];
 
     if ( !imageName.isEmpty() ) {
         imgId = QString( "%1,%2,%3,%4" ).arg( imageName ).arg( width ).arg( height ).arg( (ulong)&factory );
         if ( !pixmap_map )
             pixmap_map = new QMap<QString, QPixmapInt>;
         if ( pixmap_map->contains( imgId ) ) {
             QPixmapInt& pmi = pixmap_map->operator[](imgId);
             pm = pmi.pm;
             pmi.ref++;
             width = pm.width();
             height = pm.height();
         } else {
             QImage img;
             const QMimeSource* m =
                 factory.data( imageName, context );
             if ( !m ) {
                 owarn << "QTextImage: no mimesource for " << imageName.latin1() << "" << oendl; 
             }
             else {
                 if ( !QImageDrag::decode( m, img ) ) {
                     owarn << "QTextImage: cannot decode " << imageName.latin1() << "" << oendl; 
                 }
             }
 
             if ( !img.isNull() ) {
                 if ( width == 0 ) {
                     width = img.width();
                     if ( height != 0 ) {
@@ -6120,76 +6119,76 @@ QTextImage::QTextImage( QTextDocument *p, const QMap<QString, QString> &attr, co
                 pm.convertFromImage( img );
             }
             if ( !pm.isNull() ) {
                 QPixmapInt& pmi = pixmap_map->operator[](imgId);
                 pmi.pm = pm;
                 pmi.ref++;
             }
         }
         if ( pm.mask() ) {
             QRegion mask( *pm.mask() );
             QRegion all( 0, 0, pm.width(), pm.height() );
             reg = new QRegion( all.subtract( mask ) );
         }
     }
 
     if ( pm.isNull() && (width*height)==0 )
         width = height = 50;
 
     place = PlaceInline;
     if ( attr["align"] == "left" )
         place = PlaceLeft;
     else if ( attr["align"] == "right" )
         place = PlaceRight;
 
     tmpwidth = width;
     tmpheight = height;
 
     attributes = attr;
 }
 
 QTextImage::~QTextImage()
 {
+    delete reg;
     if ( pixmap_map && pixmap_map->contains( imgId ) ) {
         QPixmapInt& pmi = pixmap_map->operator[](imgId);
         pmi.ref--;
         if ( !pmi.ref ) {
             pixmap_map->remove( imgId );
             if ( pixmap_map->isEmpty() ) {
                 delete pixmap_map;
                 pixmap_map = 0;
             }
         }
     }
-    delete reg;
 }
 
 QString QTextImage::richText() const
 {
     QString s;
     s += "<img ";
     QMap<QString, QString>::ConstIterator it = attributes.begin();
     for ( ; it != attributes.end(); ++it )
         s += it.key() + "=" + *it + " ";
     s += ">";
     return s;
 }
 
 void QTextImage::adjustToPainter( QPainter* p )
 {
     width = scale( tmpwidth, p );
     height = scale( tmpheight, p );
 }
 
 #if !defined(Q_WS_X11)
 #include <qbitmap.h>
 #include "qcleanuphandler.h"
 static QPixmap *qrt_selection = 0;
 static QSingleCleanupHandler<QPixmap> qrt_cleanup_pixmap;
 static void qrt_createSelectionPixmap( const QColorGroup &cg )
 {
     qrt_selection = new QPixmap( 2, 2 );
     qrt_cleanup_pixmap.set( &qrt_selection );
     qrt_selection->fill( Qt::color0 );
     QBitmap m( 2, 2 );
     m.fill( Qt::color1 );
     QPainter p( &m );
diff --git a/noncore/apps/tinykate/libkate/document/katehighlight.cpp b/noncore/apps/tinykate/libkate/document/katehighlight.cpp
index 539d356..89024f7 100644
--- a/noncore/apps/tinykate/libkate/document/katehighlight.cpp
+++ b/noncore/apps/tinykate/libkate/document/katehighlight.cpp
@@ -360,71 +360,76 @@ const QChar *HlCHex::checkHgl(const QChar *str, int len, bool) {
       if ((*s&0xdf) == 'L' || (*s&0xdf) == 'U' ) s++;
       return s;
     }
   }
   return 0L;
 #endif
 }
 
 HlCFloat::HlCFloat(int attribute, int context)
   : HlFloat(attribute,context) {
 }
 
 const QChar *HlCFloat::checkHgl(const QChar *s, int len, bool lineStart) {
 
   s = HlFloat::checkHgl(s, len, lineStart);
   if (s && ((*s&0xdf) == 'F' )) s++;
   return s;
 }
 
 HlAnyChar::HlAnyChar(int attribute, int context, const QChar* charList, uint len)
   : HlItem(attribute, context) {
   _charList=charList;
   _charListLen=len;
 }
 
 const QChar *HlAnyChar::checkHgl(const QChar *s, int len, bool)
 {
   if (ustrchr(_charList, _charListLen, *s)) return s +1;
   return 0L;
 }
 
 HlRegExpr::HlRegExpr(int attribute, int context,QString regexp)
-  : HlItem(attribute, context) {
+  : HlItem(attribute, context), Expr(0) {
 
     handlesLinestart=regexp.startsWith("^");
     if(!handlesLinestart) regexp.prepend("^");
     Expr=new QRegExp3(regexp);
 }
 
+HlRegExpr::~HlRegExpr()
+{
+    delete Expr;
+}
+
 const QChar *HlRegExpr::checkHgl(const QChar *s, int len, bool lineStart)
 {
   if ((!lineStart) && handlesLinestart) return 0;
 
   QString line(s,len);
   int pos = Expr->search( line, 0 );
   if (pos==-1) return 0L;
     else
      return (s+Expr->matchedLength());
 };
 
 
 HlLineContinue::HlLineContinue(int attribute, int context)
   : HlItem(attribute,context) {
 }
 
 const QChar *HlLineContinue::checkHgl(const QChar *s, int len, bool) {
 
   if ((s[0].latin1() == '\\') && (len == 1))
     {
            return s + 1;
     }
   return 0L;
 }
 
 
 HlCStringChar::HlCStringChar(int attribute, int context)
   : HlItem(attribute,context) {
 }
 
 //checks for hex and oct (for example \x1b or \033)
 const QChar *checkCharHexOct(const QChar *str) {
diff --git a/noncore/apps/tinykate/libkate/document/katehighlight.h b/noncore/apps/tinykate/libkate/document/katehighlight.h
index fddf585..f0be27b 100644
--- a/noncore/apps/tinykate/libkate/document/katehighlight.h
+++ b/noncore/apps/tinykate/libkate/document/katehighlight.h
@@ -155,65 +155,65 @@ class HlCFloat : public HlFloat {
 };
 
 class HlLineContinue : public HlItem {
   public:
     HlLineContinue(int attribute, int context);
     virtual bool endEnable(QChar c) {return c == '\0';}
     virtual const QChar *checkHgl(const QChar *, int len, bool);
 };
 
 class HlCStringChar : public HlItem {
   public:
     HlCStringChar(int attribute, int context);
     virtual const QChar *checkHgl(const QChar *, int len, bool);
 };
 
 class HlCChar : public HlItem {
   public:
     HlCChar(int attribute, int context);
     virtual const QChar *checkHgl(const QChar *, int len, bool);
 };
 
 class HlAnyChar : public HlItem {
   public:
     HlAnyChar(int attribute, int context, const QChar* charList, uint len);
     virtual const QChar *checkHgl(const QChar *, int len, bool);
     const QChar* _charList;
     uint _charListLen;
 };
 
 class HlRegExpr : public HlItem {
   public:
   HlRegExpr(int attribute, int context,QString expr);
-  ~HlRegExpr(){delete Expr;};
+  ~HlRegExpr();
   virtual const QChar *checkHgl(const QChar *, int len, bool);
   QRegExp3 *Expr;
   bool handlesLinestart;
 };
 
 //--------
 
 
 //Item Style: color, selected color, bold, italic
 class ItemStyle {
   public:
     ItemStyle();
 //    ItemStyle(const ItemStyle &);
     ItemStyle(const QColor &, const QColor &, bool bold, bool italic);
     ItemStyle(ItemStyle *its){col=its->col;selCol=its->selCol; bold=its->bold; italic=its->italic;}
 //    void setData(const ItemStyle &);
     QColor col;
     QColor selCol;
     int bold;   //boolean value
     int italic; //boolean value
 };
 
 typedef QList<ItemStyle> ItemStyleList;
 
 //Item Properties: name, Item Style, Item Font
 class ItemData : public ItemStyle {
   public:
     ItemData(const QString  name, int defStyleNum);
     ItemData(const QString  name, int defStyleNum,
       const QColor&, const QColor&, bool bold, bool italic);
     ItemData(ItemData
 *itd):ItemStyle((ItemStyle*)itd),name(itd->name),defStyleNum(itd->defStyleNum),defStyle(itd->defStyle){;}