The Tor Browser / file comparison
comparison: editor/libeditor/text/nsInternetCiter.cpp
editor/libeditor/text/nsInternetCiter.cpp
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:1add8b05a974 |
|---|---|
| 1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ | |
| 2 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 3 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 5 | |
| 6 | |
| 7 #include "nsAString.h" | |
| 8 #include "nsCOMPtr.h" | |
| 9 #include "nsCRT.h" | |
| 10 #include "nsDebug.h" | |
| 11 #include "nsDependentSubstring.h" | |
| 12 #include "nsError.h" | |
| 13 #include "nsILineBreaker.h" | |
| 14 #include "nsInternetCiter.h" | |
| 15 #include "nsLWBrkCIID.h" | |
| 16 #include "nsServiceManagerUtils.h" | |
| 17 #include "nsString.h" | |
| 18 #include "nsStringIterator.h" | |
| 19 | |
| 20 const char16_t gt ('>'); | |
| 21 const char16_t space (' '); | |
| 22 const char16_t nbsp (0xa0); | |
| 23 const char16_t nl ('\n'); | |
| 24 const char16_t cr('\r'); | |
| 25 | |
| 26 /** Mail citations using the Internet style: > This is a citation | |
| 27 */ | |
| 28 | |
| 29 nsresult | |
| 30 nsInternetCiter::GetCiteString(const nsAString& aInString, nsAString& aOutString) | |
| 31 { | |
| 32 aOutString.Truncate(); | |
| 33 char16_t uch = nl; | |
| 34 | |
| 35 // Strip trailing new lines which will otherwise turn up | |
| 36 // as ugly quoted empty lines. | |
| 37 nsReadingIterator <char16_t> beginIter,endIter; | |
| 38 aInString.BeginReading(beginIter); | |
| 39 aInString.EndReading(endIter); | |
| 40 while(beginIter!= endIter && | |
| 41 (*endIter == cr || | |
| 42 *endIter == nl)) | |
| 43 { | |
| 44 --endIter; | |
| 45 } | |
| 46 | |
| 47 // Loop over the string: | |
| 48 while (beginIter != endIter) | |
| 49 { | |
| 50 if (uch == nl) | |
| 51 { | |
| 52 aOutString.Append(gt); | |
| 53 // No space between >: this is ">>> " style quoting, for | |
| 54 // compatibility with RFC 2646 and format=flowed. | |
| 55 if (*beginIter != gt) | |
| 56 aOutString.Append(space); | |
| 57 } | |
| 58 | |
| 59 uch = *beginIter; | |
| 60 ++beginIter; | |
| 61 | |
| 62 aOutString += uch; | |
| 63 } | |
| 64 | |
| 65 if (uch != nl) | |
| 66 aOutString += nl; | |
| 67 | |
| 68 return NS_OK; | |
| 69 } | |
| 70 | |
| 71 nsresult | |
| 72 nsInternetCiter::StripCitesAndLinebreaks(const nsAString& aInString, | |
| 73 nsAString& aOutString, | |
| 74 bool aLinebreaksToo, | |
| 75 int32_t* aCiteLevel) | |
| 76 { | |
| 77 if (aCiteLevel) | |
| 78 *aCiteLevel = 0; | |
| 79 | |
| 80 aOutString.Truncate(); | |
| 81 nsReadingIterator <char16_t> beginIter,endIter; | |
| 82 aInString.BeginReading(beginIter); | |
| 83 aInString.EndReading(endIter); | |
| 84 while (beginIter!= endIter) // loop over lines | |
| 85 { | |
| 86 // Clear out cites first, at the beginning of the line: | |
| 87 int32_t thisLineCiteLevel = 0; | |
| 88 while (beginIter!= endIter && (*beginIter == gt || nsCRT::IsAsciiSpace(*beginIter))) | |
| 89 { | |
| 90 if (*beginIter == gt) ++thisLineCiteLevel; | |
| 91 ++beginIter; | |
| 92 } | |
| 93 | |
| 94 // Now copy characters until line end: | |
| 95 while (beginIter != endIter && (*beginIter != '\r' && *beginIter != '\n')) | |
| 96 { | |
| 97 aOutString.Append(*beginIter); | |
| 98 ++beginIter; | |
| 99 } | |
| 100 if (aLinebreaksToo) | |
| 101 aOutString.Append(char16_t(' ')); | |
| 102 else | |
| 103 aOutString.Append(char16_t('\n')); // DOM linebreaks, not NS_LINEBREAK | |
| 104 // Skip over any more consecutive linebreak-like characters: | |
| 105 while (beginIter != endIter && (*beginIter == '\r' || *beginIter == '\n')) | |
| 106 ++beginIter; | |
| 107 | |
| 108 // Done with this line -- update cite level | |
| 109 if (aCiteLevel && (thisLineCiteLevel > *aCiteLevel)) | |
| 110 *aCiteLevel = thisLineCiteLevel; | |
| 111 } | |
| 112 return NS_OK; | |
| 113 } | |
| 114 | |
| 115 nsresult | |
| 116 nsInternetCiter::StripCites(const nsAString& aInString, nsAString& aOutString) | |
| 117 { | |
| 118 return StripCitesAndLinebreaks(aInString, aOutString, false, 0); | |
| 119 } | |
| 120 | |
| 121 static void AddCite(nsAString& aOutString, int32_t citeLevel) | |
| 122 { | |
| 123 for (int32_t i = 0; i < citeLevel; ++i) | |
| 124 aOutString.Append(gt); | |
| 125 if (citeLevel > 0) | |
| 126 aOutString.Append(space); | |
| 127 } | |
| 128 | |
| 129 static inline void | |
| 130 BreakLine(nsAString& aOutString, uint32_t& outStringCol, | |
| 131 uint32_t citeLevel) | |
| 132 { | |
| 133 aOutString.Append(nl); | |
| 134 if (citeLevel > 0) | |
| 135 { | |
| 136 AddCite(aOutString, citeLevel); | |
| 137 outStringCol = citeLevel + 1; | |
| 138 } | |
| 139 else | |
| 140 outStringCol = 0; | |
| 141 } | |
| 142 | |
| 143 static inline bool IsSpace(char16_t c) | |
| 144 { | |
| 145 return (nsCRT::IsAsciiSpace(c) || (c == nl) || (c == cr) || (c == nbsp)); | |
| 146 } | |
| 147 | |
| 148 nsresult | |
| 149 nsInternetCiter::Rewrap(const nsAString& aInString, | |
| 150 uint32_t aWrapCol, uint32_t aFirstLineOffset, | |
| 151 bool aRespectNewlines, | |
| 152 nsAString& aOutString) | |
| 153 { | |
| 154 // There shouldn't be returns in this string, only dom newlines. | |
| 155 // Check to make sure: | |
| 156 #ifdef DEBUG | |
| 157 int32_t cr = aInString.FindChar(char16_t('\r')); | |
| 158 NS_ASSERTION((cr < 0), "Rewrap: CR in string gotten from DOM!\n"); | |
| 159 #endif /* DEBUG */ | |
| 160 | |
| 161 aOutString.Truncate(); | |
| 162 | |
| 163 nsresult rv; | |
| 164 nsCOMPtr<nsILineBreaker> lineBreaker = do_GetService(NS_LBRK_CONTRACTID, &rv); | |
| 165 NS_ENSURE_SUCCESS(rv, rv); | |
| 166 | |
| 167 // Loop over lines in the input string, rewrapping each one. | |
| 168 uint32_t length; | |
| 169 uint32_t posInString = 0; | |
| 170 uint32_t outStringCol = 0; | |
| 171 uint32_t citeLevel = 0; | |
| 172 const nsPromiseFlatString &tString = PromiseFlatString(aInString); | |
| 173 length = tString.Length(); | |
| 174 #ifdef DEBUG_wrapping | |
| 175 int loopcount = 0; | |
| 176 #endif | |
| 177 while (posInString < length) | |
| 178 { | |
| 179 #ifdef DEBUG_wrapping | |
| 180 printf("Outer loop: '%s'\n", | |
| 181 NS_LossyConvertUTF16toASCII(Substring(tString, posInString, | |
| 182 length-posInString)).get()); | |
| 183 printf("out string is now: '%s'\n", | |
| 184 NS_LossyConvertUTF16toASCII(aOutString).get()); | |
| 185 | |
| 186 #endif | |
| 187 | |
| 188 // Get the new cite level here since we're at the beginning of a line | |
| 189 uint32_t newCiteLevel = 0; | |
| 190 while (posInString < length && tString[posInString] == gt) | |
| 191 { | |
| 192 ++newCiteLevel; | |
| 193 ++posInString; | |
| 194 while (posInString < length && tString[posInString] == space) | |
| 195 ++posInString; | |
| 196 } | |
| 197 if (posInString >= length) | |
| 198 break; | |
| 199 | |
| 200 // Special case: if this is a blank line, maintain a blank line | |
| 201 // (retain the original paragraph breaks) | |
| 202 if (tString[posInString] == nl && !aOutString.IsEmpty()) | |
| 203 { | |
| 204 if (aOutString.Last() != nl) | |
| 205 aOutString.Append(nl); | |
| 206 AddCite(aOutString, newCiteLevel); | |
| 207 aOutString.Append(nl); | |
| 208 | |
| 209 ++posInString; | |
| 210 outStringCol = 0; | |
| 211 continue; | |
| 212 } | |
| 213 | |
| 214 // If the cite level has changed, then start a new line with the | |
| 215 // new cite level (but if we're at the beginning of the string, | |
| 216 // don't bother). | |
| 217 if (newCiteLevel != citeLevel && posInString > newCiteLevel+1 | |
| 218 && outStringCol != 0) | |
| 219 { | |
| 220 BreakLine(aOutString, outStringCol, 0); | |
| 221 } | |
| 222 citeLevel = newCiteLevel; | |
| 223 | |
| 224 // Prepend the quote level to the out string if appropriate | |
| 225 if (outStringCol == 0) | |
| 226 { | |
| 227 AddCite(aOutString, citeLevel); | |
| 228 outStringCol = citeLevel + (citeLevel ? 1 : 0); | |
| 229 } | |
| 230 // If it's not a cite, and we're not at the beginning of a line in | |
| 231 // the output string, add a space to separate new text from the | |
| 232 // previous text. | |
| 233 else if (outStringCol > citeLevel) | |
| 234 { | |
| 235 aOutString.Append(space); | |
| 236 ++outStringCol; | |
| 237 } | |
| 238 | |
| 239 // find the next newline -- don't want to go farther than that | |
| 240 int32_t nextNewline = tString.FindChar(nl, posInString); | |
| 241 if (nextNewline < 0) nextNewline = length; | |
| 242 | |
| 243 // For now, don't wrap unquoted lines at all. | |
| 244 // This is because the plaintext edit window has already wrapped them | |
| 245 // by the time we get them for rewrap, yet when we call the line | |
| 246 // breaker, it will refuse to break backwards, and we'll end up | |
| 247 // with a line that's too long and gets displayed as a lone word | |
| 248 // on a line by itself. Need special logic to detect this case | |
| 249 // and break it ourselves without resorting to the line breaker. | |
| 250 if (citeLevel == 0) | |
| 251 { | |
| 252 aOutString.Append(Substring(tString, posInString, | |
| 253 nextNewline-posInString)); | |
| 254 outStringCol += nextNewline - posInString; | |
| 255 if (nextNewline != (int32_t)length) | |
| 256 { | |
| 257 aOutString.Append(nl); | |
| 258 outStringCol = 0; | |
| 259 } | |
| 260 posInString = nextNewline+1; | |
| 261 continue; | |
| 262 } | |
| 263 | |
| 264 // Otherwise we have to use the line breaker and loop | |
| 265 // over this line of the input string to get all of it: | |
| 266 while ((int32_t)posInString < nextNewline) | |
| 267 { | |
| 268 #ifdef DEBUG_wrapping | |
| 269 if (++loopcount > 1000) | |
| 270 NS_ASSERTION(false, "possible infinite loop in nsInternetCiter\n"); | |
| 271 | |
| 272 printf("Inner loop: '%s'\n", | |
| 273 NS_LossyConvertUTF16toASCII(Substring(tString, posInString, | |
| 274 nextNewline-posInString)).get()); | |
| 275 #endif | |
| 276 | |
| 277 // Skip over initial spaces: | |
| 278 while ((int32_t)posInString < nextNewline | |
| 279 && nsCRT::IsAsciiSpace(tString[posInString])) | |
| 280 ++posInString; | |
| 281 | |
| 282 // If this is a short line, just append it and continue: | |
| 283 if (outStringCol + nextNewline - posInString <= aWrapCol-citeLevel-1) | |
| 284 { | |
| 285 // If this short line is the final one in the in string, | |
| 286 // then we need to include the final newline, if any: | |
| 287 if (nextNewline+1 == (int32_t)length && tString[nextNewline-1] == nl) | |
| 288 ++nextNewline; | |
| 289 | |
| 290 // Trim trailing spaces: | |
| 291 int32_t lastRealChar = nextNewline; | |
| 292 while ((uint32_t)lastRealChar > posInString | |
| 293 && nsCRT::IsAsciiSpace(tString[lastRealChar-1])) | |
| 294 --lastRealChar; | |
| 295 | |
| 296 aOutString += Substring(tString, | |
| 297 posInString, lastRealChar - posInString); | |
| 298 outStringCol += lastRealChar - posInString; | |
| 299 posInString = nextNewline + 1; | |
| 300 continue; | |
| 301 } | |
| 302 | |
| 303 int32_t eol = posInString + aWrapCol - citeLevel - outStringCol; | |
| 304 // eol is the prospective end of line. | |
| 305 // We'll first look backwards from there for a place to break. | |
| 306 // If it's already less than our current position, | |
| 307 // then our line is already too long, so break now. | |
| 308 if (eol <= (int32_t)posInString) | |
| 309 { | |
| 310 BreakLine(aOutString, outStringCol, citeLevel); | |
| 311 continue; // continue inner loop, with outStringCol now at bol | |
| 312 } | |
| 313 | |
| 314 int32_t breakPt = 0; | |
| 315 rv = NS_ERROR_BASE; | |
| 316 if (lineBreaker) | |
| 317 { | |
| 318 breakPt = lineBreaker->Prev(tString.get() + posInString, | |
| 319 length - posInString, eol + 1 - posInString); | |
| 320 if (breakPt == NS_LINEBREAKER_NEED_MORE_TEXT) | |
| 321 { | |
| 322 // if we couldn't find a breakpoint looking backwards, | |
| 323 // and we're not starting a new line, then end this line | |
| 324 // and loop around again: | |
| 325 if (outStringCol > citeLevel + 1) | |
| 326 { | |
| 327 BreakLine(aOutString, outStringCol, citeLevel); | |
| 328 continue; // continue inner loop, with outStringCol now at bol | |
| 329 } | |
| 330 | |
| 331 // Else try looking forwards: | |
| 332 breakPt = lineBreaker->Next(tString.get() + posInString, | |
| 333 length - posInString, eol - posInString); | |
| 334 if (breakPt == NS_LINEBREAKER_NEED_MORE_TEXT) rv = NS_ERROR_BASE; | |
| 335 else rv = NS_OK; | |
| 336 } | |
| 337 else rv = NS_OK; | |
| 338 } | |
| 339 // If rv is okay, then breakPt is the place to break. | |
| 340 // If we get out here and rv is set, something went wrong with line | |
| 341 // breaker. Just break the line, hard. | |
| 342 if (NS_FAILED(rv)) | |
| 343 { | |
| 344 #ifdef DEBUG_akkana | |
| 345 printf("nsInternetCiter: LineBreaker not working -- breaking hard\n"); | |
| 346 #endif | |
| 347 breakPt = eol; | |
| 348 } | |
| 349 | |
| 350 // Special case: maybe we should have wrapped last time. | |
| 351 // If the first breakpoint here makes the current line too long, | |
| 352 // then if we already have text on the current line, | |
| 353 // break and loop around again. | |
| 354 // If we're at the beginning of the current line, though, | |
| 355 // don't force a break since the long word might be a url | |
| 356 // and breaking it would make it unclickable on the other end. | |
| 357 const int SLOP = 6; | |
| 358 if (outStringCol + breakPt > aWrapCol + SLOP | |
| 359 && outStringCol > citeLevel+1) | |
| 360 { | |
| 361 BreakLine(aOutString, outStringCol, citeLevel); | |
| 362 continue; | |
| 363 } | |
| 364 | |
| 365 nsAutoString sub (Substring(tString, posInString, breakPt)); | |
| 366 // skip newlines or whitespace at the end of the string | |
| 367 int32_t subend = sub.Length(); | |
| 368 while (subend > 0 && IsSpace(sub[subend-1])) | |
| 369 --subend; | |
| 370 sub.Left(sub, subend); | |
| 371 aOutString += sub; | |
| 372 outStringCol += sub.Length(); | |
| 373 // Advance past the whitespace which caused the wrap: | |
| 374 posInString += breakPt; | |
| 375 while (posInString < length && IsSpace(tString[posInString])) | |
| 376 ++posInString; | |
| 377 | |
| 378 // Add a newline and the quote level to the out string | |
| 379 if (posInString < length) // not for the last line, though | |
| 380 BreakLine(aOutString, outStringCol, citeLevel); | |
| 381 | |
| 382 } // end inner loop within one line of aInString | |
| 383 #ifdef DEBUG_wrapping | |
| 384 printf("---------\nEnd inner loop: out string is now '%s'\n-----------\n", | |
| 385 NS_LossyConvertUTF16toASCII(aOutString).get()); | |
| 386 #endif | |
| 387 } // end outer loop over lines of aInString | |
| 388 | |
| 389 #ifdef DEBUG_wrapping | |
| 390 printf("Final out string is now: '%s'\n", | |
| 391 NS_LossyConvertUTF16toASCII(aOutString).get()); | |
| 392 | |
| 393 #endif | |
| 394 return NS_OK; | |
| 395 } | |
| 396 | |
| 397 |
