3 * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 * PROJECT: ReactOS user32.dll
21 * FILE: lib/user32/windows/input.c
23 * PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
25 * 09-05-2001 CSH Created
28 /* INCLUDES ******************************************************************/
32 #include <wine/debug.h>
34 WINE_DEFAULT_DEBUG_CHANNEL(text
);
36 /* FUNCTIONS *****************************************************************/
44 #define assert(e) ((e) ? (void)0 : _font_assert(#e, __FILE__, __LINE__))
48 void _font_assert(const char *msg
, const char *file
, int line
)
50 /* Assertion failed at foo.c line 45: x<y */
51 DbgPrint("Assertion failed at %s line %d: %s\n", file
, line
, msg
);
53 for(;;); /* eliminate warning by mingw */
68 CONST INT
*lpnTabStopPositions
,
75 len
= MultiByteToWideChar(CP_ACP
, 0, lpString
, nCount
, NULL
, 0);
76 strW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
81 MultiByteToWideChar(CP_ACP
, 0, lpString
, nCount
, strW
, len
);
82 ret
= TabbedTextOutW(hDC
, X
, Y
, strW
, len
, nTabPositions
, lpnTabStopPositions
, nTabOrigin
);
83 HeapFree(GetProcessHeap(), 0, strW
);
88 /***********************************************************************
91 * Helper function for TabbedTextOut() and GetTabbedTextExtent().
92 * Note: this doesn't work too well for text-alignment modes other
93 * than TA_LEFT|TA_TOP. But we want bug-for-bug compatibility :-)
95 /* WINE synced 22-May-2006 */
96 static LONG
TEXT_TabbedTextOut( HDC hdc
, INT x
, INT y
, LPCWSTR lpstr
,
97 INT count
, INT cTabStops
, const INT
*lpTabPos
, INT nTabOrg
,
110 defWidth
= *lpTabPos
;
116 GetTextMetricsA( hdc
, &tm
);
117 defWidth
= 8 * tm
.tmAveCharWidth
;
126 /* chop the string into substrings of 0 or more <tabs>
127 * possibly followed by 1 or more normal characters */
128 for (i
= 0; i
< count
; i
++)
129 if (lpstr
[i
] != '\t') break;
130 for (j
= i
; j
< count
; j
++)
131 if (lpstr
[j
] == '\t') break;
132 /* get the extent of the normal character part */
133 GetTextExtentPointW( hdc
, lpstr
+ i
, j
- i
, &extent
);
134 /* and if there is a <tab>, calculate its position */
136 /* get x coordinate for the drawing of this string */
137 for (; cTabStops
> i
; lpTabPos
++, cTabStops
--)
139 if( nTabOrg
+ abs( *lpTabPos
) > x
) {
140 if( lpTabPos
[ i
- 1] >= 0) {
141 /* a left aligned tab */
142 x
= nTabOrg
+ lpTabPos
[ i
-1] + extent
.cx
;
147 /* if tab pos is negative then text is right-aligned
148 * to tab stop meaning that the string extends to the
149 * left, so we must subtract the width of the string */
150 if (nTabOrg
- lpTabPos
[ i
- 1] - extent
.cx
> x
)
152 x
= nTabOrg
- lpTabPos
[ i
- 1];
159 /* if we have run out of tab stops and we have a valid default tab
160 * stop width then round x up to that width */
161 if ((cTabStops
<= i
) && (defWidth
> 0)) {
162 x0
= nTabOrg
+ ((x
- nTabOrg
) / defWidth
+ i
) * defWidth
;
164 } else if ((cTabStops
<= i
) && (defWidth
< 0)) {
165 x
= nTabOrg
+ ((x
- nTabOrg
+ extent
.cx
) / -defWidth
+ i
)
176 r
.bottom
= y
+ extent
.cy
;
177 ExtTextOutW( hdc
, x0
, y
, GetBkMode(hdc
) == OPAQUE
? ETO_OPAQUE
: 0,
178 &r
, lpstr
+ i
, j
- i
, NULL
);
183 return MAKELONG(x
- start
, extent
.cy
);
198 CONST INT
*lpnTabStopPositions
,
201 return TEXT_TabbedTextOut(hDC
, X
, Y
, lpString
, nCount
, nTabPositions
, lpnTabStopPositions
, nTabOrigin
, TRUE
);
204 /* WINE synced 22-May-2006 */
210 GetTabbedTextExtentA(
215 CONST INT
*lpnTabStopPositions
)
218 DWORD len
= MultiByteToWideChar(CP_ACP
, 0, lpString
, nCount
, NULL
, 0);
219 LPWSTR strW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
223 MultiByteToWideChar(CP_ACP
, 0, lpString
, nCount
, strW
, len
);
225 ret
= GetTabbedTextExtentW(hDC
, strW
, len
, nTabPositions
,
226 lpnTabStopPositions
);
228 HeapFree(GetProcessHeap(), 0, strW
);
238 GetTabbedTextExtentW(
243 CONST INT
*lpnTabStopPositions
)
245 return TEXT_TabbedTextOut(hDC
, 0, 0, lpString
, nCount
, nTabPositions
, lpnTabStopPositions
, 0, FALSE
);
248 /*********************************************************************
253 * Copyright 1993, 1994 Alexandre Julliard
254 * Copyright 2002 Bill Medland
257 * How many buffers to use
258 * While processing in DrawText there are potentially three different forms
259 * of the text that need to be held. How are they best held?
260 * 1. The original text is needed, of course, to see what to display.
261 * 2. The text that will be returned to the user if the DT_MODIFYSTRING is
263 * 3. The buffered text that is about to be displayed e.g. the current line.
264 * Typically this will exclude the ampersands used for prefixing etc.
267 * a. If the buffered text to be displayed includes the ampersands then
268 * we will need special measurement and draw functions that will ignore
269 * the ampersands (e.g. by copying to a buffer without the prefix and
270 * then using the normal forms). This may involve less space but may
271 * require more processing. e.g. since a line containing tabs may
272 * contain several underlined characters either we need to carry around
273 * a list of prefix locations or we may need to locate them several
275 * b. If we actually directly modify the "original text" as we go then we
276 * will need some special "caching" to handle the fact that when we
277 * ellipsify the text the ellipsis may modify the next line of text,
278 * which we have not yet processed. (e.g. ellipsification of a W at the
279 * end of a line will overwrite the W, the \n and the first character of
280 * the next line, and a \0 will overwrite the second. Try it!!)
282 * Option 1. Three separate storages. (To be implemented)
283 * If DT_MODIFYSTRING is in effect then allocate an extra buffer to hold
284 * the edited string in some form, either as the string itself or as some
285 * sort of "edit list" to be applied just before returning.
286 * Use a buffer that holds the ellipsified current line sans ampersands
287 * and accept the need occasionally to recalculate the prefixes (if
288 * DT_EXPANDTABS and not DT_NOPREFIX and not DT_HIDEPREFIX)
297 #define FORWARD_SLASH '/'
298 #define BACK_SLASH '\\'
300 static const WCHAR ELLIPSISW
[] = {'.','.','.', 0};
302 typedef struct tag_ellipsis_data
310 /*********************************************************************
311 * TEXT_Ellipsify (static)
313 * Add an ellipsis to the end of the given string whilst ensuring it fits.
315 * If the ellipsis alone doesn't fit then it will be returned anyway.
317 * See Also TEXT_PathEllipsify
320 * hdc [in] The handle to the DC that defines the font.
321 * str [in/out] The string that needs to be modified.
322 * max_str [in] The dimension of str (number of WCHAR).
323 * len_str [in/out] The number of characters in str
324 * width [in] The maximum width permitted (in logical coordinates)
325 * size [out] The dimensions of the text
326 * modstr [out] The modified form of the string, to be returned to the
327 * calling program. It is assumed that the caller has
328 * made sufficient space available so we don't need to
329 * know the size of the space. This pointer may be NULL if
330 * the modified string is not required.
331 * len_before [out] The number of characters before the ellipsis.
332 * len_ellip [out] The number of characters in the ellipsis.
334 * See for example Microsoft article Q249678.
336 * For now we will simply use three dots rather than worrying about whether
337 * the font contains an explicit ellipsis character.
339 static void TEXT_Ellipsify (HDC hdc
, WCHAR
*str
, unsigned int max_len
,
340 unsigned int *len_str
, int width
, SIZE
*size
,
342 int *len_before
, int *len_ellip
)
344 unsigned int len_ellipsis
;
345 unsigned int lo
, mid
, hi
;
347 len_ellipsis
= strlenW (ELLIPSISW
);
348 if (len_ellipsis
> max_len
) len_ellipsis
= max_len
;
349 if (*len_str
> max_len
- len_ellipsis
)
350 *len_str
= max_len
- len_ellipsis
;
352 /* First do a quick binary search to get an upper bound for *len_str. */
354 GetTextExtentExPointW(hdc
, str
, *len_str
, width
, NULL
, NULL
, size
) &&
357 for (lo
= 0, hi
= *len_str
; lo
< hi
; )
360 if (!GetTextExtentExPointW(hdc
, str
, mid
, width
, NULL
, NULL
, size
))
362 if (size
->cx
> width
)
369 /* Now this should take only a couple iterations at most. */
372 memcpy(str
+ *len_str
, ELLIPSISW
, len_ellipsis
*sizeof(WCHAR
));
374 if (!GetTextExtentExPointW (hdc
, str
, *len_str
+ len_ellipsis
, width
,
375 NULL
, NULL
, size
)) break;
377 if (!*len_str
|| size
->cx
<= width
) break;
381 *len_ellip
= len_ellipsis
;
382 *len_before
= *len_str
;
383 *len_str
+= len_ellipsis
;
387 memcpy (modstr
, str
, *len_str
* sizeof(WCHAR
));
388 modstr
[*len_str
] = '\0';
392 /*********************************************************************
393 * TEXT_PathEllipsify (static)
395 * Add an ellipsis to the provided string in order to make it fit within
396 * the width. The ellipsis is added as specified for the DT_PATH_ELLIPSIS
399 * See Also TEXT_Ellipsify
402 * hdc [in] The handle to the DC that defines the font.
403 * str [in/out] The string that needs to be modified
404 * max_str [in] The dimension of str (number of WCHAR).
405 * len_str [in/out] The number of characters in str
406 * width [in] The maximum width permitted (in logical coordinates)
407 * size [out] The dimensions of the text
408 * modstr [out] The modified form of the string, to be returned to the
409 * calling program. It is assumed that the caller has
410 * made sufficient space available so we don't need to
411 * know the size of the space. This pointer may be NULL if
412 * the modified string is not required.
413 * pellip [out] The ellipsification results
415 * For now we will simply use three dots rather than worrying about whether
416 * the font contains an explicit ellipsis character.
418 * The following applies, I think to Win95. We will need to extend it for
419 * Win98 which can have both path and end ellipsis at the same time (e.g.
420 * C:\MyLongFileName.Txt becomes ...\MyLongFileN...)
422 * The resulting string consists of as much as possible of the following:
423 * 1. The ellipsis itself
424 * 2. The last \ or / of the string (if any)
425 * 3. Everything after the last \ or / of the string (if any) or the whole
426 * string if there is no / or \. I believe that under Win95 this would
427 * include everything even though some might be clipped off the end whereas
428 * under Win98 that might be ellipsified too.
429 * Yet to be investigated is whether this would include wordbreaking if the
430 * filename is more than 1 word and splitting if DT_EDITCONTROL was in
431 * effect. (If DT_EDITCONTROL is in effect then on occasions text will be
432 * broken within words).
433 * 4. All the stuff before the / or \, which is placed before the ellipsis.
435 static void TEXT_PathEllipsify (HDC hdc
, WCHAR
*str
, unsigned int max_len
,
436 unsigned int *len_str
, int width
, SIZE
*size
,
437 WCHAR
*modstr
, ellipsis_data
*pellip
)
442 WCHAR
*lastBkSlash
, *lastFwdSlash
, *lastSlash
;
444 len_ellipsis
= strlenW (ELLIPSISW
);
445 if (!max_len
) return;
446 if (len_ellipsis
>= max_len
) len_ellipsis
= max_len
- 1;
447 if (*len_str
+ len_ellipsis
>= max_len
)
448 *len_str
= max_len
- len_ellipsis
-1;
449 /* Hopefully this will never happen, otherwise it would probably lose
450 * the wrong character
452 str
[*len_str
] = '\0'; /* to simplify things */
454 lastBkSlash
= strrchrW (str
, BACK_SLASH
);
455 lastFwdSlash
= strrchrW (str
, FORWARD_SLASH
);
456 lastSlash
= lastBkSlash
> lastFwdSlash
? lastBkSlash
: lastFwdSlash
;
457 if (!lastSlash
) lastSlash
= str
;
458 len_trailing
= *len_str
- (lastSlash
- str
);
460 /* overlap-safe movement to the right */
461 memmove (lastSlash
+len_ellipsis
, lastSlash
, len_trailing
* sizeof(WCHAR
));
462 memcpy (lastSlash
, ELLIPSISW
, len_ellipsis
*sizeof(WCHAR
));
463 len_trailing
+= len_ellipsis
;
464 /* From this point on lastSlash actually points to the ellipsis in front
465 * of the last slash and len_trailing includes the ellipsis
471 if (!GetTextExtentExPointW (hdc
, str
, *len_str
+ len_ellipsis
, width
,
472 NULL
, NULL
, size
)) break;
474 if (lastSlash
== str
|| size
->cx
<= width
) break;
476 /* overlap-safe movement to the left */
477 memmove (lastSlash
-1, lastSlash
, len_trailing
* sizeof(WCHAR
));
484 pellip
->before
= lastSlash
-str
;
485 pellip
->len
= len_ellipsis
;
486 pellip
->under
= len_under
;
487 pellip
->after
= len_trailing
- len_ellipsis
;
488 *len_str
+= len_ellipsis
;
492 memcpy(modstr
, str
, *len_str
* sizeof(WCHAR
));
493 modstr
[*len_str
] = '\0';
497 /* Check the character is Chinese, Japanese, Korean and/or Thai */
498 inline BOOL
IsCJKT(WCHAR wch
)
500 if (0x0E00 <= wch
&& wch
<= 0x0E7F)
501 return TRUE
; /* Thai */
503 if (0x3000 <= wch
&& wch
<= 0x9FFF)
504 return TRUE
; /* CJK */
506 if (0xAC00 <= wch
&& wch
<= 0xD7FF)
507 return TRUE
; /* Korean */
509 if (0xFF00 <= wch
&& wch
<= 0xFFEF)
510 return TRUE
; /* CJK */
515 /* See http://en.wikipedia.org/wiki/Kinsoku_shori */
516 static const WCHAR KinsokuClassA
[] =
518 0x2010, 0x2013, 0x2019, 0x201D, 0x203C, 0x2047, 0x2048, 0x2049, 0x3001,
519 0x3002, 0x3005, 0x3009, 0x300B, 0x300D, 0x300F, 0x3011, 0x3015, 0x3017,
520 0x3019, 0x301C, 0x301F, 0x303B, 0x3041, 0x3043, 0x3045, 0x3047, 0x3049,
521 0x3063, 0x3083, 0x3085, 0x3087, 0x308E, 0x3095, 0x3096, 0x30A0, 0x30A1,
522 0x30A3, 0x30A5, 0x30A7, 0x30A9, 0x30C3, 0x30E3, 0x30E5, 0x30E7, 0x30EE,
523 0x30F5, 0x30F6, 0x30FB, 0x30FC, 0x30FD, 0x30FE, 0x31F0, 0x31F1, 0x31F2,
524 0x31F3, 0x31F4, 0x31F5, 0x31F6, 0x31F7, 0x31F8, 0x31F9, 0x31FA, 0x31FB,
525 0x31FC, 0x31FD, 0x31FE, 0x31FF, 0xFF01, 0xFF09, 0xFF0C, 0xFF0E, 0xFF1A,
526 0xFF1B, 0xFF1F, 0xFF3D, 0xFF5D, 0xFF60, 0
529 /*********************************************************************
530 * TEXT_WordBreak (static)
532 * Perform wordbreak processing on the given string
534 * Assumes that DT_WORDBREAK has been specified and not all the characters
535 * fit. Note that this function should even be called when the first character
536 * that doesn't fit is known to be a space or tab, so that it can swallow them.
538 * Note that the Windows processing has some strange properties.
539 * 1. If the text is left-justified and there is room for some of the spaces
540 * that follow the last word on the line then those that fit are included on
542 * 2. If the text is centred or right-justified and there is room for some of
543 * the spaces that follow the last word on the line then all but one of those
544 * that fit are included on the line.
545 * 3. (Reasonable behaviour) If the word breaking causes a space to be the first
546 * character of a new line it will be skipped.
549 * hdc [in] The handle to the DC that defines the font.
550 * str [in/out] The string that needs to be broken.
551 * max_str [in] The dimension of str (number of WCHAR).
552 * len_str [in/out] The number of characters in str
553 * width [in] The maximum width permitted
554 * format [in] The format flags in effect
555 * chars_fit [in] The maximum number of characters of str that are already
556 * known to fit; chars_fit+1 is known not to fit.
557 * chars_used [out] The number of characters of str that have been "used" and
558 * do not need to be included in later text. For example this will
559 * include any spaces that have been discarded from the start of
561 * size [out] The size of the returned text in logical coordinates
563 * Pedantic assumption - Assumes that the text length is monotonically
564 * increasing with number of characters (i.e. no weird kernings)
568 * Work back from the last character that did fit to either a space or the last
569 * character of a word, whichever is met first.
570 * If there was one or the first character didn't fit then
571 * If the text is centred or right justified and that one character was a
572 * space then break the line before that character
573 * Otherwise break the line after that character
574 * and if the next character is a space then discard it.
575 * Suppose there was none (and the first character did fit).
576 * If Break Within Word is permitted
577 * break the word after the last character that fits (there must be
578 * at least one; none is caught earlier).
580 * discard any trailing space.
581 * include the whole word; it may be ellipsified later
583 * Break Within Word is permitted under a set of circumstances that are not
584 * totally clear yet. Currently our best guess is:
585 * If DT_EDITCONTROL is in effect and neither DT_WORD_ELLIPSIS nor
586 * DT_PATH_ELLIPSIS is
589 static void TEXT_WordBreak (HDC hdc
, WCHAR
*str
, unsigned int max_str
,
590 unsigned int *len_str
,
591 int width
, int format
, unsigned int chars_fit
,
592 unsigned int *chars_used
, SIZE
*size
)
596 assert (format
& DT_WORDBREAK
);
597 assert (chars_fit
< *len_str
);
599 /* Work back from the last character that did fit to either a space or the
600 * last character of a word, whichever is met first.
602 p
= str
+ chars_fit
; /* The character that doesn't fit */
605 ; /* we pretend that it fits anyway */
606 else if (*p
== SPACE
) /* chars_fit < *len_str so this is valid */
607 p
--; /* the word just fitted */
610 while (p
> str
&& *(--p
) != SPACE
&& (!IsCJKT(p
[1]) ||
611 p
[1] == L
'\0' || wcschr(KinsokuClassA
, p
[1]) != NULL
))
613 word_fits
= (p
!= str
|| *p
== SPACE
|| IsCJKT(p
[1]));
615 /* If there was one or the first character didn't fit then */
619 /* break the line before/after that character */
620 if (!(format
& (DT_RIGHT
| DT_CENTER
)) || *p
!= SPACE
)
622 next_is_space
= (unsigned int) (p
- str
) < *len_str
&& *p
== SPACE
;
624 /* and if the next character is a space then discard it. */
625 *chars_used
= *len_str
;
629 /* Suppose there was none. */
632 if ((format
& (DT_EDITCONTROL
| DT_WORD_ELLIPSIS
| DT_PATH_ELLIPSIS
)) ==
635 /* break the word after the last character that fits (there must be
636 * at least one; none is caught earlier).
638 *len_str
= chars_fit
;
639 *chars_used
= chars_fit
;
641 /* FIXME - possible error. Since the next character is now removed
642 * this could make the text longer so that it no longer fits, and
643 * so we need a loop to test and shrink.
649 /* discard any trailing space. */
650 const WCHAR
*e
= str
+ *len_str
;
652 while (p
< e
&& *p
!= SPACE
)
654 *chars_used
= p
- str
;
655 if (p
< e
) /* i.e. loop failed because *p == SPACE */
658 /* include the whole word; it may be ellipsified later */
660 /* Possible optimisation; if DT_WORD_ELLIPSIS only use chars_fit+1
661 * so that it will be too long
665 /* Remeasure the string */
666 GetTextExtentExPointW (hdc
, str
, *len_str
, 0, NULL
, NULL
, size
);
669 /*********************************************************************
672 * Skip over the given number of characters, bearing in mind prefix
673 * substitution and the fact that a character may take more than one
674 * WCHAR (Unicode surrogates are two words long) (and there may have been
678 * new_count [out] The updated count
679 * new_str [out] The updated pointer
680 * start_count [in] The count of remaining characters corresponding to the
681 * start of the string
682 * start_str [in] The starting point of the string
683 * max [in] The number of characters actually in this segment of the
684 * string (the & counts)
685 * n [in] The number of characters to skip (if prefix then
687 * prefix [in] Apply prefix substitution
693 * There must be at least n characters in the string
694 * We need max because the "line" may have ended with a & followed by a tab
695 * or newline etc. which we don't want to swallow
698 static void TEXT_SkipChars (int *new_count
, const WCHAR
**new_str
,
699 int start_count
, const WCHAR
*start_str
,
700 int max
, int n
, int prefix
)
702 /* This is specific to wide characters, MSDN doesn't say anything much
703 * about Unicode surrogates yet and it isn't clear if _wcsinc will
704 * correctly handle them so we'll just do this the easy way for now
709 const WCHAR
*str_on_entry
= start_str
;
714 if (*start_str
++ == PREFIX
&& max
--)
717 start_count
-= (start_str
- str_on_entry
);
724 *new_str
= start_str
;
725 *new_count
= start_count
;
728 /*********************************************************************
731 * Reanalyse the text to find the prefixed character. This is called when
732 * wordbreaking or ellipsification has shortened the string such that the
733 * previously noted prefixed character is no longer visible.
736 * str [in] The original string segment (including all characters)
737 * ns [in] The number of characters in str (including prefixes)
738 * pe [in] The ellipsification data
741 * The prefix offset within the new string segment (the one that contains the
742 * ellipses and does not contain the prefix characters) (-1 if none)
745 static int TEXT_Reprefix (const WCHAR
*str
, unsigned int ns
,
746 const ellipsis_data
*pe
)
750 unsigned int n
= pe
->before
+ pe
->under
+ pe
->after
;
754 if (i
== (unsigned int) pe
->before
)
756 /* Reached the path ellipsis; jump over it */
757 if (ns
< (unsigned int) pe
->under
) break;
761 if (!pe
->after
) break; /* Nothing after the path ellipsis */
765 if (*str
++ == PREFIX
)
769 result
= (i
< (unsigned int) pe
->before
|| pe
->under
== 0) ? i
: i
- pe
->under
+ pe
->len
;
770 /* pe->len may be non-zero while pe_under is zero */
779 /*********************************************************************
780 * Returns true if and only if the remainder of the line is a single
781 * newline representation or nothing
784 static int remainder_is_none_or_newline (int num_chars
, const WCHAR
*str
)
786 if (!num_chars
) return TRUE
;
787 if (*str
!= LF
&& *str
!= CR
) return FALSE
;
788 if (!--num_chars
) return TRUE
;
789 if (*str
== *(str
+1)) return FALSE
;
791 if (*str
!= CR
&& *str
!= LF
) return FALSE
;
792 if (--num_chars
) return FALSE
;
796 /*********************************************************************
797 * Return next line of text from a string.
799 * hdc - handle to DC.
800 * str - string to parse into lines.
801 * count - length of str.
802 * dest - destination in which to return line.
803 * len - dest buffer size in chars on input, copied length into dest on output.
804 * width - maximum width of line in pixels.
805 * format - format type passed to DrawText.
806 * retsize - returned size of the line in pixels.
807 * last_line - TRUE if is the last line that will be processed
808 * p_retstr - If DT_MODIFYSTRING this points to a cursor in the buffer in which
809 * the return string is built.
810 * tabwidth - The width of a tab in logical coordinates
811 * pprefix_offset - Here is where we return the offset within dest of the first
812 * prefixed (underlined) character. -1 is returned if there
813 * are none. Note that there may be more; the calling code
814 * will need to use TEXT_Reprefix to find any later ones.
815 * pellip - Here is where we return the information about any ellipsification
816 * that was carried out. Note that if tabs are being expanded then
817 * this data will correspond to the last text segment actually
818 * returned in dest; by definition there would not have been any
819 * ellipsification in earlier text segments of the line.
821 * Returns pointer to next char in str after end of the line
822 * or NULL if end of str reached.
824 static const WCHAR
*TEXT_NextLineW( HDC hdc
, const WCHAR
*str
, int *count
,
825 WCHAR
*dest
, int *len
, int width
, DWORD format
,
826 SIZE
*retsize
, int last_line
, WCHAR
**p_retstr
,
827 int tabwidth
, int *pprefix_offset
,
828 ellipsis_data
*pellip
)
834 int seg_i
, seg_count
, seg_j
;
839 unsigned int j_in_seg
;
841 *pprefix_offset
= -1;
843 /* For each text segment in the line */
849 /* Skip any leading tabs */
851 if (str
[i
] == TAB
&& (format
& DT_EXPANDTABS
))
853 plen
= ((plen
/tabwidth
)+1)*tabwidth
;
854 (*count
)--; if (j
< maxl
) dest
[j
++] = str
[i
++]; else i
++;
855 while (*count
&& str
[i
] == TAB
)
858 (*count
)--; if (j
< maxl
) dest
[j
++] = str
[i
++]; else i
++;
863 /* Now copy as far as the next tab or cr/lf or eos */
870 (str
[i
] != TAB
|| !(format
& DT_EXPANDTABS
)) &&
871 ((str
[i
] != CR
&& str
[i
] != LF
) || (format
& DT_SINGLELINE
)))
873 if (str
[i
] == PREFIX
&& !(format
& DT_NOPREFIX
) && *count
> 1)
875 (*count
)--, i
++; /* Throw away the prefix itself */
876 if (str
[i
] == PREFIX
)
878 /* Swallow it before we see it again */
879 (*count
)--; if (j
< maxl
) dest
[j
++] = str
[i
++]; else i
++;
881 else if (*pprefix_offset
== -1 || *pprefix_offset
>= seg_j
)
885 /* else the previous prefix was in an earlier segment of the
886 * line; we will leave it to the drawing code to catch this
892 (*count
)--; if (j
< maxl
) dest
[j
++] = str
[i
++]; else i
++;
897 /* Measure the whole text segment and possibly WordBreak and
901 j_in_seg
= j
- seg_j
;
902 max_seg_width
= width
- plen
;
903 GetTextExtentExPointW (hdc
, dest
+ seg_j
, j_in_seg
, max_seg_width
, &num_fit
, NULL
, &size
);
905 /* The Microsoft handling of various combinations of formats is weird.
906 * The following may very easily be incorrect if several formats are
907 * combined, and may differ between versions (to say nothing of the
908 * several bugs in the Microsoft versions).
911 line_fits
= (num_fit
>= j_in_seg
);
912 if (!line_fits
&& (format
& DT_WORDBREAK
))
915 unsigned int chars_used
;
916 TEXT_WordBreak (hdc
, dest
+seg_j
, maxl
-seg_j
, &j_in_seg
,
917 max_seg_width
, format
, num_fit
, &chars_used
, &size
);
918 line_fits
= (size
.cx
<= max_seg_width
);
919 /* and correct the counts */
920 TEXT_SkipChars (count
, &s
, seg_count
, str
+seg_i
, i
-seg_i
,
921 chars_used
, !(format
& DT_NOPREFIX
));
925 pellip
->before
= j_in_seg
;
930 if (!line_fits
&& (format
& DT_PATH_ELLIPSIS
))
932 TEXT_PathEllipsify (hdc
, dest
+ seg_j
, maxl
-seg_j
, &j_in_seg
,
933 max_seg_width
, &size
, *p_retstr
, pellip
);
934 line_fits
= (size
.cx
<= max_seg_width
);
937 /* NB we may end up ellipsifying a word-broken or path_ellipsified
939 if ((!line_fits
&& (format
& DT_WORD_ELLIPSIS
)) ||
940 ((format
& DT_END_ELLIPSIS
) &&
941 ((last_line
&& *count
) ||
942 (remainder_is_none_or_newline (*count
, &str
[i
]) && !line_fits
))))
944 int before
, len_ellipsis
;
945 TEXT_Ellipsify (hdc
, dest
+ seg_j
, maxl
-seg_j
, &j_in_seg
,
946 max_seg_width
, &size
, *p_retstr
, &before
, &len_ellipsis
);
947 if (before
> pellip
->before
)
949 /* We must have done a path ellipsis too */
950 pellip
->after
= before
- pellip
->before
- pellip
->len
;
951 /* Leave the len as the length of the first ellipsis */
955 /* If we are here after a path ellipsification it must be
956 * because even the ellipsis itself didn't fit.
958 assert (pellip
->under
== 0 && pellip
->after
== 0);
959 pellip
->before
= before
;
960 pellip
->len
= len_ellipsis
;
961 /* pellip->after remains as zero as does
965 line_fits
= (size
.cx
<= max_seg_width
);
968 /* As an optimisation if we have ellipsified and we are expanding
969 * tabs and we haven't reached the end of the line we can skip to it
970 * now rather than going around the loop again.
972 if ((format
& DT_EXPANDTABS
) && ellipsified
)
974 if (format
& DT_SINGLELINE
)
978 while ((*count
) && str
[i
] != CR
&& str
[i
] != LF
)
985 j
= seg_j
+ j_in_seg
;
986 if (*pprefix_offset
>= seg_j
+ pellip
->before
)
988 *pprefix_offset
= TEXT_Reprefix (str
+ seg_i
, i
- seg_i
, pellip
);
989 if (*pprefix_offset
!= -1)
990 *pprefix_offset
+= seg_j
;
994 if (size
.cy
> retsize
->cy
)
995 retsize
->cy
= size
.cy
;
1001 else if (str
[i
] == CR
|| str
[i
] == LF
)
1004 if (*count
&& (str
[i
] == CR
|| str
[i
] == LF
) && str
[i
] != str
[i
-1])
1010 /* else it was a Tab and we go around again */
1022 /***********************************************************************
1023 * TEXT_DrawUnderscore
1025 * Draw the underline under the prefixed character
1028 * hdc [in] The handle of the DC for drawing
1029 * x [in] The x location of the line segment (logical coordinates)
1030 * y [in] The y location of where the underscore should appear
1031 * (logical coordinates)
1032 * str [in] The text of the line segment
1033 * offset [in] The offset of the underscored character within str
1034 * rect [in] Clipping rectangle (if not NULL)
1036 /* Synced with wine 1.1.32 */
1037 static void TEXT_DrawUnderscore (HDC hdc
, int x
, int y
, const WCHAR
*str
, int offset
, const RECT
*rect
)
1045 GetTextExtentPointW (hdc
, str
, offset
, &size
);
1046 prefix_x
= x
+ size
.cx
;
1047 GetTextExtentPointW (hdc
, str
, offset
+1, &size
);
1048 prefix_end
= x
+ size
.cx
- 1;
1049 /* The above method may eventually be slightly wrong due to kerning etc. */
1051 /* Check for clipping */
1054 if (prefix_x
> rect
->right
|| prefix_end
< rect
->left
||
1055 y
< rect
->top
|| y
> rect
->bottom
)
1056 return; /* Completely outside */
1057 /* Partially outside */
1058 if (prefix_x
< rect
->left
) prefix_x
= rect
->left
;
1059 if (prefix_end
> rect
->right
) prefix_end
= rect
->right
;
1062 hpen
= CreatePen (PS_SOLID
, 1, GetTextColor (hdc
));
1063 oldPen
= SelectObject (hdc
, hpen
);
1064 MoveToEx (hdc
, prefix_x
, y
, NULL
);
1065 LineTo (hdc
, prefix_end
, y
);
1066 SelectObject (hdc
, oldPen
);
1067 DeleteObject (hpen
);
1070 /***********************************************************************
1071 * DrawTextExW (USER32.@)
1073 * The documentation on the extra space required for DT_MODIFYSTRING at MSDN
1074 * is not quite complete, especially with regard to \0. We will assume that
1075 * the returned string could have a length of up to i_count+3 and also have
1076 * a trailing \0 (which would be 4 more than a not-null-terminated string but
1077 * 3 more than a null-terminated string). If this is not so then increase
1078 * the allowance in DrawTextExA.
1080 #define MAX_BUFFER 1024
1084 * Synced with wine 1.1.32
1086 INT WINAPI
DrawTextExW( HDC hdc
, LPWSTR str
, INT i_count
,
1087 LPRECT rect
, UINT flags
, LPDRAWTEXTPARAMS dtp
)
1090 const WCHAR
*strPtr
;
1091 WCHAR
*retstr
, *p_retstr
;
1093 WCHAR line
[MAX_BUFFER
];
1094 int len
, lh
, count
=i_count
;
1096 int lmargin
= 0, rmargin
= 0;
1097 int x
= rect
->left
, y
= rect
->top
;
1098 int width
= rect
->right
- rect
->left
;
1101 int tabwidth
/* to keep gcc happy */ = 0;
1103 ellipsis_data ellip
;
1106 TRACE("%s, %d, [%s] %08x\n", debugstr_wn (str
, count
), count
,
1107 wine_dbgstr_rect(rect
), flags
);
1109 if (dtp
) TRACE("Params: iTabLength=%d, iLeftMargin=%d, iRightMargin=%d\n",
1110 dtp
->iTabLength
, dtp
->iLeftMargin
, dtp
->iRightMargin
);
1116 if (flags
& DT_SINGLELINE
)
1117 flags
&= ~DT_WORDBREAK
;
1119 GetTextMetricsW(hdc
, &tm
);
1120 if (flags
& DT_EXTERNALLEADING
)
1121 lh
= tm
.tmHeight
+ tm
.tmExternalLeading
;
1125 if (str
[0] && count
== 0)
1128 if (dtp
&& dtp
->cbSize
!= sizeof(DRAWTEXTPARAMS
))
1133 count
= strlenW(str
);
1136 if( flags
& DT_CALCRECT
)
1138 rect
->right
= rect
->left
;
1139 if( flags
& DT_SINGLELINE
)
1140 rect
->bottom
= rect
->top
+ lh
;
1142 rect
->bottom
= rect
->top
;
1148 if (GetGraphicsMode(hdc
) == GM_COMPATIBLE
)
1150 SIZE window_ext
, viewport_ext
;
1151 GetWindowExtEx(hdc
, &window_ext
);
1152 GetViewportExtEx(hdc
, &viewport_ext
);
1153 if ((window_ext
.cy
> 0) != (viewport_ext
.cy
> 0))
1159 lmargin
= dtp
->iLeftMargin
;
1160 rmargin
= dtp
->iRightMargin
;
1161 if (!(flags
& (DT_CENTER
| DT_RIGHT
)))
1163 dtp
->uiLengthDrawn
= 0; /* This param RECEIVES number of chars processed */
1166 if (flags
& DT_EXPANDTABS
)
1168 int tabstop
= ((flags
& DT_TABSTOP
) && dtp
) ? dtp
->iTabLength
: 8;
1169 tabwidth
= tm
.tmAveCharWidth
* tabstop
;
1172 if (flags
& DT_CALCRECT
) flags
|= DT_NOCLIP
;
1174 if (flags
& DT_MODIFYSTRING
)
1176 size_retstr
= (count
+ 4) * sizeof (WCHAR
);
1177 retstr
= HeapAlloc(GetProcessHeap(), 0, size_retstr
);
1178 if (!retstr
) return 0;
1179 memcpy (retstr
, str
, size_retstr
);
1190 len
= sizeof(line
)/sizeof(line
[0]);
1192 last_line
= !(flags
& DT_NOCLIP
) && y
- ((flags
& DT_EDITCONTROL
) ? 2*lh
-1 : lh
) < rect
->bottom
;
1194 last_line
= !(flags
& DT_NOCLIP
) && y
+ ((flags
& DT_EDITCONTROL
) ? 2*lh
-1 : lh
) > rect
->bottom
;
1195 strPtr
= TEXT_NextLineW(hdc
, strPtr
, &count
, line
, &len
, width
, flags
, &size
, last_line
, &p_retstr
, tabwidth
, &prefix_offset
, &ellip
);
1197 if (flags
& DT_CENTER
) x
= (rect
->left
+ rect
->right
-
1199 else if (flags
& DT_RIGHT
) x
= rect
->right
- size
.cx
;
1201 if (flags
& DT_SINGLELINE
)
1203 if (flags
& DT_VCENTER
) y
= rect
->top
+
1204 (rect
->bottom
- rect
->top
) / 2 - size
.cy
/ 2;
1205 else if (flags
& DT_BOTTOM
) y
= rect
->bottom
- size
.cy
;
1208 if (!(flags
& DT_CALCRECT
))
1210 const WCHAR
*str
= line
;
1216 if ((flags
& DT_EXPANDTABS
))
1219 p
= str
; while (p
< str
+len
&& *p
!= TAB
) p
++;
1221 if (len_seg
!= len
&& !GetTextExtentPointW(hdc
, str
, len_seg
, &size
))
1227 if (!ExtTextOutW( hdc
, xseg
, y
,
1228 ((flags
& DT_NOCLIP
) ? 0 : ETO_CLIPPED
) |
1229 ((flags
& DT_RTLREADING
) ? ETO_RTLREADING
: 0),
1230 rect
, str
, len_seg
, NULL
)) return 0;
1231 if (prefix_offset
!= -1 && prefix_offset
< len_seg
)
1233 TEXT_DrawUnderscore (hdc
, xseg
, y
+ tm
.tmAscent
+ 1, str
, prefix_offset
, (flags
& DT_NOCLIP
) ? NULL
: rect
);
1239 assert ((flags
& DT_EXPANDTABS
) && *str
== TAB
);
1241 xseg
+= ((size
.cx
/tabwidth
)+1)*tabwidth
;
1242 if (prefix_offset
!= -1)
1244 if (prefix_offset
< len_seg
)
1246 /* We have just drawn an underscore; we ought to
1247 * figure out where the next one is. I am going
1248 * to leave it for now until I have a better model
1249 * for the line, which will make reprefixing easier.
1250 * This is where ellip would be used.
1255 prefix_offset
-= len_seg
;
1260 else if (size
.cx
> max_width
)
1261 max_width
= size
.cx
;
1268 dtp
->uiLengthDrawn
+= len
;
1270 while (strPtr
&& !last_line
);
1272 if (flags
& DT_CALCRECT
)
1274 rect
->right
= rect
->left
+ max_width
;
1277 rect
->right
+= lmargin
+ rmargin
;
1281 memcpy (str
, retstr
, size_retstr
);
1282 HeapFree (GetProcessHeap(), 0, retstr
);
1284 return y
- rect
->top
;
1289 GdiGetCodePage(HDC hdc
);
1291 /***********************************************************************
1292 * DrawTextExA (USER32.@)
1294 * If DT_MODIFYSTRING is specified then there must be room for up to
1295 * 4 extra characters. We take great care about just how much modified
1300 * Synced with wine 1.1.32
1302 INT WINAPI
DrawTextExA( HDC hdc
, LPSTR str
, INT count
,
1303 LPRECT rect
, UINT flags
, LPDRAWTEXTPARAMS dtp
)
1314 if (!count
) return 0;
1315 if (!str
&& count
> 0) return 0;
1316 if( !str
|| ((count
== -1) && !(count
= strlen(str
))))
1321 if (dtp
&& dtp
->cbSize
!= sizeof(DRAWTEXTPARAMS
))
1324 GetTextMetricsA(hdc
, &tm
);
1325 if (flags
& DT_EXTERNALLEADING
)
1326 lh
= tm
.tmHeight
+ tm
.tmExternalLeading
;
1330 if( flags
& DT_CALCRECT
)
1332 rect
->right
= rect
->left
;
1333 if( flags
& DT_SINGLELINE
)
1334 rect
->bottom
= rect
->top
+ lh
;
1336 rect
->bottom
= rect
->top
;
1340 cp
= GdiGetCodePage( hdc
);
1341 wcount
= MultiByteToWideChar( cp
, 0, str
, count
, NULL
, 0 );
1344 if (flags
& DT_MODIFYSTRING
)
1349 wstr
= HeapAlloc(GetProcessHeap(), 0, wmax
* sizeof(WCHAR
));
1352 MultiByteToWideChar( cp
, 0, str
, count
, wstr
, wcount
);
1353 if (flags
& DT_MODIFYSTRING
)
1354 for (i
=4, p
=wstr
+wcount
; i
--; p
++) *p
=0xFFFE;
1355 /* Initialise the extra characters so that we can see which ones
1356 * change. U+FFFE is guaranteed to be not a unicode character and
1357 * so will not be generated by DrawTextEx itself.
1359 ret
= DrawTextExW( hdc
, wstr
, wcount
, rect
, flags
, dtp
);
1360 if (flags
& DT_MODIFYSTRING
)
1362 /* Unfortunately the returned string may contain multiple \0s
1363 * and so we need to measure it ourselves.
1365 for (i
=4, p
=wstr
+wcount
; i
-- && *p
!= 0xFFFE; p
++) wcount
++;
1366 WideCharToMultiByte( cp
, 0, wstr
, wcount
, str
, amax
, NULL
, NULL
);
1368 HeapFree(GetProcessHeap(), 0, wstr
);
1373 /***********************************************************************
1374 * DrawTextW (USER32.@)
1378 INT WINAPI
DrawTextW( HDC hdc
, LPCWSTR str
, INT count
, LPRECT rect
, UINT flags
)
1382 memset (&dtp
, 0, sizeof(dtp
));
1383 dtp
.cbSize
= sizeof(dtp
);
1384 if (flags
& DT_TABSTOP
)
1386 dtp
.iTabLength
= (flags
>> 8) & 0xff;
1387 flags
&= 0xffff00ff;
1389 return DrawTextExW(hdc
, (LPWSTR
)str
, count
, rect
, flags
, &dtp
);
1392 /***********************************************************************
1393 * DrawTextA (USER32.@)
1397 INT WINAPI
DrawTextA( HDC hdc
, LPCSTR str
, INT count
, LPRECT rect
, UINT flags
)
1401 memset (&dtp
, 0, sizeof(dtp
));
1402 dtp
.cbSize
= sizeof(dtp
);
1403 if (flags
& DT_TABSTOP
)
1405 dtp
.iTabLength
= (flags
>> 8) & 0xff;
1406 flags
&= 0xffff00ff;
1408 return DrawTextExA( hdc
, (LPSTR
)str
, count
, rect
, flags
, &dtp
);