Initial conversion of kdepim to TQt

This will probably require some tweaking before it will build under Qt4,
however Qt3 builds are OK.  Any alterations this commit makes to kdepim
behaviour under Qt3 are unintentional and should be fixed.


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1227832 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 27 insertions, 27 deletions

diff --git a/mimelib/mimelib/msgcmp.h b/mimelib/mimelib/msgcmp.h
index cc2cefb2..46ff95cb 100644
--- a/mimelib/mimelib/msgcmp.h
+++ b/mimelib/mimelib/msgcmp.h
@@ -8,7 +8,7 @@
 // All rights reserved.
 //
 // IN NO EVENT SHALL DOUGLAS W. SAUDER BE LIABLE TO ANY PARTY FOR DIRECT,
-// INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
+// INDIRECT, SPECIAL, INCIDENTAL, OR CONSETQUENTIAL DAMAGES ARISING OUT OF
 // THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF DOUGLAS W. SAUDER
 // HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
@@ -94,31 +94,31 @@
 //.    to be set.
 //.
 //. \item
-//.    A parent.  Most message components are part of another component.
+//.    A tqparent.  Most message components are part of another component.
 //.    A collection of headers is part of a message or body part, a header
 //.    field is part of a collection of headers, a field-body is part
-//.    of a header field, and so on.  The parent of
-//.    a component is the component that tqcontains it.  This tree structure
-//.    is important, since a component's parent must be parsed before the
+//.    of a header field, and so on.  The tqparent of
+//.    a component is the component that contains it.  This tree structure
+//.    is important, since a component's tqparent must be parsed before the
 //.    component can be.  Also, a component's string representation must
-//.    be assembled before its parent's.  To maintain consistency in the
+//.    be assembled before its tqparent's.  To maintain consistency in the
 //.    tree, whenever a component's is-modified flag is set,
-//.    the component notifies its parent to also set its is-modified flag.
+//.    the component notifies its tqparent to also set its is-modified flag.
 //.    In this way, an is-modified flag set anywhere in the tree always
 //.    propagates up to the root component.
 //.
 //. \item
-//.    Children.  The preceding discussion about a component's parent is
-//.    relevant to an understanding of a component's children.  A component's
-//.    parse method calls the parse methods of its children
+//.    Children.  The preceding discussion about a component's tqparent is
+//.    relevant to an understanding of a component's tqchildren.  A component's
+//.    parse method calls the parse methods of its tqchildren
 //.    after it has executed its own parse method (and, in some cases, created
-//.    all of its children).
+//.    all of its tqchildren).
 //.    Also, a component typically calls the assemble method of its
-//.    children before it executes its own.  A component's child may request
+//.    tqchildren before it executes its own.  A component's child may request
 //.    that the component set its is-modified flag.
-//.    {\tt DwMessageComponent} does not deal directly with children.
+//.    {\tt DwMessageComponent} does not deal directly with tqchildren.
 //.    Derived classes bear all the responsibility for handling their
-//.    children.
+//.    tqchildren.
 //. \end{enumerate}
 //=============================================================================
 //+ Noentry ~DwMessageComponent _PrintDebugInfo mString mIsModified mParent
@@ -163,18 +163,18 @@ public:
     DwMessageComponent(const DwString& aStr, DwMessageComponent* aParent=0);
     //. The first constructor is the default constructor, which sets the
     //. {\tt DwMessageComponent} object's string representation to the
-    //. empty string and sets its parent to NULL.
+    //. empty string and sets its tqparent to NULL.
     //.
     //. The second constructor is the copy constructor, which performs
-    //. a deep copy of {\tt aCmp}.  The parent of the new
+    //. a deep copy of {\tt aCmp}.  The tqparent of the new
     //. {\tt DwMessageComponent} object is set to NULL.
     //.
     //. The third constructor copies {\tt aStr} to the new
     //. {\tt DwMessageComponent} object's string representation and sets
-    //. {\tt aParent} as its parent.  In typical cases, the virtual
+    //. {\tt aParent} as its tqparent.  In typical cases, the virtual
     //. member function {\tt Parse()} should be called immediately after
     //. this constructor to parse the new {\tt DwMessageComponent} object
-    //. and all of its children into their broken-down representations.
+    //. and all of its tqchildren into their broken-down representations.
 
     virtual ~DwMessageComponent();
 
@@ -188,10 +188,10 @@ public:
     //. responsible for extracting the broken-down representation from
     //. the string representation.  In some derived classes, such as
     //. {\tt DwHeaders}, the parse method is also responsible for creating the
-    //. children of the object.  (In the case of {\tt DwHeaders}, the children
+    //. tqchildren of the object.  (In the case of {\tt DwHeaders}, the tqchildren
     //. created are the {\tt DwField} objects that represent the {\it field}s
     //. contained in the {\it headers}.)  The {\tt Parse()} function always
-    //. calls the {\tt Parse()} function of all of its children.
+    //. calls the {\tt Parse()} function of all of its tqchildren.
 
     virtual void Assemble() = 0;
     //. A pure virtual function which provides an interface to the
@@ -200,11 +200,11 @@ public:
     //. from the broken-down representation.  In other words, the
     //. assemble method is the opposite of the parse method.  Before
     //. assembling its string representation, the assemble method calls
-    //. the assemble method of each of its children.  In this way, the
+    //. the assemble method of each of its tqchildren.  In this way, the
     //. entire tree structure that represents a message may be traversed.
     //. If the is-modifed flag for a {\tt DwMessageComponent} is cleared,
     //. the {\tt Assemble()} function will return immediately without
-    //. calling the {\tt Assemble()} function of any of its children.
+    //. calling the {\tt Assemble()} function of any of its tqchildren.
 
     virtual DwMessageComponent* Clone() const = 0;
     //. Creates a new {\tt DwMessageComponent} on the free store that is of
@@ -217,7 +217,7 @@ public:
     //. NUL-terminated. This member function does not invoke the parse
     //. method.  Typically, the virtual member function {\tt Parse()}
     //. should be called immediately after this member function to parse
-    //. the {\tt DwMessageComponent} object and all of its children into
+    //. the {\tt DwMessageComponent} object and all of its tqchildren into
     //. their broken-down representations.  See also
     //. {\tt DwMessageComponent::Parse()}
 
@@ -230,11 +230,11 @@ public:
     //. {\tt DwMessageComponent::Assemble()}.
 
     DwMessageComponent* Parent();
-    //. Returns the {\tt DwMessageComponent} object that is the parent
+    //. Returns the {\tt DwMessageComponent} object that is the tqparent
     //. of this object.
 
     void SetParent(DwMessageComponent* aParent);
-    //. Sets {\tt aParent} as the {\tt DwMessageComponent} object's parent.
+    //. Sets {\tt aParent} as the {\tt DwMessageComponent} object's tqparent.
 
     DwBool IsModified() const;
     //. Returns 1 if the is-modified flag is set for this
@@ -242,7 +242,7 @@ public:
 
     void SetModified();
     //. Sets the is-modified (dirty) flag for this {\tt DwMessageComponent}
-    //. object and notifies the object's parent to also set its is-modified
+    //. object and notifies the object's tqparent to also set its is-modified
     //. flag.
 
     int ClassId() const;
@@ -269,7 +269,7 @@ protected:
     // Is-modified flag
 
     DwMessageComponent* mParent;
-    // Component that tqcontains this component
+    // Component that contains this component
 
     componentType mClassId;
     // Class identifier for runtime type identification