Automated conversion for enhanced compatibility with TQt for Qt4 3.4.0 TP1

NOTE: This will not compile with Qt4 (yet), however it does compile with Qt3


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

1 files changed, 67 insertions, 67 deletions

diff --git a/kutils/kreplace.h b/kutils/kreplace.h
index ea385189b..3a44589b8 100644
--- a/kutils/kreplace.h
+++ b/kutils/kreplace.h
@@ -27,8 +27,8 @@ class KReplaceNextDialog;
 
 /**
  * @ingroup main
- * @ingroup findreplace
- * @brief A generic implementation of the "replace" function.
+ * @ingroup tqfindtqreplace
+ * @brief A generic implementation of the "tqreplace" function.
  *
  * @author S.R.Haque <srhaque@iee.org>, David Faure <faure@kde.org>
  *
@@ -40,23 +40,23 @@ class KReplaceNextDialog;
  *
  * \b Example:
  *
- * To use the class to implement a complete replace feature:
+ * To use the class to implement a complete tqreplace feature:
  *
- * In the slot connect to the replace action, after using KReplaceDialog:
+ * In the slot connect to the tqreplace action, after using KReplaceDialog:
  * \code
  *
- *  // This creates a replace-on-prompt dialog if needed.
- *  m_replace = new KReplace(pattern, replacement, options, this);
+ *  // This creates a tqreplace-on-prompt dialog if needed.
+ *  m_tqreplace = new KReplace(pattern, tqreplacement, options, this);
  *
  *  // Connect signals to code which handles highlighting
- *  // of found text, and on-the-fly replacement.
- *  connect( m_replace, TQT_SIGNAL( highlight( const TQString &, int, int ) ),
+ *  // of found text, and on-the-fly tqreplacement.
+ *  connect( m_tqreplace, TQT_SIGNAL( highlight( const TQString &, int, int ) ),
  *          this, TQT_SLOT( slotHighlight( const TQString &, int, int ) ) );
- *  // Connect findNext signal - called when pressing the button in the dialog
- *  connect( m_replace, TQT_SIGNAL( findNext() ),
+ *  // Connect tqfindNext signal - called when pressing the button in the dialog
+ *  connect( m_tqreplace, TQT_SIGNAL( tqfindNext() ),
  *          this, TQT_SLOT( slotReplaceNext() ) );
- *  // Connect replace signal - called when doing a replacement
- *  connect( m_replace, TQT_SIGNAL( replace(const TQString &, int, int, int) ),
+ *  // Connect tqreplace signal - called when doing a tqreplacement
+ *  connect( m_tqreplace, TQT_SIGNAL( tqreplace(const TQString &, int, int, int) ),
  *          this, TQT_SLOT( slotReplace(const TQString &, int, int, int) ) );
  * \endcode
  *  Then initialize the variables determining the "current position"
@@ -72,11 +72,11 @@ class KReplaceNextDialog;
  *  {
  *      KFind::Result res = KFind::NoMatch;
  *      while ( res == KFind::NoMatch && <position not at end> ) {
- *          if ( m_replace->needData() )
- *              m_replace->setData( <current text fragment> );
+ *          if ( m_tqreplace->needData() )
+ *              m_tqreplace->setData( <current text fragment> );
  *
  *          // Let KReplace inspect the text fragment, and display a dialog if a match is found
- *          res = m_replace->replace();
+ *          res = m_tqreplace->tqreplace();
  *
  *          if ( res == KFind::NoMatch ) {
  *              <Move to the next text fragment, honoring the FindBackwards setting for the direction>
@@ -84,13 +84,13 @@ class KReplaceNextDialog;
  *      }
  *
  *      if ( res == KFind::NoMatch ) // i.e. at end
- *          <Call either  m_replace->displayFinalDialog(); delete m_replace; m_replace = 0L;
- *           or           if ( m_replace->shouldRestart() ) { reinit (w/o FromCursor) and call slotReplaceNext(); }
- *                        else { m_replace->closeReplaceNextDialog(); }>
+ *          <Call either  m_tqreplace->displayFinalDialog(); delete m_tqreplace; m_tqreplace = 0L;
+ *           or           if ( m_tqreplace->shouldRestart() ) { reinit (w/o FromCursor) and call slotReplaceNext(); }
+ *                        else { m_tqreplace->closeReplaceNextDialog(); }>
  *  }
  * \endcode
  *
- *  Don't forget delete m_find in the destructor of your class,
+ *  Don't forget delete m_tqfind in the destructor of your class,
  *  unless you gave it a parent widget on construction.
  *
  */
@@ -105,23 +105,23 @@ public:
      * Only use this constructor if you don't use KFindDialog, or if
      * you use it as a modal dialog.
      * @param pattern The pattern to look for.
-     * @param replacement The replacement string.
-     * @param options Options for the find dialog. @see KFindDialog and KReplaceDialog.
+     * @param tqreplacement The tqreplacement string.
+     * @param options Options for the tqfind dialog. @see KFindDialog and KReplaceDialog.
      * @param parent The parent widget.
      */
-    KReplace(const TQString &pattern, const TQString &replacement, long options, TQWidget *parent = 0);
+    KReplace(const TQString &pattern, const TQString &tqreplacement, long options, TQWidget *parent = 0);
     /**
      * This is the recommended constructor if you also use KReplaceDialog (non-modal).
      * You should pass the pointer to it here, so that when a message box
      * appears it has the right parent. Don't worry about deletion, KReplace
-     * will notice if the find dialog is closed.
+     * will notice if the tqfind dialog is closed.
      * @param pattern The pattern to look for.
-     * @param replacement The replacement string.
-     * @param options Options for the find dialog. @see KFindDialog and KReplaceDialog.
+     * @param tqreplacement The tqreplacement string.
+     * @param options Options for the tqfind dialog. @see KFindDialog and KReplaceDialog.
      * @param parent The parent widget.
-     * @param replaceDialog A pointer to the KReplaceDialog object.
+     * @param tqreplaceDialog A pointer to the KReplaceDialog object.
      */
-    KReplace(const TQString &pattern, const TQString &replacement, long options, TQWidget *parent, TQWidget* replaceDialog);
+    KReplace(const TQString &pattern, const TQString &tqreplacement, long options, TQWidget *parent, TQWidget* tqreplaceDialog);
 
     /**
      * Destructor.
@@ -129,13 +129,13 @@ public:
     virtual ~KReplace();
 
     /**
-     * Return the number of replacements made (i.e. the number of times
-     * the replace signal was emitted).
-     * Can be used in a dialog box to tell the user how many replacements were made.
+     * Return the number of tqreplacements made (i.e. the number of times
+     * the tqreplace signal was emitted).
+     * Can be used in a dialog box to tell the user how many tqreplacements were made.
      * The final dialog does so already, unless you used setDisplayFinalDialog(false).
-     * @return The number of replacements.
+     * @return The number of tqreplacements.
      */
-    int numReplacements() const { return m_replacements; }
+    int numReplacements() const { return m_tqreplacements; }
 
     /**
      * Call this to reset the numMatches & numReplacements counts.
@@ -146,76 +146,76 @@ public:
 
     /**
      * Walk the text fragment (e.g. kwrite line, kspread cell) looking for matches.
-     * For each match, if prompt-on-replace is specified, emits the highlight() signal
-     * and displays the prompt-for-replace dialog before doing the replace.
+     * For each match, if prompt-on-tqreplace is specified, emits the highlight() signal
+     * and displays the prompt-for-tqreplace dialog before doing the tqreplace.
      * @return Whether or not there has been a match.
      */
-    Result replace();
+    Result tqreplace();
 
     /**
-     * Return (or create) the dialog that shows the "find next?" prompt.
+     * Return (or create) the dialog that shows the "tqfind next?" prompt.
      * Usually you don't need to call this.
      * One case where it can be useful, is when the user selects the "Find"
-     * menu item while a find operation is under way. In that case, the
+     * menu item while a tqfind operation is under way. In that case, the
      * program may want to call setActiveWindow() on that dialog.
-     * @return The replace next dialog.
+     * @return The tqreplace next dialog.
      */
-    KDialogBase* replaceNextDialog( bool create = false );
+    KDialogBase* tqreplaceNextDialog( bool create = false );
 
     /**
-     * Close the "replace next?" dialog. The application should do this when
+     * Close the "tqreplace next?" dialog. The application should do this when
      * the last match was hit. If the application deletes the KReplace, then
-     * "find previous" won't be possible anymore.
+     * "tqfind previous" won't be possible anymore.
      */
     void closeReplaceNextDialog();
 
     /**
-     * Searches the given string, replaces with the given replacement string,
+     * Searches the given string, tqreplaces with the given tqreplacement string,
      * and returns whether a match was found. If one is,
-     * the replacement string length is also returned.
+     * the tqreplacement string length is also returned.
      *
      * A performance optimised version of the function is provided for use
      * with regular expressions.
      *
      * @param text The string to search.
      * @param pattern The pattern to look for.
-     * @param replacement The replacement string to insert into the text.
+     * @param tqreplacement The tqreplacement string to insert into the text.
      * @param index The starting index into the string.
      * @param options The options to use.
-     * @param replacedLength Output parameter, contains the length of the replaced string.
-     * Not always the same as replacement.length(), when backreferences are used.
+     * @param tqreplacedLength Output parameter, tqcontains the length of the tqreplaced string.
+     * Not always the same as tqreplacement.length(), when backreferences are used.
      * @return The index at which a match was found, or -1 if no match was found.
      */
-    static int replace( TQString &text, const TQString &pattern, const TQString &replacement, int index, long options, int *replacedLength );
+    static int tqreplace( TQString &text, const TQString &pattern, const TQString &tqreplacement, int index, long options, int *tqreplacedLength );
 
     /**
-     * Searches the given regular expression, replaces with the given replacement string,
+     * Searches the given regular expression, tqreplaces with the given tqreplacement string,
      * and returns whether a match was found. If one is,
-     * the replacement string length is also returned.
+     * the tqreplacement string length is also returned.
      *
      * Another version of the function is provided for use with strings.
      *
      * @param text The string to search.
      * @param pattern The regular expression pattern to look for.
-     * @param replacement The replacement string to insert into the text.
+     * @param tqreplacement The tqreplacement string to insert into the text.
      * @param index The starting index into the string.
      * @param options The options to use.
-     * @param replacedLength Output parameter, contains the length of the replaced string.
-     * Not always the same as replacement.length(), when backreferences are used.
+     * @param tqreplacedLength Output parameter, tqcontains the length of the tqreplaced string.
+     * Not always the same as tqreplacement.length(), when backreferences are used.
      * @return The index at which a match was found, or -1 if no match was found.
      */
-    static int replace( TQString &text, const TQRegExp &pattern, const TQString &replacement, int index, long options, int *replacedLength );
+    static int tqreplace( TQString &text, const TQRegExp &pattern, const TQString &tqreplacement, int index, long options, int *tqreplacedLength );
 
     /**
      * Returns @c true if we should restart the search from scratch.
-     * Can ask the user, or return @c false (if we already searched/replaced the
+     * Can ask the user, or return @c false (if we already searched/tqreplaced the
      * whole document without the PromptOnReplace option).
      *
      * @param forceAsking set to @c true if the user modified the document during the
      * search. In that case it makes sense to restart the search again.
      *
      * @param showNumMatches set to @c true if the dialog should show the number of
-     * matches. Set to @c false if the application provides a "find previous" action,
+     * matches. Set to @c false if the application provides a "tqfind previous" action,
      * in which case the match count will be erroneous when hitting the end,
      * and we could even be hitting the beginning of the document (so not all
      * matches have even been seen).
@@ -225,7 +225,7 @@ public:
     virtual bool shouldRestart( bool forceAsking = false, bool showNumMatches = true ) const;
 
     /**
-     * Displays the final dialog telling the user how many replacements were made.
+     * Displays the final dialog telling the user how many tqreplacements were made.
      * Call either this or shouldRestart().
      */
     virtual void displayFinalDialog() const;
@@ -233,20 +233,20 @@ public:
 signals:
 
     /**
-     * Connect to this slot to implement updating of replaced text during the replace
+     * Connect to this slot to implement updating of tqreplaced text during the tqreplace
      * operation.
      *
-     * Extra care must be taken to properly implement the "no prompt-on-replace" case.
+     * Extra care must be taken to properly implement the "no prompt-on-tqreplace" case.
      * For instance highlight isn't emitted in that case (some code might rely on it),
-     * and for performance reasons one should repaint after replace() ONLY if
-     * prompt-on-replace was selected.
+     * and for performance reasons one should tqrepaint after tqreplace() ONLY if
+     * prompt-on-tqreplace was selected.
      *
-     * @param text The text, in which the replacement has already been done.
-     * @param replacementIndex Starting index of the matched substring
-     * @param replacedLength Length of the replacement string
+     * @param text The text, in which the tqreplacement has already been done.
+     * @param tqreplacementIndex Starting index of the matched substring
+     * @param tqreplacedLength Length of the tqreplacement string
      * @param matchedLength Length of the matched string
      */
-    void replace(const TQString &text, int replacementIndex, int replacedLength, int matchedLength);
+    void tqreplace(const TQString &text, int tqreplacementIndex, int tqreplacedLength, int matchedLength);
 
 protected slots:
 
@@ -257,10 +257,10 @@ protected slots:
 private:
     KReplaceNextDialog* dialog();
     void doReplace();
-    static int replace( TQString &text, const TQString &replacement, int index, long options, int length );
+    static int tqreplace( TQString &text, const TQString &tqreplacement, int index, long options, int length );
 
-    TQString m_replacement;
-    unsigned m_replacements;
+    TQString m_tqreplacement;
+    unsigned m_tqreplacements;
 
     // Binary compatible extensibility.
     class KReplacePrivate;