"\\%sfunc{%s%s}{%s}{",
                       op.mIsConstant ? "const" : "",
                       op.mIsVirtual ? "virtual " : "",
-                      op.mRetType.c_str(),
+                      op.m_RetType.c_str(),
                       funcname.c_str());
     m_textFunc += func;
 }
         m_textFunc << ", ";
     }
 
-    m_textFunc << "\\param{" << param.mType << " }{" << param.GetName();
+    m_textFunc << "\\param{" << param.m_Type << " }{" << param.GetName();
     wxString defvalue = param.mInitVal;
     if ( !defvalue.empty() ) {
         m_textFunc << " = " << defvalue;
                             continue;
                         }
 
-                        if ( param.GetType() != ctxParam->mType ) {
+                        if ( param.GetType() != ctxParam->m_Type ) {
                             foundDiff = true;
 
                             wxLogError("Type of parameter '%s' of '%s::%s' "
                                        ctxParam->m_Name.c_str(),
                                        nameClass.c_str(),
                                        nameMethod.c_str(),
-                                       ctxParam->mType.c_str(),
+                                       ctxParam->m_Type.c_str(),
                                        param.GetType().GetName().c_str());
 
                             continue;
 
 /*
    $Log$
+   Revision 1.38  2005/05/24 09:06:20  ABX
+   More fixes and wxWidgets coding standards.
+
    Revision 1.37  2005/05/23 15:22:08  ABX
    Initial HelpGen source cleaning.
 
 
 // moves tokens like '*' '**', '***', '&' from the name
 // to the type
 
-static void arrange_indirection_tokens_between( string& type,
-                                                string& identifier )
+static void arrange_indirection_tokens_between( wxString& type,
+                                                wxString& identifier )
 {
     // TBD:: FIXME:: return value of operators !
 
-    while ( identifier[0u] == '*' ||
-            identifier[0u] == '&'
+    while ( identifier[0u] == _T('*') ||
+            identifier[0u] == _T('&')
           )
     {
         type += identifier[0u];
         string toerase("WXDLLEXPORT ");
         while((pos = rettype.find(toerase, pos)) != string::npos)
             rettype.erase(pos, toerase.length());
-        pOp->mRetType = rettype;
+        pOp->m_RetType = rettype;
     }
 
-    arrange_indirection_tokens_between( pOp->mRetType, pOp->m_Name );
+    arrange_indirection_tokens_between( pOp->m_RetType, pOp->m_Name );
 
     cur = savedPos;
     restore_line_no( tmpLnNo );
         size_t len = blockSizes[ typeBlock ];
         len = size_t ( (blocks[ typeBlock ] + len) - blocks[ 0 ] );
 
-        pPar->mType = string( blocks[0], len );
+        pPar->m_Type = string( blocks[0], len );
 
-        arrange_indirection_tokens_between( pPar->mType, pPar->m_Name );
+        arrange_indirection_tokens_between( pPar->m_Type, pPar->m_Name );
 
         if ( *cur == ')' )
         {
         skip_next_token_back( cur );
         skip_token_back( cur );
 
-        pAttr->mType = get_token_str( cur );
+        pAttr->m_Type = get_token_str( cur );
 
         // if comma, than variable list continues
         // otherwise the variable type reached - stop
         if ( !pAttr )
             continue;
 
-        if ( pAttr->mType.empty() )
-            pAttr->mType = type;
+        if ( pAttr->m_Type.empty() )
+            pAttr->m_Type = type;
         pAttr->mVisibility = mCurVis;
 
         if ( !pAttr->m_Name.empty() )
-            arrange_indirection_tokens_between( pAttr->mType, pAttr->m_Name );
+            arrange_indirection_tokens_between( pAttr->m_Type, pAttr->m_Name );
     }
 
     cur = savedPos;
 
 {
     string body;
     body += mTags[TAG_BOLD].start;
-    body += attr.mType;
+    body += attr.m_Type;
     body += mTags[TAG_BOLD].end;
 
     body += mTags[TAG_ITALIC].start;
 
 {
     char buf[128];
 
-    switch ( pInfo->mType )
+    switch ( pInfo->m_Type )
     {
         case TVAR_INTEGER :
             {
                 cout << "DBG:: pInfo->mOfs value is " << (int)pInfo->mOfs << endl;
                 cout << "DBG:: d+pInfo->mOfs is " << (int)((char*)dataObj + pInfo->mOfs) << endl;
                 cout << "DBG:: pInfo->m_Name is " << pInfo->m_Name << endl;
-                cout << "DBG:: pInfo->mType is " << pInfo->mType << endl;
+                cout << "DBG:: pInfo->m_Type is " << pInfo->m_Type << endl;
                 cout << "DBG:: end of dump. " << endl;
 
                 cout << "DBG:: cs value is " << endl << cs << endl;
 
 {
 public:
     const char*     m_Name;
-    int             mType;
+    int             m_Type;
     int             mOfs;
 
     TVarInfo( const char* name, int ofs, int varType )
         : m_Name(name),
-          mType( varType ),
+          m_Type( varType ),
           mOfs( ofs )
     {}
 };
 
 
 string spOperation::GetFullName(MarkupTagsT tags)
 {
-    string txt = tags[TAG_BOLD].start + mRetType;
+    string txt = tags[TAG_BOLD].start + m_RetType;
     txt += " ";
     txt += m_Name;
     txt += "( ";
 
         txt += tags[TAG_BOLD].start;
 
-        txt += param.mType;
+        txt += param.m_Type;
 
         txt += tags[TAG_BOLD].end;
         txt += tags[TAG_ITALIC].start;
 void spParameter::DumpThis(const wxString& indent) const
 {
     wxLogDebug("%sparam named '%s' of type '%s'",
-               indent.c_str(), m_Name.c_str(), mType.c_str());
+               indent.c_str(), m_Name.c_str(), m_Type.c_str());
 }
 
 void spAttribute::DumpThis(const wxString& indent) const
 {
     wxLogDebug("%svariable named '%s' of type '%s'",
-               indent.c_str(), m_Name.c_str(), mType.c_str());
+               indent.c_str(), m_Name.c_str(), m_Type.c_str());
 }
 
 void spOperation::DumpThis(const wxString& indent) const
                mIsConstant ? "const " : "",
                mIsVirtual ? "virtual " : "",
                protection.c_str(),
-               mScope.c_str(), m_Name.c_str(), mRetType.c_str());
+               mScope.c_str(), m_Name.c_str(), m_RetType.c_str());
 }
 
 void spPreprocessorLine::DumpThis(const wxString& indent) const
 
 {
 public:
     // type of argument (parameter)
-    string mType;
+    wxString m_Type;
 
     // "stringified" initial value
     string mInitVal;
 {
 public:
     // type of the attribute
-    string mType;
+    wxString m_Type;
 
     // it's initial value
     string mInitVal;
 {
 public:
     // type of return value
-    string      mRetType;
+    wxString    m_RetType;
 
     // argument list
     //MParamListT mParams;