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.
21 * PROJECT: ReactOS user32.dll
22 * FILE: lib/user32/windows/input.c
24 * PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
26 * 09-05-2001 CSH Created
29 /* INCLUDES ******************************************************************/
33 #include <wine/debug.h>
35 /* FUNCTIONS *****************************************************************/
43 #define assert(e) ((e) ? (void)0 : _font_assert(#e, __FILE__, __LINE__))
47 void _font_assert(const char *msg
, const char *file
, int line
)
49 /* Assertion failed at foo.c line 45: x<y */
50 DbgPrint("Assertion failed at %s line %d: %s\n", file
, line
, msg
);
52 for(;;); /* eliminate warning by mingw */
67 CONST LPINT lpnTabStopPositions
,
74 len
= MultiByteToWideChar(CP_ACP
, 0, lpString
, nCount
, NULL
, 0);
75 strW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
80 MultiByteToWideChar(CP_ACP
, 0, lpString
, nCount
, strW
, len
);
81 ret
= TabbedTextOutW(hDC
, X
, Y
, strW
, len
, nTabPositions
, lpnTabStopPositions
, nTabOrigin
);
82 HeapFree(GetProcessHeap(), 0, strW
);
87 /***********************************************************************
90 * Helper function for TabbedTextOut() and GetTabbedTextExtent().
91 * Note: this doesn't work too well for text-alignment modes other
92 * than TA_LEFT|TA_TOP. But we want bug-for-bug compatibility :-)
94 /* WINE synced 22-May-2006 */
95 static LONG
TEXT_TabbedTextOut( HDC hdc
, INT x
, INT y
, LPCWSTR lpstr
,
96 INT count
, INT cTabStops
, const INT
*lpTabPos
, INT nTabOrg
,
109 defWidth
= *lpTabPos
;
115 GetTextMetricsA( hdc
, &tm
);
116 defWidth
= 8 * tm
.tmAveCharWidth
;
125 /* chop the string into substrings of 0 or more <tabs>
126 * possibly followed by 1 or more normal characters */
127 for (i
= 0; i
< count
; i
++)
128 if (lpstr
[i
] != '\t') break;
129 for (j
= i
; j
< count
; j
++)
130 if (lpstr
[j
] == '\t') break;
131 /* get the extent of the normal character part */
132 GetTextExtentPointW( hdc
, lpstr
+ i
, j
- i
, &extent
);
133 /* and if there is a <tab>, calculate its position */
135 /* get x coordinate for the drawing of this string */
136 for (; cTabStops
> i
; lpTabPos
++, cTabStops
--)
138 if( nTabOrg
+ abs( *lpTabPos
) > x
) {
139 if( lpTabPos
[ i
- 1] >= 0) {
140 /* a left aligned tab */
141 x
= nTabOrg
+ lpTabPos
[ i
-1] + extent
.cx
;
146 /* if tab pos is negative then text is right-aligned
147 * to tab stop meaning that the string extends to the
148 * left, so we must subtract the width of the string */
149 if (nTabOrg
- lpTabPos
[ i
- 1] - extent
.cx
> x
)
151 x
= nTabOrg
- lpTabPos
[ i
- 1];
158 /* if we have run out of tab stops and we have a valid default tab
159 * stop width then round x up to that width */
160 if ((cTabStops
<= i
) && (defWidth
> 0)) {
161 x0
= nTabOrg
+ ((x
- nTabOrg
) / defWidth
+ i
) * defWidth
;
163 } else if ((cTabStops
<= i
) && (defWidth
< 0)) {
164 x
= nTabOrg
+ ((x
- nTabOrg
+ extent
.cx
) / -defWidth
+ i
)
175 r
.bottom
= y
+ extent
.cy
;
176 ExtTextOutW( hdc
, x0
, y
, GetBkMode(hdc
) == OPAQUE
? ETO_OPAQUE
: 0,
177 &r
, lpstr
+ i
, j
- i
, NULL
);
182 return MAKELONG(x
- start
, extent
.cy
);
197 CONST LPINT lpnTabStopPositions
,
200 return TEXT_TabbedTextOut(hDC
, X
, Y
, lpString
, nCount
, nTabPositions
, lpnTabStopPositions
, nTabOrigin
, TRUE
);
203 /* WINE synced 22-May-2006 */
209 GetTabbedTextExtentA(
214 CONST LPINT lpnTabStopPositions
)
217 DWORD len
= MultiByteToWideChar(CP_ACP
, 0, lpString
, nCount
, NULL
, 0);
218 LPWSTR strW
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
222 MultiByteToWideChar(CP_ACP
, 0, lpString
, nCount
, strW
, len
);
224 ret
= GetTabbedTextExtentW(hDC
, strW
, len
, nTabPositions
,
225 lpnTabStopPositions
);
227 HeapFree(GetProcessHeap(), 0, strW
);
237 GetTabbedTextExtentW(
242 CONST LPINT lpnTabStopPositions
)
244 return TEXT_TabbedTextOut(hDC
, 0, 0, lpString
, nCount
, nTabPositions
, lpnTabStopPositions
, 0, FALSE
);
247 /*********************************************************************
252 * Copyright 1993, 1994 Alexandre Julliard
253 * Copyright 2002 Bill Medland
256 * How many buffers to use
257 * While processing in DrawText there are potentially three different forms
258 * of the text that need to be held. How are they best held?
259 * 1. The original text is needed, of course, to see what to display.
260 * 2. The text that will be returned to the user if the DT_MODIFYSTRING is
262 * 3. The buffered text that is about to be displayed e.g. the current line.
263 * Typically this will exclude the ampersands used for prefixing etc.
266 * a. If the buffered text to be displayed includes the ampersands then
267 * we will need special measurement and draw functions that will ignore
268 * the ampersands (e.g. by copying to a buffer without the prefix and
269 * then using the normal forms). This may involve less space but may
270 * require more processing. e.g. since a line containing tabs may
271 * contain several underlined characters either we need to carry around
272 * a list of prefix locations or we may need to locate them several
274 * b. If we actually directly modify the "original text" as we go then we
275 * will need some special "caching" to handle the fact that when we
276 * ellipsify the text the ellipsis may modify the next line of text,
277 * which we have not yet processed. (e.g. ellipsification of a W at the
278 * end of a line will overwrite the W, the \n and the first character of
279 * the next line, and a \0 will overwrite the second. Try it!!)
281 * Option 1. Three separate storages. (To be implemented)
282 * If DT_MODIFYSTRING is in effect then allocate an extra buffer to hold
283 * the edited string in some form, either as the string itself or as some
284 * sort of "edit list" to be applied just before returning.
285 * Use a buffer that holds the ellipsified current line sans ampersands
286 * and accept the need occasionally to recalculate the prefixes (if
287 * DT_EXPANDTABS and not DT_NOPREFIX and not DT_HIDEPREFIX)
296 #define FORWARD_SLASH '/'
297 #define BACK_SLASH '\\'
299 static const WCHAR ELLIPSISW
[] = {'.','.','.', 0};
301 typedef struct tag_ellipsis_data
309 /*********************************************************************
310 * TEXT_Ellipsify (static)
312 * Add an ellipsis to the end of the given string whilst ensuring it fits.
314 * If the ellipsis alone doesn't fit then it will be returned anyway.
316 * See Also TEXT_PathEllipsify
319 * hdc [in] The handle to the DC that defines the font.
320 * str [in/out] The string that needs to be modified.
321 * max_str [in] The dimension of str (number of WCHAR).
322 * len_str [in/out] The number of characters in str
323 * width [in] The maximum width permitted (in logical coordinates)
324 * size [out] The dimensions of the text
325 * modstr [out] The modified form of the string, to be returned to the
326 * calling program. It is assumed that the caller has
327 * made sufficient space available so we don't need to
328 * know the size of the space. This pointer may be NULL if
329 * the modified string is not required.
330 * len_before [out] The number of characters before the ellipsis.
331 * len_ellip [out] The number of characters in the ellipsis.
333 * See for example Microsoft article Q249678.
335 * For now we will simply use three dots rather than worrying about whether
336 * the font contains an explicit ellipsis character.
338 static void TEXT_Ellipsify (HDC hdc
, WCHAR
*str
, unsigned int max_len
,
339 unsigned int *len_str
, int width
, SIZE
*size
,
341 int *len_before
, int *len_ellip
)
343 unsigned int len_ellipsis
;
344 unsigned int lo
, mid
, hi
;
346 len_ellipsis
= wcslen (ELLIPSISW
);
347 if (len_ellipsis
> max_len
) len_ellipsis
= max_len
;
348 if (*len_str
> max_len
- len_ellipsis
)
349 *len_str
= max_len
- len_ellipsis
;
351 /* First do a quick binary search to get an upper bound for *len_str. */
353 GetTextExtentExPointW(hdc
, str
, *len_str
, width
, NULL
, NULL
, size
) &&
356 for (lo
= 0, hi
= *len_str
; lo
< hi
; )
359 if (!GetTextExtentExPointW(hdc
, str
, mid
, width
, NULL
, NULL
, size
))
361 if (size
->cx
> width
)
368 /* Now this should take only a couple iterations at most. */
371 wcsncpy (str
+ *len_str
, ELLIPSISW
, len_ellipsis
);
373 if (!GetTextExtentExPointW (hdc
, str
, *len_str
+ len_ellipsis
, width
,
374 NULL
, NULL
, size
)) break;
376 if (!*len_str
|| size
->cx
<= width
) break;
380 *len_ellip
= len_ellipsis
;
381 *len_before
= *len_str
;
382 *len_str
+= len_ellipsis
;
386 wcsncpy (modstr
, str
, *len_str
);
387 *(str
+*len_str
) = '\0';
391 /*********************************************************************
392 * TEXT_PathEllipsify (static)
394 * Add an ellipsis to the provided string in order to make it fit within
395 * the width. The ellipsis is added as specified for the DT_PATH_ELLIPSIS
398 * See Also TEXT_Ellipsify
401 * hdc [in] The handle to the DC that defines the font.
402 * str [in/out] The string that needs to be modified
403 * max_str [in] The dimension of str (number of WCHAR).
404 * len_str [in/out] The number of characters in str
405 * width [in] The maximum width permitted (in logical coordinates)
406 * size [out] The dimensions of the text
407 * modstr [out] The modified form of the string, to be returned to the
408 * calling program. It is assumed that the caller has
409 * made sufficient space available so we don't need to
410 * know the size of the space. This pointer may be NULL if
411 * the modified string is not required.
412 * pellip [out] The ellipsification results
414 * For now we will simply use three dots rather than worrying about whether
415 * the font contains an explicit ellipsis character.
417 * The following applies, I think to Win95. We will need to extend it for
418 * Win98 which can have both path and end ellipsis at the same time (e.g.
419 * C:\MyLongFileName.Txt becomes ...\MyLongFileN...)
421 * The resulting string consists of as much as possible of the following:
422 * 1. The ellipsis itself
423 * 2. The last \ or / of the string (if any)
424 * 3. Everything after the last \ or / of the string (if any) or the whole
425 * string if there is no / or \. I believe that under Win95 this would
426 * include everything even though some might be clipped off the end whereas
427 * under Win98 that might be ellipsified too.
428 * Yet to be investigated is whether this would include wordbreaking if the
429 * filename is more than 1 word and splitting if DT_EDITCONTROL was in
430 * effect. (If DT_EDITCONTROL is in effect then on occasions text will be
431 * broken within words).
432 * 4. All the stuff before the / or \, which is placed before the ellipsis.
434 static void TEXT_PathEllipsify (HDC hdc
, WCHAR
*str
, unsigned int max_len
,
435 unsigned int *len_str
, int width
, SIZE
*size
,
436 WCHAR
*modstr
, ellipsis_data
*pellip
)
438 unsigned int len_ellipsis
;
441 WCHAR
*lastBkSlash
, *lastFwdSlash
, *lastSlash
;
443 len_ellipsis
= wcslen (ELLIPSISW
);
444 if (!max_len
) return;
445 if (len_ellipsis
>= max_len
) len_ellipsis
= max_len
- 1;
446 if (*len_str
+ len_ellipsis
>= max_len
)
447 *len_str
= max_len
- len_ellipsis
-1;
448 /* Hopefully this will never happen, otherwise it would probably lose
449 * the wrong character
451 str
[*len_str
] = '\0'; /* to simplify things */
453 lastBkSlash
= wcsrchr (str
, BACK_SLASH
);
454 lastFwdSlash
= wcsrchr (str
, FORWARD_SLASH
);
455 lastSlash
= lastBkSlash
> lastFwdSlash
? lastBkSlash
: lastFwdSlash
;
456 if (!lastSlash
) lastSlash
= str
;
457 len_trailing
= *len_str
- (lastSlash
- str
);
459 /* overlap-safe movement to the right */
460 memmove (lastSlash
+len_ellipsis
, lastSlash
, len_trailing
* sizeof(WCHAR
));
461 wcsncpy (lastSlash
, ELLIPSISW
, len_ellipsis
);
462 len_trailing
+= len_ellipsis
;
463 /* From this point on lastSlash actually points to the ellipsis in front
464 * of the last slash and len_trailing includes the ellipsis
470 if (!GetTextExtentExPointW (hdc
, str
, *len_str
+ len_ellipsis
, width
,
471 NULL
, NULL
, size
)) break;
473 if (lastSlash
== str
|| size
->cx
<= width
) break;
475 /* overlap-safe movement to the left */
476 memmove (lastSlash
-1, lastSlash
, len_trailing
* sizeof(WCHAR
));
483 pellip
->before
= lastSlash
-str
;
484 pellip
->len
= len_ellipsis
;
485 pellip
->under
= len_under
;
486 pellip
->after
= len_trailing
- len_ellipsis
;
487 *len_str
+= len_ellipsis
;
491 wcsncpy (modstr
, str
, *len_str
);
492 *(str
+*len_str
) = '\0';
496 /*********************************************************************
497 * TEXT_WordBreak (static)
499 * Perform wordbreak processing on the given string
501 * Assumes that DT_WORDBREAK has been specified and not all the characters
502 * fit. Note that this function should even be called when the first character
503 * that doesn't fit is known to be a space or tab, so that it can swallow them.
505 * Note that the Windows processing has some strange properties.
506 * 1. If the text is left-justified and there is room for some of the spaces
507 * that follow the last word on the line then those that fit are included on
509 * 2. If the text is centred or right-justified and there is room for some of
510 * the spaces that follow the last word on the line then all but one of those
511 * that fit are included on the line.
512 * 3. (Reasonable behaviour) If the word breaking causes a space to be the first
513 * character of a new line it will be skipped.
516 * hdc [in] The handle to the DC that defines the font.
517 * str [in/out] The string that needs to be broken.
518 * max_str [in] The dimension of str (number of WCHAR).
519 * len_str [in/out] The number of characters in str
520 * width [in] The maximum width permitted
521 * format [in] The format flags in effect
522 * chars_fit [in] The maximum number of characters of str that are already
523 * known to fit; chars_fit+1 is known not to fit.
524 * chars_used [out] The number of characters of str that have been "used" and
525 * do not need to be included in later text. For example this will
526 * include any spaces that have been discarded from the start of
528 * size [out] The size of the returned text in logical coordinates
530 * Pedantic assumption - Assumes that the text length is monotonically
531 * increasing with number of characters (i.e. no weird kernings)
535 * Work back from the last character that did fit to either a space or the last
536 * character of a word, whichever is met first.
537 * If there was one or the first character didn't fit then
538 * If the text is centred or right justified and that one character was a
539 * space then break the line before that character
540 * Otherwise break the line after that character
541 * and if the next character is a space then discard it.
542 * Suppose there was none (and the first character did fit).
543 * If Break Within Word is permitted
544 * break the word after the last character that fits (there must be
545 * at least one; none is caught earlier).
547 * discard any trailing space.
548 * include the whole word; it may be ellipsified later
550 * Break Within Word is permitted under a set of circumstances that are not
551 * totally clear yet. Currently our best guess is:
552 * If DT_EDITCONTROL is in effect and neither DT_WORD_ELLIPSIS nor
553 * DT_PATH_ELLIPSIS is
556 static void TEXT_WordBreak (HDC hdc
, WCHAR
*str
, unsigned int max_str
,
557 unsigned int *len_str
,
558 int width
, int format
, unsigned int chars_fit
,
559 unsigned int *chars_used
, SIZE
*size
)
563 assert (format
& DT_WORDBREAK
);
564 assert (chars_fit
< *len_str
);
566 /* Work back from the last character that did fit to either a space or the
567 * last character of a word, whichever is met first.
569 p
= str
+ chars_fit
; /* The character that doesn't fit */
572 ; /* we pretend that it fits anyway */
573 else if (*p
== SPACE
) /* chars_fit < *len_str so this is valid */
574 p
--; /* the word just fitted */
577 while (p
> str
&& *(--p
) != SPACE
)
579 word_fits
= (p
!= str
|| *p
== SPACE
);
581 /* If there was one or the first character didn't fit then */
585 /* break the line before/after that character */
586 if (!(format
& (DT_RIGHT
| DT_CENTER
)) || *p
!= SPACE
)
588 next_is_space
= (unsigned int) (p
- str
) < *len_str
&& *p
== SPACE
;
590 /* and if the next character is a space then discard it. */
591 *chars_used
= *len_str
;
595 /* Suppose there was none. */
598 if ((format
& (DT_EDITCONTROL
| DT_WORD_ELLIPSIS
| DT_PATH_ELLIPSIS
)) ==
601 /* break the word after the last character that fits (there must be
602 * at least one; none is caught earlier).
604 *len_str
= chars_fit
;
605 *chars_used
= chars_fit
;
607 /* FIXME - possible error. Since the next character is now removed
608 * this could make the text longer so that it no longer fits, and
609 * so we need a loop to test and shrink.
615 /* discard any trailing space. */
616 const WCHAR
*e
= str
+ *len_str
;
618 while (p
< e
&& *p
!= SPACE
)
620 *chars_used
= p
- str
;
621 if (p
< e
) /* i.e. loop failed because *p == SPACE */
624 /* include the whole word; it may be ellipsified later */
626 /* Possible optimisation; if DT_WORD_ELLIPSIS only use chars_fit+1
627 * so that it will be too long
631 /* Remeasure the string */
632 GetTextExtentExPointW (hdc
, str
, *len_str
, 0, NULL
, NULL
, size
);
635 /*********************************************************************
638 * Skip over the given number of characters, bearing in mind prefix
639 * substitution and the fact that a character may take more than one
640 * WCHAR (Unicode surrogates are two words long) (and there may have been
644 * new_count [out] The updated count
645 * new_str [out] The updated pointer
646 * start_count [in] The count of remaining characters corresponding to the
647 * start of the string
648 * start_str [in] The starting point of the string
649 * max [in] The number of characters actually in this segment of the
650 * string (the & counts)
651 * n [in] The number of characters to skip (if prefix then
653 * prefix [in] Apply prefix substitution
659 * There must be at least n characters in the string
660 * We need max because the "line" may have ended with a & followed by a tab
661 * or newline etc. which we don't want to swallow
664 static void TEXT_SkipChars (int *new_count
, const WCHAR
**new_str
,
665 int start_count
, const WCHAR
*start_str
,
666 int max
, int n
, int prefix
)
668 /* This is specific to wide characters, MSDN doesn't say anything much
669 * about Unicode surrogates yet and it isn't clear if _wcsinc will
670 * correctly handle them so we'll just do this the easy way for now
675 const WCHAR
*str_on_entry
= start_str
;
679 if (*start_str
++ == PREFIX
&& max
--)
682 start_count
-= (start_str
- str_on_entry
);
689 *new_str
= start_str
;
690 *new_count
= start_count
;
693 /*********************************************************************
696 * Reanalyse the text to find the prefixed character. This is called when
697 * wordbreaking or ellipsification has shortened the string such that the
698 * previously noted prefixed character is no longer visible.
701 * str [in] The original string segment (including all characters)
702 * ns [in] The number of characters in str (including prefixes)
703 * pe [in] The ellipsification data
706 * The prefix offset within the new string segment (the one that contains the
707 * ellipses and does not contain the prefix characters) (-1 if none)
710 static int TEXT_Reprefix (const WCHAR
*str
, unsigned int ns
,
711 const ellipsis_data
*pe
)
715 unsigned int n
= pe
->before
+ pe
->under
+ pe
->after
;
719 if (i
== (unsigned int) pe
->before
)
721 /* Reached the path ellipsis; jump over it */
722 if (ns
< (unsigned int) pe
->under
) break;
726 if (!pe
->after
) break; /* Nothing after the path ellipsis */
730 if (*str
++ == PREFIX
)
734 result
= (i
< (unsigned int) pe
->before
|| pe
->under
== 0) ? i
: i
- pe
->under
+ pe
->len
;
735 /* pe->len may be non-zero while pe_under is zero */
745 /*********************************************************************
746 * Returns true if and only if the remainder of the line is a single
747 * newline representation or nothing
750 static int remainder_is_none_or_newline (int num_chars
, const WCHAR
*str
)
752 if (!num_chars
) return TRUE
;
753 if (*str
!= LF
&& *str
!= CR
) return FALSE
;
754 if (!--num_chars
) return TRUE
;
755 if (*str
== *(str
+1)) return FALSE
;
757 if (*str
!= CR
&& *str
!= LF
) return FALSE
;
758 if (--num_chars
) return FALSE
;
762 /*********************************************************************
763 * Return next line of text from a string.
765 * hdc - handle to DC.
766 * str - string to parse into lines.
767 * count - length of str.
768 * dest - destination in which to return line.
769 * len - dest buffer size in chars on input, copied length into dest on output.
770 * width - maximum width of line in pixels.
771 * format - format type passed to DrawText.
772 * retsize - returned size of the line in pixels.
773 * last_line - TRUE if is the last line that will be processed
774 * p_retstr - If DT_MODIFYSTRING this points to a cursor in the buffer in which
775 * the return string is built.
776 * tabwidth - The width of a tab in logical coordinates
777 * pprefix_offset - Here is where we return the offset within dest of the first
778 * prefixed (underlined) character. -1 is returned if there
779 * are none. Note that there may be more; the calling code
780 * will need to use TEXT_Reprefix to find any later ones.
781 * pellip - Here is where we return the information about any ellipsification
782 * that was carried out. Note that if tabs are being expanded then
783 * this data will correspond to the last text segment actually
784 * returned in dest; by definition there would not have been any
785 * ellipsification in earlier text segments of the line.
787 * Returns pointer to next char in str after end of the line
788 * or NULL if end of str reached.
790 static const WCHAR
*TEXT_NextLineW( HDC hdc
, const WCHAR
*str
, int *count
,
791 WCHAR
*dest
, int *len
, int width
, DWORD format
,
792 SIZE
*retsize
, int last_line
, WCHAR
**p_retstr
,
793 int tabwidth
, int *pprefix_offset
,
794 ellipsis_data
*pellip
)
800 int seg_i
, seg_count
, seg_j
;
805 unsigned int j_in_seg
;
807 *pprefix_offset
= -1;
809 /* For each text segment in the line */
815 /* Skip any leading tabs */
817 if (str
[i
] == TAB
&& (format
& DT_EXPANDTABS
))
819 plen
= ((plen
/tabwidth
)+1)*tabwidth
;
820 (*count
)--; if (j
< maxl
) dest
[j
++] = str
[i
++]; else i
++;
821 while (*count
&& str
[i
] == TAB
)
824 (*count
)--; if (j
< maxl
) dest
[j
++] = str
[i
++]; else i
++;
829 /* Now copy as far as the next tab or cr/lf or eos */
836 (str
[i
] != TAB
|| !(format
& DT_EXPANDTABS
)) &&
837 ((str
[i
] != CR
&& str
[i
] != LF
) || (format
& DT_SINGLELINE
)))
839 if (str
[i
] == PREFIX
&& !(format
& DT_NOPREFIX
) && *count
> 1)
841 (*count
)--, i
++; /* Throw away the prefix itself */
842 if (str
[i
] == PREFIX
)
844 /* Swallow it before we see it again */
845 (*count
)--; if (j
< maxl
) dest
[j
++] = str
[i
++]; else i
++;
847 else if (*pprefix_offset
== -1 || *pprefix_offset
>= seg_j
)
851 /* else the previous prefix was in an earlier segment of the
852 * line; we will leave it to the drawing code to catch this
858 (*count
)--; if (j
< maxl
) dest
[j
++] = str
[i
++]; else i
++;
863 /* Measure the whole text segment and possibly WordBreak and
867 j_in_seg
= j
- seg_j
;
868 max_seg_width
= width
- plen
;
869 GetTextExtentExPointW (hdc
, dest
+ seg_j
, j_in_seg
, max_seg_width
, &num_fit
, NULL
, &size
);
871 /* The Microsoft handling of various combinations of formats is weird.
872 * The following may very easily be incorrect if several formats are
873 * combined, and may differ between versions (to say nothing of the
874 * several bugs in the Microsoft versions).
877 line_fits
= (num_fit
>= j_in_seg
);
878 if (!line_fits
&& (format
& DT_WORDBREAK
))
881 unsigned int chars_used
;
882 TEXT_WordBreak (hdc
, dest
+seg_j
, maxl
-seg_j
, &j_in_seg
,
883 max_seg_width
, format
, num_fit
, &chars_used
, &size
);
884 line_fits
= (size
.cx
<= max_seg_width
);
885 /* and correct the counts */
886 TEXT_SkipChars (count
, &s
, seg_count
, str
+seg_i
, i
-seg_i
,
887 chars_used
, !(format
& DT_NOPREFIX
));
891 pellip
->before
= j_in_seg
;
896 if (!line_fits
&& (format
& DT_PATH_ELLIPSIS
))
898 TEXT_PathEllipsify (hdc
, dest
+ seg_j
, maxl
-seg_j
, &j_in_seg
,
899 max_seg_width
, &size
, *p_retstr
, pellip
);
900 line_fits
= (size
.cx
<= max_seg_width
);
903 /* NB we may end up ellipsifying a word-broken or path_ellipsified
905 if ((!line_fits
&& (format
& DT_WORD_ELLIPSIS
)) ||
906 ((format
& DT_END_ELLIPSIS
) &&
907 ((last_line
&& *count
) ||
908 (remainder_is_none_or_newline (*count
, &str
[i
]) && !line_fits
))))
910 int before
, len_ellipsis
;
911 TEXT_Ellipsify (hdc
, dest
+ seg_j
, maxl
-seg_j
, &j_in_seg
,
912 max_seg_width
, &size
, *p_retstr
, &before
, &len_ellipsis
);
913 if (before
> pellip
->before
)
915 /* We must have done a path ellipsis too */
916 pellip
->after
= before
- pellip
->before
- pellip
->len
;
917 /* Leave the len as the length of the first ellipsis */
921 /* If we are here after a path ellipsification it must be
922 * because even the ellipsis itself didn't fit.
924 assert (pellip
->under
== 0 && pellip
->after
== 0);
925 pellip
->before
= before
;
926 pellip
->len
= len_ellipsis
;
927 /* pellip->after remains as zero as does
931 line_fits
= (size
.cx
<= max_seg_width
);
934 /* As an optimisation if we have ellipsified and we are expanding
935 * tabs and we haven't reached the end of the line we can skip to it
936 * now rather than going around the loop again.
938 if ((format
& DT_EXPANDTABS
) && ellipsified
)
940 if (format
& DT_SINGLELINE
)
944 while ((*count
) && str
[i
] != CR
&& str
[i
] != LF
)
951 j
= seg_j
+ j_in_seg
;
952 if (*pprefix_offset
>= seg_j
+ pellip
->before
)
954 *pprefix_offset
= TEXT_Reprefix (str
+ seg_i
, i
- seg_i
, pellip
);
955 if (*pprefix_offset
!= -1)
956 *pprefix_offset
+= seg_j
;
960 if (size
.cy
> retsize
->cy
)
961 retsize
->cy
= size
.cy
;
967 else if (str
[i
] == CR
|| str
[i
] == LF
)
970 if (*count
&& (str
[i
] == CR
|| str
[i
] == LF
) && str
[i
] != str
[i
-1])
976 /* else it was a Tab and we go around again */
988 /***********************************************************************
989 * TEXT_DrawUnderscore
991 * Draw the underline under the prefixed character
994 * hdc [in] The handle of the DC for drawing
995 * x [in] The x location of the line segment (logical coordinates)
996 * y [in] The y location of where the underscore should appear
997 * (logical coordinates)
998 * str [in] The text of the line segment
999 * offset [in] The offset of the underscored character within str
1000 * rect [in] Clipping rectangle (if not NULL)
1002 /* WINE synced 22-May-2006 */
1003 static void TEXT_DrawUnderscore (HDC hdc
, int x
, int y
, const WCHAR
*str
, int offset
, const RECT
*rect
)
1011 GetTextExtentPointW (hdc
, str
, offset
, &size
);
1012 prefix_x
= x
+ size
.cx
;
1013 GetTextExtentPointW (hdc
, str
, offset
+1, &size
);
1014 prefix_end
= x
+ size
.cx
- 1;
1015 /* The above method may eventually be slightly wrong due to kerning etc. */
1017 /* Check for clipping */
1020 if (prefix_x
> rect
->right
|| prefix_end
< rect
->left
||
1021 y
< rect
->top
|| y
> rect
->bottom
)
1022 return; /* Completely outside */
1023 /* Partially outside */
1024 if (prefix_x
< rect
->left
) prefix_x
= rect
->left
;
1025 if (prefix_end
> rect
->right
) prefix_end
= rect
->right
;
1028 hpen
= CreatePen (PS_SOLID
, 1, GetTextColor (hdc
));
1029 oldPen
= SelectObject (hdc
, hpen
);
1030 MoveToEx (hdc
, prefix_x
, y
, NULL
);
1031 LineTo (hdc
, prefix_end
, y
);
1032 SelectObject (hdc
, oldPen
);
1033 DeleteObject (hpen
);
1036 /***********************************************************************
1037 * DrawTextExW (USER32.@)
1039 * The documentation on the extra space required for DT_MODIFYSTRING at MSDN
1040 * is not quite complete, especially with regard to \0. We will assume that
1041 * the returned string could have a length of up to i_count+3 and also have
1042 * a trailing \0 (which would be 4 more than a not-null-terminated string but
1043 * 3 more than a null-terminated string). If this is not so then increase
1044 * the allowance in DrawTextExA.
1046 #define MAX_BUFFER 1024
1047 /* WINE synced 22-May-2006 */
1052 DrawTextExW( HDC hdc
, LPWSTR str
, INT i_count
,
1053 LPRECT rect
, UINT flags
, LPDRAWTEXTPARAMS dtp
)
1056 const WCHAR
*strPtr
;
1057 WCHAR
*retstr
, *p_retstr
;
1059 WCHAR line
[MAX_BUFFER
];
1060 int len
, lh
, count
=i_count
;
1062 int lmargin
= 0, rmargin
= 0;
1063 int x
= rect
->left
, y
= rect
->top
;
1064 int width
= rect
->right
- rect
->left
;
1067 int tabwidth
/* to keep gcc happy */ = 0;
1069 ellipsis_data ellip
;
1072 TRACE("%s, %d, [%s] %08x\n", debugstr_wn (str
, count
), count
,
1073 wine_dbgstr_rect(rect
), flags
);
1075 if (dtp
) TRACE("Params: iTabLength=%d, iLeftMargin=%d, iRightMargin=%d\n",
1076 dtp
->iTabLength
, dtp
->iLeftMargin
, dtp
->iRightMargin
);
1079 if (!str
|| count
== 0) return 0;
1082 count
= strlenW(str
);
1085 if( flags
& DT_CALCRECT
)
1087 rect
->right
= rect
->left
;
1088 rect
->bottom
= rect
->top
;
1095 if (flags
& DT_SINGLELINE
)
1096 flags
&= ~DT_WORDBREAK
;
1098 GetTextMetricsW(hdc
, &tm
);
1099 if (flags
& DT_EXTERNALLEADING
)
1100 lh
= tm
.tmHeight
+ tm
.tmExternalLeading
;
1106 lmargin
= dtp
->iLeftMargin
* tm
.tmAveCharWidth
;
1107 rmargin
= dtp
->iRightMargin
* tm
.tmAveCharWidth
;
1108 if (!(flags
& (DT_CENTER
| DT_RIGHT
)))
1110 dtp
->uiLengthDrawn
= 0; /* This param RECEIVES number of chars processed */
1113 if (flags
& DT_EXPANDTABS
)
1115 int tabstop
= ((flags
& DT_TABSTOP
) && dtp
) ? dtp
->iTabLength
: 8;
1116 tabwidth
= tm
.tmAveCharWidth
* tabstop
;
1119 if (flags
& DT_CALCRECT
) flags
|= DT_NOCLIP
;
1121 if (flags
& DT_MODIFYSTRING
)
1123 size_retstr
= (count
+ 4) * sizeof (WCHAR
);
1124 retstr
= HeapAlloc(GetProcessHeap(), 0, size_retstr
);
1125 if (!retstr
) return 0;
1126 memcpy (retstr
, str
, size_retstr
);
1137 len
= sizeof(line
)/sizeof(line
[0]);
1138 last_line
= !(flags
& DT_NOCLIP
) && y
+ ((flags
& DT_EDITCONTROL
) ? 2*lh
-1 : lh
) > rect
->bottom
;
1139 strPtr
= TEXT_NextLineW(hdc
, strPtr
, &count
, line
, &len
, width
, flags
, &size
, last_line
, &p_retstr
, tabwidth
, &prefix_offset
, &ellip
);
1141 if (flags
& DT_CENTER
)
1142 x
= (rect
->left
+ rect
->right
- size
.cx
) / 2;
1143 else if (flags
& DT_RIGHT
) x
= rect
->right
- size
.cx
;
1145 if (flags
& DT_SINGLELINE
)
1147 if (flags
& DT_VCENTER
) y
= rect
->top
+
1148 (rect
->bottom
- rect
->top
) / 2 - size
.cy
/ 2;
1149 else if (flags
& DT_BOTTOM
) y
= rect
->bottom
- size
.cy
;
1152 if (!(flags
& DT_CALCRECT
))
1154 const WCHAR
*str
= line
;
1160 if ((flags
& DT_EXPANDTABS
))
1163 p
= str
; while (p
< str
+len
&& *p
!= TAB
) p
++;
1165 if (len_seg
!= len
&& !GetTextExtentPointW(hdc
, str
, len_seg
, &size
))
1171 if (!(flags
& DT_PREFIXONLY
)&&
1172 !ExtTextOutW( hdc
, xseg
, y
,
1173 ((flags
& DT_NOCLIP
) ? 0 : ETO_CLIPPED
) |
1174 ((flags
& DT_RTLREADING
) ? ETO_RTLREADING
: 0),
1175 rect
, str
, len_seg
, NULL
)) return 0;
1176 if (prefix_offset
!= -1 && prefix_offset
< len_seg
&& !(flags
& DT_HIDEPREFIX
))
1178 TEXT_DrawUnderscore (hdc
, xseg
, y
+ tm
.tmAscent
+ 1, str
, prefix_offset
, (flags
& DT_NOCLIP
) ? NULL
: rect
);
1184 assert ((flags
& DT_EXPANDTABS
) && *str
== TAB
);
1186 xseg
+= ((size
.cx
/tabwidth
)+1)*tabwidth
;
1187 if (prefix_offset
!= -1)
1189 if (prefix_offset
< len_seg
)
1191 /* We have just drawn an underscore; we ought to
1192 * figure out where the next one is. I am going
1193 * to leave it for now until I have a better model
1194 * for the line, which will make reprefixing easier.
1195 * This is where ellip would be used.
1200 prefix_offset
-= len_seg
;
1205 else if (size
.cx
> max_width
)
1206 max_width
= size
.cx
;
1210 dtp
->uiLengthDrawn
+= len
;
1212 while (strPtr
&& !last_line
);
1214 if (flags
& DT_CALCRECT
)
1216 rect
->right
= rect
->left
+ max_width
;
1219 rect
->right
+= lmargin
+ rmargin
;
1223 memcpy (str
, retstr
, size_retstr
);
1224 HeapFree (GetProcessHeap(), 0, retstr
);
1226 return y
- rect
->top
;
1229 /***********************************************************************
1230 * DrawTextExA (USER32.@)
1232 * If DT_MODIFYSTRING is specified then there must be room for up to
1233 * 4 extra characters. We take great care about just how much modified
1238 /* WINE synced 22-May-2006 */
1240 DrawTextExA( HDC hdc
, LPSTR str
, INT count
,
1241 LPRECT rect
, UINT flags
, LPDRAWTEXTPARAMS dtp
)
1251 if (!count
) return 0;
1252 if( !str
|| ((count
== -1) && !(count
= strlen(str
))))
1254 if( flags
& DT_CALCRECT
)
1256 rect
->right
= rect
->left
;
1257 rect
->bottom
= rect
->top
;
1261 wcount
= MultiByteToWideChar( CP_ACP
, 0, str
, count
, NULL
, 0 );
1264 if (flags
& DT_MODIFYSTRING
)
1269 wstr
= HeapAlloc(GetProcessHeap(), 0, wmax
* sizeof(WCHAR
));
1272 MultiByteToWideChar( CP_ACP
, 0, str
, count
, wstr
, wcount
);
1273 if (flags
& DT_MODIFYSTRING
)
1274 for (i
=4, p
=wstr
+wcount
; i
--; p
++) *p
=0xFFFE;
1275 /* Initialise the extra characters so that we can see which ones
1276 * change. U+FFFE is guaranteed to be not a unicode character and
1277 * so will not be generated by DrawTextEx itself.
1279 ret
= DrawTextExW( hdc
, wstr
, wcount
, rect
, flags
, dtp
);
1280 if (flags
& DT_MODIFYSTRING
)
1282 /* Unfortunately the returned string may contain multiple \0s
1283 * and so we need to measure it ourselves.
1285 for (i
=4, p
=wstr
+wcount
; i
-- && *p
!= 0xFFFE; p
++) wcount
++;
1286 WideCharToMultiByte( CP_ACP
, 0, wstr
, wcount
, str
, amax
, NULL
, NULL
);
1288 HeapFree(GetProcessHeap(), 0, wstr
);
1293 /***********************************************************************
1294 * DrawTextW (USER32.@)
1299 DrawTextW( HDC hdc
, LPCWSTR str
, INT count
, LPRECT rect
, UINT flags
)
1303 memset (&dtp
, 0, sizeof(dtp
));
1304 if (flags
& DT_TABSTOP
)
1306 dtp
.iTabLength
= (flags
>> 8) && 0xff;
1307 flags
&= 0xffff00ff;
1309 return DrawTextExW(hdc
, (LPWSTR
)str
, count
, rect
, flags
, &dtp
);
1312 /***********************************************************************
1313 * DrawTextA (USER32.@)
1318 DrawTextA( HDC hdc
, LPCSTR str
, INT count
, LPRECT rect
, UINT flags
)
1322 memset (&dtp
, 0, sizeof(dtp
));
1323 if (flags
& DT_TABSTOP
)
1325 dtp
.iTabLength
= (flags
>> 8) && 0xff;
1326 flags
&= 0xffff00ff;
1328 return DrawTextExA( hdc
, (LPSTR
)str
, count
, rect
, flags
, &dtp
);