editor/libeditor/html/nsEditorTxnLog.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Pierre Phaneuf <pp@ludusdesign.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include <stdio.h>
  40 #include "nsHTMLEditorLog.h"
  41 #include "nsEditorTxnLog.h"
  42 #include "nsPIEditorTransaction.h"
  43
  44 #define LOCK_LOG(doc)
  45 #define UNLOCK_LOG(doc)
  46
  47
  48 nsEditorTxnLog::nsEditorTxnLog(nsHTMLEditorLog *aEditorLog)
  49 {
  50   mRefCnt      = 0;
  51   mIndentLevel = 0;
  52   mBatchCount  = 0;
  53   mEditorLog   = aEditorLog;
  54 }
  55
  56 nsEditorTxnLog::~nsEditorTxnLog()
  57 {
  58 }
  59
  60 // #define DEBUG_EDITOR_TXN_LOG_REFCNT 1
  61
  62 #ifdef DEBUG_EDITOR_TXN_LOG_REFCNT
  63
  64 nsrefcnt nsEditorTxnLog::AddRef(void)
  65 {
  66   return ++mRefCnt;
  67 }
  68
  69 nsrefcnt nsEditorTxnLog::Release(void)
  70 {
  71   NS_PRECONDITION(0 != mRefCnt, "dup release");
  72   if (--mRefCnt == 0) {
  73     NS_DELETEXPCOM(this);
  74     return 0;
  75   }
  76   return mRefCnt;
  77 }
  78
  79 #else
  80
  81 NS_IMPL_ADDREF(nsEditorTxnLog)
  82 NS_IMPL_RELEASE(nsEditorTxnLog)
  83
  84 #endif
  85
  86 NS_IMPL_QUERY_INTERFACE1(nsEditorTxnLog, nsITransactionListener)
  87
  88 NS_IMETHODIMP
  89 nsEditorTxnLog::WillDo(nsITransactionManager *aTxMgr, nsITransaction *aTransaction, PRBool *aInterrupt)
  90 {
  91   LOCK_LOG(this);
  92
  93   PrintIndent(mIndentLevel++);
  94   Write("WillDo:   ");
  95   WriteTransaction(aTransaction);
  96   Write("\n");
  97   Flush();
  98
  99   UNLOCK_LOG(this);
 100
 101   return NS_OK;
 102 }
 103
 104 NS_IMETHODIMP
 105 nsEditorTxnLog::DidDo(nsITransactionManager *aTxMgr, nsITransaction *aTransaction, nsresult aDoResult)
 106 {
 107   LOCK_LOG(this);
 108
 109   PrintIndent(--mIndentLevel);
 110   Write("DidDo:    ");
 111   WriteTransaction(aTransaction);
 112   Write("(");
 113   WriteInt(aDoResult);
 114   Write(")\n");
 115   Flush();
 116
 117   UNLOCK_LOG(this);
 118
 119   return NS_OK;
 120 }
 121
 122 NS_IMETHODIMP
 123 nsEditorTxnLog::WillUndo(nsITransactionManager *aTxMgr, nsITransaction *aTransaction, PRBool *aInterrupt)
 124 {
 125   LOCK_LOG(this);
 126
 127   PrintIndent(mIndentLevel++);
 128
 129   if (aTransaction)
 130   {
 131     Write("WillUndo:   ");
 132     WriteTransaction(aTransaction);
 133     Write("\n");
 134   }
 135   else
 136     Write("WillUndoBatch\n");
 137
 138   Flush();
 139
 140   UNLOCK_LOG(this);
 141
 142   return NS_OK;
 143 }
 144
 145 NS_IMETHODIMP
 146 nsEditorTxnLog::DidUndo(nsITransactionManager *aTxMgr, nsITransaction *aTransaction, nsresult aUndoResult)
 147 {
 148   LOCK_LOG(this);
 149
 150   PrintIndent(--mIndentLevel);
 151
 152   if (aTransaction)
 153   {
 154     Write("DidUndo:  ");
 155     WriteTransaction(aTransaction);
 156     Write("(");
 157     WriteInt(aUndoResult);
 158     Write(")\n");
 159   }
 160   else
 161   {
 162     Write("EndUndoBatch (");
 163     WriteInt(aUndoResult);
 164     Write(")\n");
 165   }
 166
 167   Flush();
 168
 169   UNLOCK_LOG(this);
 170
 171   return NS_OK;
 172 }
 173
 174 NS_IMETHODIMP
 175 nsEditorTxnLog::WillRedo(nsITransactionManager *aTxMgr, nsITransaction *aTransaction, PRBool *aInterrupt)
 176 {
 177   LOCK_LOG(this);
 178
 179   PrintIndent(mIndentLevel++);
 180
 181   if (aTransaction)
 182   {
 183     Write("WillRedo: ");
 184     WriteTransaction(aTransaction);
 185     Write("\n");
 186   }
 187   else
 188     Write("WillRedoBatch\n");
 189
 190   Flush();
 191
 192   UNLOCK_LOG(this);
 193
 194   return NS_OK;
 195 }
 196
 197 NS_IMETHODIMP
 198 nsEditorTxnLog::DidRedo(nsITransactionManager *aTxMgr, nsITransaction *aTransaction, nsresult aRedoResult)
 199 {
 200   LOCK_LOG(this);
 201
 202   PrintIndent(--mIndentLevel);
 203
 204   if (aTransaction)
 205   {
 206     Write("DidRedo:  ");
 207     WriteTransaction(aTransaction);
 208     Write(" (");
 209     WriteInt(aRedoResult);
 210     Write(")\n");
 211   }
 212   else
 213   {
 214     Write("DidRedoBatch (");
 215     WriteInt(aRedoResult);
 216     Write(")\n");
 217   }
 218
 219   Flush();
 220
 221   UNLOCK_LOG(this);
 222
 223   return NS_OK;
 224 }
 225
 226 NS_IMETHODIMP
 227 nsEditorTxnLog::WillBeginBatch(nsITransactionManager *aTxMgr, PRBool *aInterrupt)
 228 {
 229   LOCK_LOG(this);
 230
 231   PrintIndent(mIndentLevel);
 232   Write("WillBeginBatch: ");
 233   WriteInt(mBatchCount);
 234   Write("\n");
 235   Flush();
 236
 237   UNLOCK_LOG(this);
 238
 239   return NS_OK;
 240 }
 241
 242 NS_IMETHODIMP
 243 nsEditorTxnLog::DidBeginBatch(nsITransactionManager *aTxMgr, nsresult aResult)
 244 {
 245   LOCK_LOG(this);
 246
 247   PrintIndent(mIndentLevel++);
 248   Write("DidBeginBatch:  ");
 249   WriteInt(mBatchCount++);
 250   Write(" (");
 251   WriteInt(aResult);
 252   Write(")\n");
 253   Flush();
 254
 255   UNLOCK_LOG(this);
 256
 257   return NS_OK;
 258 }
 259
 260 NS_IMETHODIMP
 261 nsEditorTxnLog::WillEndBatch(nsITransactionManager *aTxMgr, PRBool *aInterrupt)
 262 {
 263   LOCK_LOG(this);
 264
 265   PrintIndent(--mIndentLevel);
 266   Write("WillEndBatch:   ");
 267   WriteInt(--mBatchCount);
 268   Write("\n");
 269   Flush();
 270
 271   UNLOCK_LOG(this);
 272
 273   return NS_OK;
 274 }
 275
 276 NS_IMETHODIMP
 277 nsEditorTxnLog::DidEndBatch(nsITransactionManager *aTxMgr, nsresult aResult)
 278 {
 279   LOCK_LOG(this);
 280
 281   PrintIndent(mIndentLevel);
 282   Write("DidEndBatch:    ");
 283   WriteInt(mBatchCount);
 284   Write(" (");
 285   WriteInt(aResult);
 286   Write(")\n");
 287   Flush();
 288
 289   UNLOCK_LOG(this);
 290
 291   return NS_OK;
 292 }
 293
 294 NS_IMETHODIMP
 295 nsEditorTxnLog::WillMerge(nsITransactionManager *aTxMgr, nsITransaction *aTopTransaction, nsITransaction *aTransaction, PRBool *aInterrupt)
 296 {
 297   LOCK_LOG(this);
 298
 299   PrintIndent(mIndentLevel);
 300   Write("WillMerge:   ");
 301   WriteTransaction(aTopTransaction);
 302   Write(" <-- ");
 303   WriteTransaction(aTransaction);
 304   Write("\n");
 305   Flush();
 306
 307   UNLOCK_LOG(this);
 308
 309   return NS_OK;
 310 }
 311
 312 NS_IMETHODIMP
 313 nsEditorTxnLog::DidMerge(nsITransactionManager *aTxMgr, nsITransaction *aTopTransaction, nsITransaction *aTransaction, PRBool aDidMerge, nsresult aMergeResult)
 314 {
 315   LOCK_LOG(this);
 316
 317   PrintIndent(mIndentLevel);
 318   Write("DidMerge:    ");
 319   WriteTransaction(aTopTransaction);
 320   Write(" <-- ");
 321   WriteTransaction(aTransaction);
 322   Write(" (");
 323   Write(aDidMerge ? "TRUE" : "FALSE");
 324   Write(", ");
 325   WriteInt(aMergeResult);
 326   Write(")\n");
 327   Flush();
 328
 329   UNLOCK_LOG(this);
 330
 331   return NS_OK;
 332 }
 333
 334 nsresult
 335 nsEditorTxnLog::WriteTransaction(nsITransaction *aTransaction)
 336 {
 337   nsString str;
 338
 339   nsCOMPtr<nsPIEditorTransaction> txn = do_QueryInterface(aTransaction);
 340   if (txn) {
 341     txn->GetTxnDescription(str);
 342     if (str.IsEmpty())
 343       str.AssignLiteral("<NULL>");
 344   }
 345
 346   return Write(NS_LossyConvertUTF16toASCII(str).get());
 347 }
 348
 349 nsresult
 350 nsEditorTxnLog::PrintIndent(PRInt32 aIndentLevel)
 351 {
 352   PRInt32 i;
 353
 354   Write("    // ");
 355
 356   for (i = 0; i < aIndentLevel; i++)
 357     Write("  ");
 358
 359   return NS_OK;
 360 }
 361
 362 nsresult
 363 nsEditorTxnLog::Write(const char *aBuffer)
 364 {
 365   if (!aBuffer)
 366     return NS_ERROR_NULL_POINTER;
 367
 368   if (mEditorLog)
 369     mEditorLog->Write(aBuffer);
 370   else
 371   {
 372     PRInt32 len = strlen(aBuffer);
 373     if (len > 0)
 374       fwrite(aBuffer, 1, len, stdout);
 375   }
 376
 377   return NS_OK;
 378 }
 379
 380 nsresult
 381 nsEditorTxnLog::WriteInt(PRInt32 aInt)
 382 {
 383   if (mEditorLog)
 384     mEditorLog->WriteInt(aInt);
 385   else
 386     printf("%d", aInt);
 387
 388   return NS_OK;
 389 }
 390
 391 nsresult
 392 nsEditorTxnLog::Flush()
 393 {
 394   nsresult result = NS_OK;
 395
 396 #ifdef SLOWS_THINGS_WAY_DOWN
 397
 398   if (mEditorLog)
 399     result = mEditorLog->Flush();
 400   else
 401     fflush(stdout);
 402
 403 #endif // SLOWS_THINGS_WAY_DOWN
 404
 405   return result;
 406 }