Back to index

lightning-sunbird  0.9+nobinonly
Defines | Functions | Variables
nsPlainTextSerializer.cpp File Reference
#include "nsPlainTextSerializer.h"
#include "nsILineBreakerFactory.h"
#include "nsLWBrkCIID.h"
#include "nsIServiceManager.h"
#include "nsHTMLAtoms.h"
#include "nsIDOMText.h"
#include "nsIDOMCDATASection.h"
#include "nsIDOMElement.h"
#include "nsINameSpaceManager.h"
#include "nsITextContent.h"
#include "nsTextFragment.h"
#include "nsContentUtils.h"
#include "nsReadableUtils.h"
#include "nsUnicharUtils.h"
#include "nsCRT.h"
#include "nsIParserService.h"

Go to the source code of this file.

Defines

#define PREF_STRUCTS   "converter.html2txt.structs"
#define PREF_HEADER_STRATEGY   "converter.html2txt.header_strategy"

Functions

static NS_DEFINE_CID (kLWBrkCID, NS_LWBRK_CID)
static PRInt32 HeaderLevel (eHTMLTags aTag)
static PRInt32 GetUnicharWidth (PRUnichar ucs)
static PRInt32 GetUnicharStringWidth (const PRUnichar *pwcs, PRInt32 n)
nsresult NS_NewPlainTextSerializer (nsIContentSerializer **aSerializer)
 NS_IMPL_ISUPPORTS4 (nsPlainTextSerializer, nsIContentSerializer, nsIContentSink, nsIHTMLContentSink, nsIHTMLToTextSink) NS_IMETHODIMP nsPlainTextSerializer

Variables

static const PRInt32 kTabSize = 4
static const PRInt32 kOLNumberWidth = 3
static const PRInt32 kIndentSizeHeaders = 2
static const PRInt32 kIndentIncrementHeaders = 2
static const PRInt32 kIndentSizeList = (kTabSize > kOLNumberWidth+3) ? kTabSize: kOLNumberWidth+3
static const PRInt32 kIndentSizeDD = kTabSize
static const PRUint32 TagStackSize = 500
static const PRUint32 OLStackSize = 100

Define Documentation

#define PREF_HEADER_STRATEGY   "converter.html2txt.header_strategy"

Definition at line 60 of file nsPlainTextSerializer.cpp.

#define PREF_STRUCTS   "converter.html2txt.structs"

Definition at line 59 of file nsPlainTextSerializer.cpp.


Function Documentation

PRInt32 GetUnicharStringWidth ( const PRUnichar pwcs,
PRInt32  n 
) [static]

Definition at line 2130 of file nsPlainTextSerializer.cpp.

{
  PRInt32 w, width = 0;

  for (;*pwcs && n-- > 0; pwcs++)
    if ((w = GetUnicharWidth(*pwcs)) < 0)
      ++width; // Taking 1 as the width of non-printable character, for bug# 94475.
    else
      width += w;

  return width;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PRInt32 GetUnicharWidth ( PRUnichar  ucs) [static]

Definition at line 2048 of file nsPlainTextSerializer.cpp.

{
  /* sorted list of non-overlapping intervals of non-spacing characters */
  static const struct interval {
    PRUint16 first;
    PRUint16 last;
  } combining[] = {
    { 0x0300, 0x034E }, { 0x0360, 0x0362 }, { 0x0483, 0x0486 },
    { 0x0488, 0x0489 }, { 0x0591, 0x05A1 }, { 0x05A3, 0x05B9 },
    { 0x05BB, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
    { 0x05C4, 0x05C4 }, { 0x064B, 0x0655 }, { 0x0670, 0x0670 },
    { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED },
    { 0x0711, 0x0711 }, { 0x0730, 0x074A }, { 0x07A6, 0x07B0 },
    { 0x0901, 0x0902 }, { 0x093C, 0x093C }, { 0x0941, 0x0948 },
    { 0x094D, 0x094D }, { 0x0951, 0x0954 }, { 0x0962, 0x0963 },
    { 0x0981, 0x0981 }, { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 },
    { 0x09CD, 0x09CD }, { 0x09E2, 0x09E3 }, { 0x0A02, 0x0A02 },
    { 0x0A3C, 0x0A3C }, { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 },
    { 0x0A4B, 0x0A4D }, { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 },
    { 0x0ABC, 0x0ABC }, { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 },
    { 0x0ACD, 0x0ACD }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C },
    { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D },
    { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 },
    { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 },
    { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBF, 0x0CBF },
    { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD }, { 0x0D41, 0x0D43 },
    { 0x0D4D, 0x0D4D }, { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 },
    { 0x0DD6, 0x0DD6 }, { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A },
    { 0x0E47, 0x0E4E }, { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 },
    { 0x0EBB, 0x0EBC }, { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 },
    { 0x0F35, 0x0F35 }, { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 },
    { 0x0F71, 0x0F7E }, { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 },
    { 0x0F90, 0x0F97 }, { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 },
    { 0x102D, 0x1030 }, { 0x1032, 0x1032 }, { 0x1036, 0x1037 },
    { 0x1039, 0x1039 }, { 0x1058, 0x1059 }, { 0x17B7, 0x17BD },
    { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x18A9, 0x18A9 },
    { 0x20D0, 0x20E3 }, { 0x302A, 0x302F }, { 0x3099, 0x309A },
    { 0xFB1E, 0xFB1E }, { 0xFE20, 0xFE23 }
  };
  PRInt32 min = 0;
  PRInt32 max = sizeof(combining) / sizeof(struct interval) - 1;
  PRInt32 mid;

  /* test for 8-bit control characters */
  if (ucs == 0)
    return 0;
  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
    return -1;

  /* first quick check for Latin-1 etc. characters */
  if (ucs < combining[0].first)
    return 1;

  /* binary search in table of non-spacing characters */
  while (max >= min) {
    mid = (min + max) / 2;
    if (combining[mid].last < ucs)
      min = mid + 1;
    else if (combining[mid].first > ucs)
      max = mid - 1;
    else if (combining[mid].first <= ucs && combining[mid].last >= ucs)
      return 0;
  }

  /* if we arrive here, ucs is not a combining or C0/C1 control character */

  /* fast test for majority of non-wide scripts */
  if (ucs < 0x1100)
    return 1;

  return 1 +
    ((ucs >= 0x1100 && ucs <= 0x115f) || /* Hangul Jamo */
     (ucs >= 0x2e80 && ucs <= 0xa4cf && (ucs & ~0x0011) != 0x300a &&
      ucs != 0x303f) ||                  /* CJK ... Yi */
     (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
     (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
     (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
     (ucs >= 0xff00 && ucs <= 0xff5f) || /* Fullwidth Forms */
     (ucs >= 0xffe0 && ucs <= 0xffe6));
}

Here is the caller graph for this function:

PRInt32 HeaderLevel ( eHTMLTags  aTag) [static]

Definition at line 1989 of file nsPlainTextSerializer.cpp.

{
  PRInt32 result;
  switch (aTag)
  {
    case eHTMLTag_h1:
      result = 1; break;
    case eHTMLTag_h2:
      result = 2; break;
    case eHTMLTag_h3:
      result = 3; break;
    case eHTMLTag_h4:
      result = 4; break;
    case eHTMLTag_h5:
      result = 5; break;
    case eHTMLTag_h6:
      result = 6; break;
    default:
      result = 0; break;
  }
  return result;
}

Here is the caller graph for this function:

static NS_DEFINE_CID ( kLWBrkCID  ,
NS_LWBRK_CID   
) [static]

Definition at line 141 of file nsPlainTextSerializer.cpp.

{
#ifdef DEBUG
  // Check if the major control flags are set correctly.
  if(aFlags & nsIDocumentEncoder::OutputFormatFlowed) {
    NS_ASSERTION(aFlags & nsIDocumentEncoder::OutputFormatted,
                 "If you want format=flowed, you must combine it with "
                 "nsIDocumentEncoder::OutputFormatted");
  }

  if(aFlags & nsIDocumentEncoder::OutputFormatted) {
    NS_ASSERTION(!(aFlags & nsIDocumentEncoder::OutputPreformatted),
                 "Can't do formatted and preformatted output at the same time!");
  }
#endif

  NS_ENSURE_TRUE(nsContentUtils::GetParserServiceWeakRef(),
                 NS_ERROR_UNEXPECTED);

  nsresult rv;
  
  mFlags = aFlags;
  mWrapColumn = aWrapColumn;

  // Only create a linebreaker if we will handle wrapping.
  if (MayWrap()) {
    nsCOMPtr<nsILineBreakerFactory> lf(do_GetService(kLWBrkCID, &rv));
    if (NS_SUCCEEDED(rv)) {
      nsAutoString lbarg;
      rv = lf->GetBreaker(lbarg, getter_AddRefs(mLineBreaker));
      if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
    }
  }

  // Set the line break character:
  if ((mFlags & nsIDocumentEncoder::OutputCRLineBreak)
      && (mFlags & nsIDocumentEncoder::OutputLFLineBreak)) {
    // Windows
    mLineBreak.AssignLiteral("\r\n");
  }
  else if (mFlags & nsIDocumentEncoder::OutputCRLineBreak) {
    // Mac
    mLineBreak.Assign(PRUnichar('\r'));
  }
  else if (mFlags & nsIDocumentEncoder::OutputLFLineBreak) {
    // Unix/DOM
    mLineBreak.Assign(PRUnichar('\n'));
  }
  else {
    // Platform/default
    mLineBreak.AssignLiteral(NS_LINEBREAK);
  }

  mLineBreakDue = PR_FALSE;
  mFloatingLines = -1;

  if (mFlags & nsIDocumentEncoder::OutputFormatted) {
    // Get some prefs that controls how we do formatted output
    mStructs = nsContentUtils::GetBoolPref(PREF_STRUCTS, mStructs);

    mHeaderStrategy =
      nsContentUtils::GetIntPref(PREF_HEADER_STRATEGY, mHeaderStrategy);

    // The quotesPreformatted pref is a temporary measure. See bug 69638.
    mQuotesPreformatted =
      nsContentUtils::GetBoolPref("editor.quotesPreformatted",
                                  mQuotesPreformatted);

    // DontWrapAnyQuotes is set according to whether plaintext mail
    // is wrapping to window width -- see bug 134439.
    // We'll only want this if we're wrapping and formatted.
    if (mFlags & nsIDocumentEncoder::OutputWrap || mWrapColumn > 0) {
      mDontWrapAnyQuotes =
        nsContentUtils::GetBoolPref("mail.compose.wrap_to_window_width",
                                    mDontWrapAnyQuotes);
    }
  }

  // XXX We should let the caller pass this in.
  if (nsContentUtils::GetBoolPref("browser.frames.enabled")) {
    mFlags &= ~nsIDocumentEncoder::OutputNoFramesContent;
  }
  else {
    mFlags |= nsIDocumentEncoder::OutputNoFramesContent;
  }

  return NS_OK;
}

Here is the call graph for this function:

Definition at line 84 of file nsPlainTextSerializer.cpp.

{
  nsPlainTextSerializer* it = new nsPlainTextSerializer();
  if (!it) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  return CallQueryInterface(it, aSerializer);
}

Here is the call graph for this function:


Variable Documentation

Definition at line 69 of file nsPlainTextSerializer.cpp.

Definition at line 74 of file nsPlainTextSerializer.cpp.

Definition at line 64 of file nsPlainTextSerializer.cpp.

Definition at line 72 of file nsPlainTextSerializer.cpp.

Definition at line 63 of file nsPlainTextSerializer.cpp.

const PRInt32 kTabSize = 4 [static]

Definition at line 62 of file nsPlainTextSerializer.cpp.

const PRUint32 OLStackSize = 100 [static]

Definition at line 82 of file nsPlainTextSerializer.cpp.

const PRUint32 TagStackSize = 500 [static]

Definition at line 81 of file nsPlainTextSerializer.cpp.