ReactOS 0.4.15-dev-5666-gc548b97
text.c
Go to the documentation of this file.
1/*
2 * ReactOS kernel
3 * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
4 *
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.
9 *
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.
14 *
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.
18 */
19/*
20 * PROJECT: ReactOS user32.dll
21 * FILE: win32ss/user/rtl/text.c
22 * PURPOSE: Draw Text
23 * PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
24 * UPDATE HISTORY:
25 * 09-05-2001 CSH Created
26 */
27
28/* INCLUDES ******************************************************************/
29
30#ifdef _WIN32K_
31#include <win32k.h>
32DBG_DEFAULT_CHANNEL(UserMenu);
33#else
34#include <user32.h>
35#include <wine/debug.h>
37#endif
38
39/* FUNCTIONS *****************************************************************/
40
41#ifndef NDEBUG
42
43#ifdef assert
44#undef assert
45#endif
46
47#define assert(e) ((e) ? (void)0 : _font_assert(#e, __FILE__, __LINE__))
48
49#else
50#include <assert.h>
51
52#endif
53
54void _font_assert(const char *msg, const char *file, int line)
55{
56 /* Assertion failed at foo.c line 45: x<y */
57 DbgPrint("Assertion failed at %s line %d: %s\n", file, line, msg);
58#ifdef _WIN32K_
60#else
61 ExitProcess(3);
62 for(;;); /* eliminate warning by mingw */
63#endif
64}
65
66/*********************************************************************
67 *
68 * DrawText functions
69 *
70 * Copied from Wine.
71 * Copyright 1993, 1994 Alexandre Julliard
72 * Copyright 2002 Bill Medland
73 *
74 * Design issues
75 * How many buffers to use
76 * While processing in DrawText there are potentially three different forms
77 * of the text that need to be held. How are they best held?
78 * 1. The original text is needed, of course, to see what to display.
79 * 2. The text that will be returned to the user if the DT_MODIFYSTRING is
80 * in effect.
81 * 3. The buffered text that is about to be displayed e.g. the current line.
82 * Typically this will exclude the ampersands used for prefixing etc.
83 *
84 * Complications.
85 * a. If the buffered text to be displayed includes the ampersands then
86 * we will need special measurement and draw functions that will ignore
87 * the ampersands (e.g. by copying to a buffer without the prefix and
88 * then using the normal forms). This may involve less space but may
89 * require more processing. e.g. since a line containing tabs may
90 * contain several underlined characters either we need to carry around
91 * a list of prefix locations or we may need to locate them several
92 * times.
93 * b. If we actually directly modify the "original text" as we go then we
94 * will need some special "caching" to handle the fact that when we
95 * ellipsify the text the ellipsis may modify the next line of text,
96 * which we have not yet processed. (e.g. ellipsification of a W at the
97 * end of a line will overwrite the W, the \n and the first character of
98 * the next line, and a \0 will overwrite the second. Try it!!)
99 *
100 * Option 1. Three separate storages. (To be implemented)
101 * If DT_MODIFYSTRING is in effect then allocate an extra buffer to hold
102 * the edited string in some form, either as the string itself or as some
103 * sort of "edit list" to be applied just before returning.
104 * Use a buffer that holds the ellipsified current line sans ampersands
105 * and accept the need occasionally to recalculate the prefixes (if
106 * DT_EXPANDTABS and not DT_NOPREFIX and not DT_HIDEPREFIX)
107 */
108
109#define TAB 9
110#define LF 10
111#define CR 13
112#define SPACE 32
113#define PREFIX 38
114#define ALPHA_PREFIX 30 /* Win16: Alphabet prefix */
115#define KANA_PREFIX 31 /* Win16: Katakana prefix */
116
117#define FORWARD_SLASH '/'
118#define BACK_SLASH '\\'
119
120static const WCHAR ELLIPSISW[] = {'.','.','.', 0};
121
122typedef struct tag_ellipsis_data
123{
125 int len;
126 int under;
127 int after;
129
130/*********************************************************************
131 * TEXT_Ellipsify (static)
132 *
133 * Add an ellipsis to the end of the given string whilst ensuring it fits.
134 *
135 * If the ellipsis alone doesn't fit then it will be returned anyway.
136 *
137 * See Also TEXT_PathEllipsify
138 *
139 * Arguments
140 * hdc [in] The handle to the DC that defines the font.
141 * str [in/out] The string that needs to be modified.
142 * max_str [in] The dimension of str (number of WCHAR).
143 * len_str [in/out] The number of characters in str
144 * width [in] The maximum width permitted (in logical coordinates)
145 * size [out] The dimensions of the text
146 * modstr [out] The modified form of the string, to be returned to the
147 * calling program. It is assumed that the caller has
148 * made sufficient space available so we don't need to
149 * know the size of the space. This pointer may be NULL if
150 * the modified string is not required.
151 * len_before [out] The number of characters before the ellipsis.
152 * len_ellip [out] The number of characters in the ellipsis.
153 *
154 * See for example Microsoft article Q249678.
155 *
156 * For now we will simply use three dots rather than worrying about whether
157 * the font contains an explicit ellipsis character.
158 */
159static void TEXT_Ellipsify (HDC hdc, WCHAR *str, unsigned int max_len,
160 unsigned int *len_str, int width, SIZE *size,
161 WCHAR *modstr,
162 int *len_before, int *len_ellip)
163{
164 unsigned int len_ellipsis;
165 unsigned int lo, mid, hi;
166 len_ellipsis = strlenW (ELLIPSISW);
167 if (len_ellipsis > max_len) len_ellipsis = max_len;
168 if (*len_str > max_len - len_ellipsis)
169 *len_str = max_len - len_ellipsis;
170
171 /* First do a quick binary search to get an upper bound for *len_str. */
172 if (*len_str > 0 &&
173#ifdef _WIN32K_
174 GreGetTextExtentExW(hdc, str, *len_str, width, NULL, NULL, size, 0) &&
175#else
176 GetTextExtentExPointW(hdc, str, *len_str, width, NULL, NULL, size) &&
177#endif
178 size->cx > width)
179 {
180 for (lo = 0, hi = *len_str; lo < hi; )
181 {
182 mid = (lo + hi) / 2;
183#ifdef _WIN32K_
184 if (!GreGetTextExtentExW(hdc, str, mid, width, NULL, NULL, size, 0))
185#else
187#endif
188 break;
189 if (size->cx > width)
190 hi = mid;
191 else
192 lo = mid + 1;
193 }
194 *len_str = hi;
195 }
196 /* Now this should take only a couple iterations at most. */
197 for ( ; ; )
198 {
199 memcpy(str + *len_str, ELLIPSISW, len_ellipsis*sizeof(WCHAR));
200#ifdef _WIN32K_
201 if (!GreGetTextExtentExW (hdc, str, *len_str + len_ellipsis, width,
202 NULL, NULL, size, 0)) break;
203#else
204 if (!GetTextExtentExPointW (hdc, str, *len_str + len_ellipsis, width,
205 NULL, NULL, size)) break;
206#endif
207 if (!*len_str || size->cx <= width) break;
208
209 (*len_str)--;
210 }
211 *len_ellip = len_ellipsis;
212 *len_before = *len_str;
213 *len_str += len_ellipsis;
214
215 if (modstr)
216 {
217 memcpy (modstr, str, *len_str * sizeof(WCHAR));
218 modstr[*len_str] = '\0';
219 }
220}
221
222/*********************************************************************
223 * TEXT_PathEllipsify (static)
224 *
225 * Add an ellipsis to the provided string in order to make it fit within
226 * the width. The ellipsis is added as specified for the DT_PATH_ELLIPSIS
227 * flag.
228 *
229 * See Also TEXT_Ellipsify
230 *
231 * Arguments
232 * hdc [in] The handle to the DC that defines the font.
233 * str [in/out] The string that needs to be modified
234 * max_str [in] The dimension of str (number of WCHAR).
235 * len_str [in/out] The number of characters in str
236 * width [in] The maximum width permitted (in logical coordinates)
237 * size [out] The dimensions of the text
238 * modstr [out] The modified form of the string, to be returned to the
239 * calling program. It is assumed that the caller has
240 * made sufficient space available so we don't need to
241 * know the size of the space. This pointer may be NULL if
242 * the modified string is not required.
243 * pellip [out] The ellipsification results
244 *
245 * For now we will simply use three dots rather than worrying about whether
246 * the font contains an explicit ellipsis character.
247 *
248 * The following applies, I think to Win95. We will need to extend it for
249 * Win98 which can have both path and end ellipsis at the same time (e.g.
250 * C:\MyLongFileName.Txt becomes ...\MyLongFileN...)
251 *
252 * The resulting string consists of as much as possible of the following:
253 * 1. The ellipsis itself
254 * 2. The last \ or / of the string (if any)
255 * 3. Everything after the last \ or / of the string (if any) or the whole
256 * string if there is no / or \. I believe that under Win95 this would
257 * include everything even though some might be clipped off the end whereas
258 * under Win98 that might be ellipsified too.
259 * Yet to be investigated is whether this would include wordbreaking if the
260 * filename is more than 1 word and splitting if DT_EDITCONTROL was in
261 * effect. (If DT_EDITCONTROL is in effect then on occasions text will be
262 * broken within words).
263 * 4. All the stuff before the / or \, which is placed before the ellipsis.
264 */
265static void TEXT_PathEllipsify (HDC hdc, WCHAR *str, unsigned int max_len,
266 unsigned int *len_str, int width, SIZE *size,
267 WCHAR *modstr, ellipsis_data *pellip)
268{
269 int len_ellipsis;
270 int len_trailing;
271 int len_under;
272 WCHAR *lastBkSlash, *lastFwdSlash, *lastSlash;
273 len_ellipsis = strlenW (ELLIPSISW);
274 if (!max_len) return;
275 if (len_ellipsis >= max_len) len_ellipsis = max_len - 1;
276 if (*len_str + len_ellipsis >= max_len)
277 *len_str = max_len - len_ellipsis-1;
278 /* Hopefully this will never happen, otherwise it would probably lose
279 * the wrong character
280 */
281 str[*len_str] = '\0'; /* to simplify things */
282#ifdef _WIN32K_
283 lastBkSlash = wcsrchr (str, BACK_SLASH);
284 lastFwdSlash = wcsrchr (str, FORWARD_SLASH);
285#else
286 lastBkSlash = strrchrW (str, BACK_SLASH);
287 lastFwdSlash = strrchrW (str, FORWARD_SLASH);
288#endif
289 lastSlash = lastBkSlash > lastFwdSlash ? lastBkSlash : lastFwdSlash;
290 if (!lastSlash) lastSlash = str;
291 len_trailing = *len_str - (lastSlash - str);
292
293 /* overlap-safe movement to the right */
294 memmove (lastSlash+len_ellipsis, lastSlash, len_trailing * sizeof(WCHAR));
295 memcpy (lastSlash, ELLIPSISW, len_ellipsis*sizeof(WCHAR));
296 len_trailing += len_ellipsis;
297 /* From this point on lastSlash actually points to the ellipsis in front
298 * of the last slash and len_trailing includes the ellipsis
299 */
300
301 len_under = 0;
302 for ( ; ; )
303 {
304#ifdef _WIN32K_
305 if (!GreGetTextExtentExW (hdc, str, *len_str + len_ellipsis, width,
306 NULL, NULL, size, 0)) break;
307#else
308 if (!GetTextExtentExPointW (hdc, str, *len_str + len_ellipsis, width,
309 NULL, NULL, size)) break;
310#endif
311 if (lastSlash == str || size->cx <= width) break;
312
313 /* overlap-safe movement to the left */
314 memmove (lastSlash-1, lastSlash, len_trailing * sizeof(WCHAR));
315 lastSlash--;
316 len_under++;
317
318 assert (*len_str);
319 (*len_str)--;
320 }
321 pellip->before = lastSlash-str;
322 pellip->len = len_ellipsis;
323 pellip->under = len_under;
324 pellip->after = len_trailing - len_ellipsis;
325 *len_str += len_ellipsis;
326
327 if (modstr)
328 {
329 memcpy(modstr, str, *len_str * sizeof(WCHAR));
330 modstr[*len_str] = '\0';
331 }
332}
333
334/* Check the character is Chinese, Japanese, Korean and/or Thai */
336{
337 if (0x0E00 <= wch && wch <= 0x0E7F)
338 return TRUE; /* Thai */
339
340 if (0x3000 <= wch && wch <= 0x9FFF)
341 return TRUE; /* CJK */
342
343 if (0xAC00 <= wch && wch <= 0xD7FF)
344 return TRUE; /* Korean */
345
346 if (0xFF00 <= wch && wch <= 0xFFEF)
347 return TRUE; /* CJK */
348
349 return FALSE;
350}
351
352/* See http://en.wikipedia.org/wiki/Kinsoku_shori */
353static const WCHAR KinsokuClassA[] =
354{
355 0x2010, 0x2013, 0x2019, 0x201D, 0x203C, 0x2047, 0x2048, 0x2049, 0x3001,
356 0x3002, 0x3005, 0x3009, 0x300B, 0x300D, 0x300F, 0x3011, 0x3015, 0x3017,
357 0x3019, 0x301C, 0x301F, 0x303B, 0x3041, 0x3043, 0x3045, 0x3047, 0x3049,
358 0x3063, 0x3083, 0x3085, 0x3087, 0x308E, 0x3095, 0x3096, 0x30A0, 0x30A1,
359 0x30A3, 0x30A5, 0x30A7, 0x30A9, 0x30C3, 0x30E3, 0x30E5, 0x30E7, 0x30EE,
360 0x30F5, 0x30F6, 0x30FB, 0x30FC, 0x30FD, 0x30FE, 0x31F0, 0x31F1, 0x31F2,
361 0x31F3, 0x31F4, 0x31F5, 0x31F6, 0x31F7, 0x31F8, 0x31F9, 0x31FA, 0x31FB,
362 0x31FC, 0x31FD, 0x31FE, 0x31FF, 0xFF01, 0xFF09, 0xFF0C, 0xFF0E, 0xFF1A,
363 0xFF1B, 0xFF1F, 0xFF3D, 0xFF5D, 0xFF60, 0
364};
365
366/*********************************************************************
367 * TEXT_WordBreak (static)
368 *
369 * Perform wordbreak processing on the given string
370 *
371 * Assumes that DT_WORDBREAK has been specified and not all the characters
372 * fit. Note that this function should even be called when the first character
373 * that doesn't fit is known to be a space or tab, so that it can swallow them.
374 *
375 * Note that the Windows processing has some strange properties.
376 * 1. If the text is left-justified and there is room for some of the spaces
377 * that follow the last word on the line then those that fit are included on
378 * the line.
379 * 2. If the text is centred or right-justified and there is room for some of
380 * the spaces that follow the last word on the line then all but one of those
381 * that fit are included on the line.
382 * 3. (Reasonable behaviour) If the word breaking causes a space to be the first
383 * character of a new line it will be skipped.
384 *
385 * Arguments
386 * hdc [in] The handle to the DC that defines the font.
387 * str [in/out] The string that needs to be broken.
388 * max_str [in] The dimension of str (number of WCHAR).
389 * len_str [in/out] The number of characters in str
390 * width [in] The maximum width permitted
391 * format [in] The format flags in effect
392 * chars_fit [in] The maximum number of characters of str that are already
393 * known to fit; chars_fit+1 is known not to fit.
394 * chars_used [out] The number of characters of str that have been "used" and
395 * do not need to be included in later text. For example this will
396 * include any spaces that have been discarded from the start of
397 * the next line.
398 * size [out] The size of the returned text in logical coordinates
399 *
400 * Pedantic assumption - Assumes that the text length is monotonically
401 * increasing with number of characters (i.e. no weird kernings)
402 *
403 * Algorithm
404 *
405 * Work back from the last character that did fit to either a space or the last
406 * character of a word, whichever is met first.
407 * If there was one or the first character didn't fit then
408 * If the text is centred or right justified and that one character was a
409 * space then break the line before that character
410 * Otherwise break the line after that character
411 * and if the next character is a space then discard it.
412 * Suppose there was none (and the first character did fit).
413 * If Break Within Word is permitted
414 * break the word after the last character that fits (there must be
415 * at least one; none is caught earlier).
416 * Otherwise
417 * discard any trailing space.
418 * include the whole word; it may be ellipsified later
419 *
420 * Break Within Word is permitted under a set of circumstances that are not
421 * totally clear yet. Currently our best guess is:
422 * If DT_EDITCONTROL is in effect and neither DT_WORD_ELLIPSIS nor
423 * DT_PATH_ELLIPSIS is
424 */
425
426static void TEXT_WordBreak (HDC hdc, WCHAR *str, unsigned int max_str,
427 unsigned int *len_str,
428 int width, int format, unsigned int chars_fit,
429 unsigned int *chars_used, SIZE *size)
430{
431 WCHAR *p;
432 int word_fits;
434 assert (chars_fit < *len_str);
435
436 /* Work back from the last character that did fit to either a space or the
437 * last character of a word, whichever is met first.
438 */
439 p = str + chars_fit; /* The character that doesn't fit */
440 word_fits = TRUE;
441 if (!chars_fit)
442 word_fits = FALSE;
443 else if (*p == SPACE) /* chars_fit < *len_str so this is valid */
444 p--; /* the word just fitted */
445 else
446 {
447 while (p > str && *(--p) != SPACE && (!IsCJKT(p[1]) ||
448 p[1] == L'\0' || wcschr(KinsokuClassA, p[1]) != NULL))
449 ;
450 word_fits = (p != str || *p == SPACE || IsCJKT(p[1]));
451 }
452 /* If there was one. */
453 if (word_fits)
454 {
455 int next_is_space;
456 /* break the line before/after that character */
457 if (!(format & (DT_RIGHT | DT_CENTER)) || *p != SPACE)
458 p++;
459 next_is_space = (unsigned int) (p - str) < *len_str && *p == SPACE;
460 *len_str = p - str;
461 /* and if the next character is a space then discard it. */
462 *chars_used = *len_str;
463 if (next_is_space)
464 (*chars_used)++;
465 }
466 /* Suppose there was none. */
467 else
468 {
471 {
472 /* break the word after the last character that fits (there must be
473 * at least one). */
474 if (!chars_fit)
475 ++chars_fit;
476 *len_str = chars_fit;
477 *chars_used = chars_fit;
478
479 /* FIXME - possible error. Since the next character is now removed
480 * this could make the text longer so that it no longer fits, and
481 * so we need a loop to test and shrink.
482 */
483 }
484 /* Otherwise */
485 else
486 {
487 /* discard any trailing space. */
488 const WCHAR *e = str + *len_str;
489 p = str + chars_fit;
490 while (p < e && *p != SPACE)
491 p++;
492 *chars_used = p - str;
493 if (p < e) /* i.e. loop failed because *p == SPACE */
494 (*chars_used)++;
495
496 /* include the whole word; it may be ellipsified later */
497 *len_str = p - str;
498 /* Possible optimisation; if DT_WORD_ELLIPSIS only use chars_fit+1
499 * so that it will be too long
500 */
501 }
502 }
503 /* Remeasure the string */
504#ifdef _WIN32K_
505 GreGetTextExtentExW (hdc, str, *len_str, 0, NULL, NULL, size, 0);
506#else
507 GetTextExtentExPointW (hdc, str, *len_str, 0, NULL, NULL, size);
508#endif
509}
510
511/*********************************************************************
512 * TEXT_SkipChars
513 *
514 * Skip over the given number of characters, bearing in mind prefix
515 * substitution and the fact that a character may take more than one
516 * WCHAR (Unicode surrogates are two words long) (and there may have been
517 * a trailing &)
518 *
519 * Parameters
520 * new_count [out] The updated count
521 * new_str [out] The updated pointer
522 * start_count [in] The count of remaining characters corresponding to the
523 * start of the string
524 * start_str [in] The starting point of the string
525 * max [in] The number of characters actually in this segment of the
526 * string (the & counts)
527 * n [in] The number of characters to skip (if prefix then
528 * &c counts as one)
529 * prefix [in] Apply prefix substitution
530 *
531 * Return Values
532 * none
533 *
534 * Remarks
535 * There must be at least n characters in the string
536 * We need max because the "line" may have ended with a & followed by a tab
537 * or newline etc. which we don't want to swallow
538 */
539
540static void TEXT_SkipChars (int *new_count, const WCHAR **new_str,
541 int start_count, const WCHAR *start_str,
542 int max, int n, int prefix)
543{
544 /* This is specific to wide characters, MSDN doesn't say anything much
545 * about Unicode surrogates yet and it isn't clear if _wcsinc will
546 * correctly handle them so we'll just do this the easy way for now
547 */
548
549 if (prefix)
550 {
551 const WCHAR *str_on_entry = start_str;
552 assert (max >= n);
553 max -= n;
554 while (n--)
555 {
556 if ((*start_str == PREFIX || *start_str == ALPHA_PREFIX) && max--)
557 start_str++;
558 start_str++;
559 }
560 start_count -= (start_str - str_on_entry);
561 }
562 else
563 {
564 start_str += n;
565 start_count -= n;
566 }
567 *new_str = start_str;
568 *new_count = start_count;
569}
570
571/*********************************************************************
572 * TEXT_Reprefix
573 *
574 * Reanalyse the text to find the prefixed character. This is called when
575 * wordbreaking or ellipsification has shortened the string such that the
576 * previously noted prefixed character is no longer visible.
577 *
578 * Parameters
579 * str [in] The original string segment (including all characters)
580 * ns [in] The number of characters in str (including prefixes)
581 * pe [in] The ellipsification data
582 *
583 * Return Values
584 * The prefix offset within the new string segment (the one that contains the
585 * ellipses and does not contain the prefix characters) (-1 if none)
586 */
587
588static int TEXT_Reprefix (const WCHAR *str, unsigned int ns,
589 const ellipsis_data *pe)
590{
591 int result = -1;
592 unsigned int i;
593 unsigned int n = pe->before + pe->under + pe->after;
594 assert (n <= ns);
595 for (i = 0; i < n; i++, str++)
596 {
597 if (i == (unsigned int) pe->before)
598 {
599 /* Reached the path ellipsis; jump over it */
600 if (ns < (unsigned int) pe->under) break;
601 str += pe->under;
602 ns -= pe->under;
603 i += pe->under;
604 if (!pe->after) break; /* Nothing after the path ellipsis */
605 }
606 if (!ns) break;
607 ns--;
608 if (*str++ == PREFIX || *str == ALPHA_PREFIX)
609 {
610 str++;
611 if (!ns) break;
612 if (*str != PREFIX)
613 result = (i < (unsigned int) pe->before || pe->under == 0) ? i : i - pe->under + pe->len;
614 /* pe->len may be non-zero while pe_under is zero */
615 ns--;
616 }
617 }
618 return result;
619}
620
621/*********************************************************************
622 * Returns true if and only if the remainder of the line is a single
623 * newline representation or nothing
624 */
625
626static int remainder_is_none_or_newline (int num_chars, const WCHAR *str)
627{
628 if (!num_chars) return TRUE;
629 if (*str != LF && *str != CR) return FALSE;
630 if (!--num_chars) return TRUE;
631 if (*str == *(str+1)) return FALSE;
632 str++;
633 if (*str != CR && *str != LF) return FALSE;
634 if (--num_chars) return FALSE;
635 return TRUE;
636}
637
638/*********************************************************************
639 * Return next line of text from a string.
640 *
641 * hdc - handle to DC.
642 * str - string to parse into lines.
643 * count - length of str.
644 * dest - destination in which to return line.
645 * len - dest buffer size in chars on input, copied length into dest on output.
646 * width - maximum width of line in pixels.
647 * format - format type passed to DrawText.
648 * retsize - returned size of the line in pixels.
649 * last_line - TRUE if is the last line that will be processed
650 * p_retstr - If DT_MODIFYSTRING this points to a cursor in the buffer in which
651 * the return string is built.
652 * tabwidth - The width of a tab in logical coordinates
653 * pprefix_offset - Here is where we return the offset within dest of the first
654 * prefixed (underlined) character. -1 is returned if there
655 * are none. Note that there may be more; the calling code
656 * will need to use TEXT_Reprefix to find any later ones.
657 * pellip - Here is where we return the information about any ellipsification
658 * that was carried out. Note that if tabs are being expanded then
659 * this data will correspond to the last text segment actually
660 * returned in dest; by definition there would not have been any
661 * ellipsification in earlier text segments of the line.
662 *
663 * Returns pointer to next char in str after end of the line
664 * or NULL if end of str reached.
665 */
666static const WCHAR *TEXT_NextLineW( HDC hdc, const WCHAR *str, int *count,
667 WCHAR *dest, int *len, int width, DWORD format,
668 SIZE *retsize, int last_line, WCHAR **p_retstr,
669 int tabwidth, int *pprefix_offset,
670 ellipsis_data *pellip)
671{
672 int i = 0, j = 0;
673 int plen = 0;
674 SIZE size = {0, 0};
675 int maxl = *len;
676 int seg_i, seg_count, seg_j;
677 int max_seg_width;
678 int num_fit;
679 int word_broken;
680 int line_fits;
681 unsigned int j_in_seg;
682 int ellipsified;
683 *pprefix_offset = -1;
684
685 /* For each text segment in the line */
686
687 retsize->cy = 0;
688 while (*count)
689 {
690
691 /* Skip any leading tabs */
692
693 if (str[i] == TAB && (format & DT_EXPANDTABS))
694 {
695 plen = ((plen/tabwidth)+1)*tabwidth;
696 (*count)--; if (j < maxl) dest[j++] = str[i++]; else i++;
697 while (*count && str[i] == TAB)
698 {
699 plen += tabwidth;
700 (*count)--; if (j < maxl) dest[j++] = str[i++]; else i++;
701 }
702 }
703
704
705 /* Now copy as far as the next tab or cr/lf or eos */
706
707 seg_i = i;
708 seg_count = *count;
709 seg_j = j;
710
711 while (*count &&
712 (str[i] != TAB || !(format & DT_EXPANDTABS)) &&
713 ((str[i] != CR && str[i] != LF) || (format & DT_SINGLELINE)))
714 {
715 if ((format & DT_NOPREFIX) || *count <= 1)
716 {
717 (*count)--; if (j < maxl) dest[j++] = str[i++]; else i++;
718 continue;
719 }
720
721 if (str[i] == PREFIX || str[i] == ALPHA_PREFIX) {
722 (*count)--, i++; /* Throw away the prefix itself */
723 if (str[i] == PREFIX)
724 {
725 /* Swallow it before we see it again */
726 (*count)--; if (j < maxl) dest[j++] = str[i++]; else i++;
727 }
728 else if (*pprefix_offset == -1 || *pprefix_offset >= seg_j)
729 {
730 *pprefix_offset = j;
731 }
732 /* else the previous prefix was in an earlier segment of the
733 * line; we will leave it to the drawing code to catch this
734 * one.
735 */
736 }
737 else if (str[i] == KANA_PREFIX)
738 {
739 /* Throw away katakana access keys */
740 (*count)--, i++; /* skip the prefix */
741 (*count)--, i++; /* skip the letter */
742 }
743 else
744 {
745 (*count)--; if (j < maxl) dest[j++] = str[i++]; else i++;
746 }
747 }
748
749
750 /* Measure the whole text segment and possibly WordBreak and
751 * ellipsify it
752 */
753
754 j_in_seg = j - seg_j;
755 max_seg_width = width - plen;
756#ifdef _WIN32K_
757 GreGetTextExtentExW (hdc, dest + seg_j, j_in_seg, max_seg_width, (PULONG)&num_fit, NULL, &size, 0);
758#else
759 GetTextExtentExPointW (hdc, dest + seg_j, j_in_seg, max_seg_width, &num_fit, NULL, &size);
760#endif
761
762 /* The Microsoft handling of various combinations of formats is weird.
763 * The following may very easily be incorrect if several formats are
764 * combined, and may differ between versions (to say nothing of the
765 * several bugs in the Microsoft versions).
766 */
767 word_broken = 0;
768 line_fits = (num_fit >= j_in_seg);
769 if (!line_fits && (format & DT_WORDBREAK))
770 {
771 const WCHAR *s;
772 unsigned int chars_used;
773 TEXT_WordBreak (hdc, dest+seg_j, maxl-seg_j, &j_in_seg,
774 max_seg_width, format, num_fit, &chars_used, &size);
775 line_fits = (size.cx <= max_seg_width);
776 /* and correct the counts */
777 TEXT_SkipChars (count, &s, seg_count, str+seg_i, i-seg_i,
778 chars_used, !(format & DT_NOPREFIX));
779 i = s - str;
780 word_broken = 1;
781 }
782 pellip->before = j_in_seg;
783 pellip->under = 0;
784 pellip->after = 0;
785 pellip->len = 0;
786 ellipsified = 0;
787 if (!line_fits && (format & DT_PATH_ELLIPSIS))
788 {
789 TEXT_PathEllipsify (hdc, dest + seg_j, maxl-seg_j, &j_in_seg,
790 max_seg_width, &size, *p_retstr, pellip);
791 line_fits = (size.cx <= max_seg_width);
792 ellipsified = 1;
793 }
794 /* NB we may end up ellipsifying a word-broken or path_ellipsified
795 * string */
796 if ((!line_fits && (format & DT_WORD_ELLIPSIS)) ||
797 ((format & DT_END_ELLIPSIS) &&
798 ((last_line && *count) ||
799 (remainder_is_none_or_newline (*count, &str[i]) && !line_fits))))
800 {
801 int before, len_ellipsis;
802 TEXT_Ellipsify (hdc, dest + seg_j, maxl-seg_j, &j_in_seg,
803 max_seg_width, &size, *p_retstr, &before, &len_ellipsis);
804 if (before > pellip->before)
805 {
806 /* We must have done a path ellipsis too */
807 pellip->after = before - pellip->before - pellip->len;
808 /* Leave the len as the length of the first ellipsis */
809 }
810 else
811 {
812 /* If we are here after a path ellipsification it must be
813 * because even the ellipsis itself didn't fit.
814 */
815 assert (pellip->under == 0 && pellip->after == 0);
816 pellip->before = before;
817 pellip->len = len_ellipsis;
818 /* pellip->after remains as zero as does
819 * pellip->under
820 */
821 }
822 line_fits = (size.cx <= max_seg_width);
823 ellipsified = 1;
824 }
825 /* As an optimisation if we have ellipsified and we are expanding
826 * tabs and we haven't reached the end of the line we can skip to it
827 * now rather than going around the loop again.
828 */
829 if ((format & DT_EXPANDTABS) && ellipsified)
830 {
831 if (format & DT_SINGLELINE)
832 *count = 0;
833 else
834 {
835 while ((*count) && str[i] != CR && str[i] != LF)
836 {
837 (*count)--, i++;
838 }
839 }
840 }
841
842 j = seg_j + j_in_seg;
843 if (*pprefix_offset >= seg_j + pellip->before)
844 {
845 *pprefix_offset = TEXT_Reprefix (str + seg_i, i - seg_i, pellip);
846 if (*pprefix_offset != -1)
847 *pprefix_offset += seg_j;
848 }
849
850 plen += size.cx;
851 if (size.cy > retsize->cy)
852 retsize->cy = size.cy;
853
854 if (word_broken)
855 break;
856 else if (!*count)
857 break;
858 else if (str[i] == CR || str[i] == LF)
859 {
860 (*count)--, i++;
861 if (*count && (str[i] == CR || str[i] == LF) && str[i] != str[i-1])
862 {
863 (*count)--, i++;
864 }
865 break;
866 }
867 /* else it was a Tab and we go around again */
868 }
869
870 retsize->cx = plen;
871 *len = j;
872 if (*count)
873 return (&str[i]);
874 else
875 return NULL;
876}
877
878
879/***********************************************************************
880 * TEXT_DrawUnderscore
881 *
882 * Draw the underline under the prefixed character
883 *
884 * Parameters
885 * hdc [in] The handle of the DC for drawing
886 * x [in] The x location of the line segment (logical coordinates)
887 * y [in] The y location of where the underscore should appear
888 * (logical coordinates)
889 * str [in] The text of the line segment
890 * offset [in] The offset of the underscored character within str
891 * rect [in] Clipping rectangle (if not NULL)
892 */
893/* Synced with wine 1.1.32 */
894static void TEXT_DrawUnderscore (HDC hdc, int x, int y, const WCHAR *str, int offset, const RECT *rect)
895{
896 int prefix_x;
897 int prefix_end;
898 SIZE size;
899 HPEN hpen;
900 HPEN oldPen;
901#ifdef _WIN32K_
903#else
905#endif
906 prefix_x = x + size.cx;
907#ifdef _WIN32K_
909#else
911#endif
912 prefix_end = x + size.cx - 1;
913 /* The above method may eventually be slightly wrong due to kerning etc. */
914
915 /* Check for clipping */
916 if (rect)
917 {
918 if (prefix_x > rect->right || prefix_end < rect->left ||
919 y < rect->top || y > rect->bottom)
920 return; /* Completely outside */
921 /* Partially outside */
922 if (prefix_x < rect->left ) prefix_x = rect->left;
923 if (prefix_end > rect->right) prefix_end = rect->right;
924 }
925#ifdef _WIN32K_
927 oldPen = NtGdiSelectPen (hdc, hpen);
928 GreMoveTo (hdc, prefix_x, y, NULL);
929 NtGdiLineTo (hdc, prefix_end, y);
930 NtGdiSelectPen (hdc, oldPen);
932#else
934 oldPen = SelectObject (hdc, hpen);
935 MoveToEx (hdc, prefix_x, y, NULL);
936 LineTo (hdc, prefix_end, y);
937 SelectObject (hdc, oldPen);
939#endif
940}
941
942#ifdef _WIN32K_
943/***********************************************************************
944 * UserExtTextOutW
945 *
946 * Callback to usermode to use ExtTextOut, which will apply complex
947 * script processing if needed and then draw it
948 *
949 * Parameters
950 * hdc [in] The handle of the DC for drawing
951 * x [in] The x location of the string
952 * y [in] The y location of the string
953 * flags [in] ExtTextOut flags
954 * lprc [in] Clipping rectangle (if not NULL)
955 * lpString [in] String to be drawn
956 * count [in] String length
957 */
959 INT x,
960 INT y,
961 UINT flags,
962 PRECTL lprc,
963 LPCWSTR lpString,
964 UINT count)
965{
966 PVOID ResultPointer;
968 ULONG ArgumentLength;
969 ULONG_PTR pStringBuffer;
972 BOOL bResult;
973
974 ArgumentLength = sizeof(LPK_CALLBACK_ARGUMENTS);
975
976 pStringBuffer = ArgumentLength;
977 ArgumentLength += sizeof(WCHAR) * (count + 2);
978
979 Argument = IntCbAllocateMemory(ArgumentLength);
980
981 if (!Argument)
982 {
983 goto fallback;
984 }
985
986 /* Initialize struct members */
987 Argument->hdc = hdc;
988 Argument->x = x;
989 Argument->y = y;
990 Argument->flags = flags;
991 Argument->count = count;
992
993 if (lprc)
994 {
995 Argument->rect = *lprc;
996 Argument->bRect = TRUE;
997 }
998 else
999 {
1000 Argument->bRect = FALSE;
1001 }
1002
1003 /* Align lpString
1004 mimicks code from co_IntClientLoadLibrary */
1005 Argument->lpString = (LPWSTR)pStringBuffer;
1006 pStringBuffer += (ULONG_PTR)Argument;
1007
1008 Status = RtlStringCchCopyNW((LPWSTR)pStringBuffer, count + 1, lpString, count);
1009
1010 if (!NT_SUCCESS(Status))
1011 {
1012 IntCbFreeMemory(Argument);
1013 goto fallback;
1014 }
1015
1016 UserLeaveCo();
1017
1019 Argument,
1020 ArgumentLength,
1021 &ResultPointer,
1022 &ResultLength);
1023
1024 UserEnterCo();
1025
1026 IntCbFreeMemory(Argument);
1027
1028 if (NT_SUCCESS(Status))
1029 {
1030 _SEH2_TRY
1031 {
1032 ProbeForRead(ResultPointer, sizeof(BOOL), 1);
1033 bResult = *(LPBOOL)ResultPointer;
1034 }
1036 {
1037 ERR("Failed to copy result from user mode!\n");
1039 }
1040 _SEH2_END;
1041 }
1042
1043 if (!NT_SUCCESS(Status))
1044 {
1045 goto fallback;
1046 }
1047
1048 return bResult;
1049
1050fallback:
1051 return GreExtTextOutW(hdc, x, y, flags, lprc, lpString, count, NULL, 0);
1052}
1053#endif
1054
1055/***********************************************************************
1056 * DrawTextExW (USER32.@)
1057 *
1058 * The documentation on the extra space required for DT_MODIFYSTRING at MSDN
1059 * is not quite complete, especially with regard to \0. We will assume that
1060 * the returned string could have a length of up to i_count+3 and also have
1061 * a trailing \0 (which would be 4 more than a not-null-terminated string but
1062 * 3 more than a null-terminated string). If this is not so then increase
1063 * the allowance in DrawTextExA.
1064 */
1065#define MAX_BUFFER 1024
1066/*
1067 * DrawTextExW
1068 *
1069 * Synced with Wine Staging 1.7.37
1070 */
1072 LPWSTR str,
1073 INT i_count,
1074 LPRECT rect,
1075 UINT flags,
1076 LPDRAWTEXTPARAMS dtp )
1077{
1078 SIZE size;
1079 const WCHAR *strPtr;
1080 WCHAR *retstr, *p_retstr;
1081 size_t size_retstr;
1083 int len, lh, count=i_count;
1085 int lmargin = 0, rmargin = 0;
1086 int x = rect->left, y = rect->top;
1087 int width = rect->right - rect->left;
1088 int max_width = 0;
1089 int last_line;
1090 int tabwidth /* to keep gcc happy */ = 0;
1091 int prefix_offset;
1092 ellipsis_data ellip;
1093 BOOL invert_y=FALSE;
1094
1095 HRGN hrgn = 0;
1096
1097#ifdef _WIN32K_
1098 TRACE("%S, %d, %08x\n", str, count, flags);
1099#else
1100 TRACE("%s, %d, [%s] %08x\n", debugstr_wn (str, count), count,
1102#endif
1103 if (dtp) TRACE("Params: iTabLength=%d, iLeftMargin=%d, iRightMargin=%d\n",
1104 dtp->iTabLength, dtp->iLeftMargin, dtp->iRightMargin);
1105
1106 if (!str) return 0;
1107
1108 strPtr = str;
1109
1110 if (flags & DT_SINGLELINE)
1111 flags &= ~DT_WORDBREAK;
1112#ifdef _WIN32K_
1114#else
1116#endif
1118 lh = tm.tmHeight + tm.tmExternalLeading;
1119 else
1120 lh = tm.tmHeight;
1121
1122 if (str[0] && count == 0)
1123 return lh;
1124
1125 if (dtp && dtp->cbSize != sizeof(DRAWTEXTPARAMS))
1126 return 0;
1127#ifdef _WIN32K_
1129 {
1130 SIZE window_ext, viewport_ext;
1131 GreGetWindowExtEx(hdc, &window_ext);
1132 GreGetViewportExtEx(hdc, &viewport_ext);
1133 if ((window_ext.cy > 0) != (viewport_ext.cy > 0))
1134 invert_y = TRUE;
1135 }
1136#else
1138 {
1139 SIZE window_ext, viewport_ext;
1140 GetWindowExtEx(hdc, &window_ext);
1141 GetViewportExtEx(hdc, &viewport_ext);
1142 if ((window_ext.cy > 0) != (viewport_ext.cy > 0))
1143 invert_y = TRUE;
1144 }
1145#endif
1146 if (count == -1)
1147 {
1148#ifdef _WIN32K_
1149 count = wcslen(str);
1150#else
1151 count = strlenW(str);
1152#endif
1153 if (count == 0)
1154 {
1155 if( flags & DT_CALCRECT)
1156 {
1157 rect->right = rect->left;
1158 if( flags & DT_SINGLELINE)
1159 rect->bottom = rect->top + (invert_y ? -lh : lh);
1160 else
1161 rect->bottom = rect->top;
1162 }
1163 return lh;
1164 }
1165 }
1166
1167 if (dtp)
1168 {
1169 lmargin = dtp->iLeftMargin;
1170 rmargin = dtp->iRightMargin;
1171 if (!(flags & (DT_CENTER | DT_RIGHT)))
1172 x += lmargin;
1173 dtp->uiLengthDrawn = 0; /* This param RECEIVES number of chars processed */
1174 }
1175
1176 if (flags & DT_EXPANDTABS)
1177 {
1178 int tabstop = ((flags & DT_TABSTOP) && dtp && dtp->iTabLength) ? dtp->iTabLength : 8;
1179 tabwidth = tm.tmAveCharWidth * tabstop;
1180 }
1181
1182 if (flags & DT_CALCRECT) flags |= DT_NOCLIP;
1183#ifndef _WIN32K_
1184 if (!(flags & DT_NOCLIP) )
1185 {
1186 int hasClip;
1187 hrgn = CreateRectRgn(0,0,0,0);
1188 if (hrgn)
1189 {
1190 hasClip = GetClipRgn(hdc, hrgn);
1191 // If the region to be retrieved is NULL, the return value is 0.
1192 if (hasClip != 1)
1193 {
1195 hrgn = NULL;
1196 }
1197 IntersectClipRect(hdc, rect->left, rect->top, rect->right, rect->bottom);
1198 }
1199 }
1200#else
1201 if (!(flags & DT_NOCLIP) )
1202 {
1203 int hasClip;
1204 hrgn = NtGdiCreateRectRgn(0,0,0,0);
1205 if (hrgn)
1206 {
1207 hasClip = NtGdiGetRandomRgn(hdc, hrgn, CLIPRGN);
1208 if (hasClip != 1)
1209 {
1211 hrgn = NULL;
1212 }
1213 NtGdiIntersectClipRect(hdc, rect->left, rect->top, rect->right, rect->bottom);
1214 }
1215 }
1216#endif
1217 if (flags & DT_MODIFYSTRING)
1218 {
1219 size_retstr = (count + 4) * sizeof (WCHAR);
1220#ifdef _WIN32K_
1221 retstr = ExAllocatePoolWithTag(PagedPool, size_retstr, USERTAG_RTL);
1222#else
1223 retstr = HeapAlloc(GetProcessHeap(), 0, size_retstr);
1224#endif
1225 if (!retstr) return 0;
1226 memcpy (retstr, str, size_retstr);
1227 }
1228 else
1229 {
1230 size_retstr = 0;
1231 retstr = NULL;
1232 }
1233 p_retstr = retstr;
1234
1235 do
1236 {
1237 len = sizeof(line)/sizeof(line[0]);
1238 if (invert_y)
1239 last_line = !(flags & DT_NOCLIP) && y - ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) < rect->bottom;
1240 else
1241 last_line = !(flags & DT_NOCLIP) && y + ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) > rect->bottom;
1242 strPtr = TEXT_NextLineW(hdc, strPtr, &count, line, &len, width, flags, &size, last_line, &p_retstr, tabwidth, &prefix_offset, &ellip);
1243
1244#ifdef __REACTOS__
1245 if (flags & DT_CENTER)
1246 {
1247 if (((rect->right - rect->left) < size.cx) && (flags & DT_CALCRECT))
1248 {
1249 x = rect->left + size.cx;
1250 }
1251 else
1252 {
1253 x = (rect->left + rect->right - size.cx) / 2;
1254 }
1255 }
1256#else
1257 if (flags & DT_CENTER) x = (rect->left + rect->right -
1258 size.cx) / 2;
1259#endif
1260 else if (flags & DT_RIGHT) x = rect->right - size.cx;
1261
1262 if (flags & DT_SINGLELINE)
1263 {
1264#ifdef __REACTOS__
1265 if (flags & DT_VCENTER) y = rect->top +
1266 (rect->bottom - rect->top + (invert_y ? size.cy : -size.cy)) / 2;
1267 else if (flags & DT_BOTTOM)
1268 y = rect->bottom + (invert_y ? size.cy : -size.cy);
1269#else
1270 if (flags & DT_VCENTER) y = rect->top +
1271 (rect->bottom - rect->top) / 2 - size.cy / 2;
1272 else if (flags & DT_BOTTOM) y = rect->bottom - size.cy;
1273#endif
1274 }
1275
1276 if (!(flags & DT_CALCRECT))
1277 {
1278 const WCHAR *str = line;
1279 int xseg = x;
1280 while (len)
1281 {
1282 int len_seg;
1283 SIZE size;
1284 if ((flags & DT_EXPANDTABS))
1285 {
1286 const WCHAR *p;
1287 p = str; while (p < str+len && *p != TAB) p++;
1288 len_seg = p - str;
1289 if (len_seg != len &&
1290#ifdef _WIN32K_
1291 !GreGetTextExtentW(hdc, str, len_seg, &size, 0))
1292#else
1293 !GetTextExtentPointW(hdc, str, len_seg, &size))
1294#endif
1295 {
1296#ifdef _WIN32K_
1298#else
1299 HeapFree (GetProcessHeap(), 0, retstr);
1300#endif
1301 return 0;
1302 }
1303 }
1304 else
1305 len_seg = len;
1306#ifdef _WIN32K_
1307 if (!UserExtTextOutW( hdc, xseg, y,
1308 ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
1309 ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
1310 rect, str, len_seg))
1311#else
1312 if (!ExtTextOutW( hdc, xseg, y,
1313 ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
1314 ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
1315 rect, str, len_seg, NULL ))
1316#endif
1317 {
1318#ifdef _WIN32K_
1320#else
1321 HeapFree (GetProcessHeap(), 0, retstr);
1322#endif
1323 return 0;
1324 }
1325 if (prefix_offset != -1 && prefix_offset < len_seg)
1326 {
1327 TEXT_DrawUnderscore (hdc, xseg, y + tm.tmAscent + 1, str, prefix_offset, (flags & DT_NOCLIP) ? NULL : rect);
1328 }
1329 len -= len_seg;
1330 str += len_seg;
1331 if (len)
1332 {
1333 assert ((flags & DT_EXPANDTABS) && *str == TAB);
1334 len--; str++;
1335 xseg += ((size.cx/tabwidth)+1)*tabwidth;
1336 if (prefix_offset != -1)
1337 {
1338 if (prefix_offset < len_seg)
1339 {
1340 /* We have just drawn an underscore; we ought to
1341 * figure out where the next one is. I am going
1342 * to leave it for now until I have a better model
1343 * for the line, which will make reprefixing easier.
1344 * This is where ellip would be used.
1345 */
1346 prefix_offset = -1;
1347 }
1348 else
1349 prefix_offset -= len_seg;
1350 }
1351 }
1352 }
1353 }
1354 else if (size.cx > max_width)
1355 max_width = size.cx;
1356
1357 y += invert_y ? -lh : lh;
1358 if (dtp)
1359 dtp->uiLengthDrawn += len;
1360 }
1361 while (strPtr && !last_line);
1362
1363#ifndef _WIN32K_
1364 if (!(flags & DT_NOCLIP) )
1365 {
1366 SelectClipRgn(hdc, hrgn); // This should be NtGdiExtSelectClipRgn, but due to ReactOS build rules this option is next:
1367 GdiFlush(); // Flush the batch and level up! See CORE-16498.
1368 if (hrgn)
1369 {
1371 }
1372 }
1373#else
1374 if (!(flags & DT_NOCLIP) )
1375 {
1377 if (hrgn)
1378 {
1380 }
1381 }
1382#endif
1383
1384 if (flags & DT_CALCRECT)
1385 {
1386 rect->right = rect->left + max_width;
1387 rect->bottom = y;
1388 if (dtp)
1389 rect->right += lmargin + rmargin;
1390 }
1391 if (retstr)
1392 {
1393 memcpy (str, retstr, size_retstr);
1394#ifdef _WIN32K_
1396#else
1397 HeapFree (GetProcessHeap(), 0, retstr);
1398#endif
1399 }
1400 return y - rect->top;
1401}
1402
static HRGN hrgn
static HPEN hpen
NTSTATUS NTAPI KeUserModeCallback(IN ULONG RoutineIndex, IN PVOID Argument, IN ULONG ArgumentLength, OUT PVOID *Result, OUT PULONG ResultLength)
Definition: usercall.c:229
#define msg(x)
Definition: auth_time.c:54
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
LONG NTSTATUS
Definition: precomp.h:26
#define ERR(fmt,...)
Definition: debug.h:110
#define DBG_DEFAULT_CHANNEL(ch)
Definition: debug.h:103
COLORREF FASTCALL GreGetTextColor(HDC)
Definition: dcutil.c:80
int FASTCALL GreGetGraphicsMode(HDC)
Definition: dcutil.c:306
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define wcschr
Definition: compat.h:17
#define GetProcessHeap()
Definition: compat.h:736
#define wcsrchr
Definition: compat.h:16
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
VOID WINAPI ExitProcess(IN UINT uExitCode)
Definition: proc.c:1487
const WCHAR * text
Definition: package.c:1799
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define assert(x)
Definition: debug.h:53
#define ULONG_PTR
Definition: config.h:101
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PagedPool
Definition: env_spec_w32.h:308
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL APIENTRY GreExtTextOutW(IN HDC hDC, IN INT XStart, IN INT YStart, IN UINT fuOptions, IN OPTIONAL PRECTL lprc, IN LPCWSTR String, IN INT Count, IN OPTIONAL LPINT Dx, IN DWORD dwCodePage)
Definition: freetype.c:6543
pKey DeleteObject()
Status
Definition: gdiplustypes.h:25
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLdouble s
Definition: gl.h:2039
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
GLdouble n
Definition: glext.h:7729
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
GLint left
Definition: glext.h:7726
GLbitfield flags
Definition: glext.h:7161
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
GLuint64EXT * result
Definition: glext.h:11304
GLintptr offset
Definition: glext.h:5920
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define DbgPrint
Definition: hal.h:12
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
BOOL FASTCALL GreMoveTo(HDC hdc, INT x, INT y, LPPOINT pptOut)
Definition: line.c:108
#define e
Definition: ke_i.h:82
#define debugstr_wn
Definition: kernel32.h:33
if(dx< 0)
Definition: linetemp.h:194
unsigned int * PULONG
Definition: retypes.h:1
unsigned int ULONG
Definition: retypes.h:1
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define CLIPRGN
Definition: precomp.h:18
HDC hdc
Definition: main.c:9
static HDC
Definition: imagelist.c:92
static char * dest
Definition: rtl.c:135
unsigned int UINT
Definition: ndis.h:50
BOOL WINAPI GreGetViewportExtEx(_In_ HDC hdc, _Out_ LPSIZE lpSize)
Definition: coord.c:1416
BOOL WINAPI GreGetWindowExtEx(_In_ HDC hdc, _Out_ LPSIZE lpSize)
Definition: coord.c:1407
__kernel_entry W32KAPI HRGN APIENTRY NtGdiCreateRectRgn(_In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
__kernel_entry W32KAPI INT APIENTRY NtGdiExtSelectClipRgn(_In_ HDC hdc, _In_opt_ HRGN hrgn, _In_ INT iMode)
__kernel_entry W32KAPI INT APIENTRY NtGdiIntersectClipRect(_In_ HDC hdc, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
Definition: cliprgn.c:486
__kernel_entry W32KAPI INT APIENTRY NtGdiGetRandomRgn(_In_ HDC hdc, _In_ HRGN hrgn, _In_ INT iRgn)
__kernel_entry W32KAPI HPEN APIENTRY NtGdiCreatePen(_In_ INT iPenStyle, _In_ INT iPenWidth, _In_ COLORREF cr, _In_opt_ HBRUSH hbr)
__kernel_entry W32KAPI HPEN APIENTRY NtGdiSelectPen(_In_ HDC hdc, _In_ HPEN hpen)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiLineTo(_In_ HDC hdc, _In_ INT x, _In_ INT y)
NTSTRSAFEAPI RtlStringCchCopyNW(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cchDest, _In_reads_or_z_(cchToCopy) STRSAFE_LPCWSTR pszSrc, _In_ size_t cchToCopy)
Definition: ntstrsafe.h:363
#define L(x)
Definition: ntvdm.h:50
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define strlenW(s)
Definition: unicode.h:28
#define strrchrW(s, c)
Definition: unicode.h:35
const WCHAR * str
static __inline const char * wine_dbgstr_rect(const RECT *rect)
Definition: debug.h:219
#define TRACE(s)
Definition: solgame.cpp:4
& rect
Definition: startmenu.cpp:1413
int iRightMargin
Definition: winuser.h:3090
UINT uiLengthDrawn
Definition: winuser.h:3091
Definition: fci.c:127
Definition: parser.c:49
Definition: mxnamespace.c:45
LONG cx
Definition: windef.h:334
LONG cy
Definition: windef.h:335
Definition: time.h:68
#define max(a, b)
Definition: svc.c:63
__inline int before(__u32 seq1, __u32 seq2)
Definition: tcpcore.h:2390
int32_t INT
Definition: typedefs.h:58
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define UserEnterCo
Definition: ntuser.h:8
#define UserLeaveCo
Definition: ntuser.h:9
BOOL UserExtTextOutW(HDC hdc, INT x, INT y, UINT flags, PRECTL lprc, LPCWSTR lpString, UINT count)
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG _Out_ PULONG ResultLength
Definition: wdfdevice.h:3776
#define FORCEINLINE
Definition: wdftypes.h:67
BOOL WINAPI ExtTextOutW(_In_ HDC hdc, _In_ INT x, _In_ INT y, _In_ UINT fuOptions, _In_opt_ const RECT *lprc, _In_reads_opt_(cwc) LPCWSTR lpString, _In_ UINT cwc, _In_reads_opt_(cwc) const INT *lpDx)
Definition: text.c:492
BOOL WINAPI GetTextMetricsW(_In_ HDC hdc, _Out_ LPTEXTMETRICW lptm)
Definition: text.c:221
BOOL APIENTRY GetTextExtentPointW(_In_ HDC hdc, _In_reads_(cchString) LPCWSTR lpString, _In_ INT cchString, _Out_ LPSIZE lpsz)
Definition: text.c:268
BOOL WINAPI GetTextExtentExPointW(_In_ HDC hdc, _In_reads_(cchString) LPCWSTR lpszString, _In_ INT cchString, _In_ INT nMaxExtent, _Out_opt_ LPINT lpnFit, _Out_writes_to_opt_(cchString, *lpnFit) LPINT lpnDx, _Out_ LPSIZE lpSize)
Definition: text.c:283
COLORREF WINAPI GetTextColor(_In_ HDC hdc)
Definition: text.c:861
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1158
BOOL FASTCALL GreGetTextExtentW(HDC hDC, LPCWSTR lpwsz, INT cwc, LPSIZE psize, UINT flOpts)
Definition: text.c:78
BOOL FASTCALL GreGetTextExtentExW(HDC hDC, LPCWSTR String, ULONG Count, ULONG MaxExtent, PULONG Fit, PULONG Dx, LPSIZE pSize, FLONG fl)
Definition: text.c:135
BOOL WINAPI GreGetTextMetricsW(_In_ HDC hdc, _Out_ LPTEXTMETRICW lptm)
Definition: text.c:193
struct _LPK_CALLBACK_ARGUMENTS LPK_CALLBACK_ARGUMENTS
#define USER32_CALLBACK_LPK
Definition: callback.h:20
PVOID FASTCALL IntCbAllocateMemory(ULONG Size)
Definition: callback.c:27
VOID FASTCALL IntCbFreeMemory(PVOID Data)
Definition: callback.c:50
#define USERTAG_RTL
Definition: tags.h:270
void _font_assert(const char *msg, const char *file, int line)
Definition: text.c:54
#define MAX_BUFFER
Definition: text.c:1065
static void TEXT_DrawUnderscore(HDC hdc, int x, int y, const WCHAR *str, int offset, const RECT *rect)
Definition: text.c:894
#define BACK_SLASH
Definition: text.c:118
#define LF
Definition: text.c:110
static int remainder_is_none_or_newline(int num_chars, const WCHAR *str)
Definition: text.c:626
#define KANA_PREFIX
Definition: text.c:115
#define SPACE
Definition: text.c:112
struct tag_ellipsis_data ellipsis_data
static const WCHAR * TEXT_NextLineW(HDC hdc, const WCHAR *str, int *count, WCHAR *dest, int *len, int width, DWORD format, SIZE *retsize, int last_line, WCHAR **p_retstr, int tabwidth, int *pprefix_offset, ellipsis_data *pellip)
Definition: text.c:666
static void TEXT_Ellipsify(HDC hdc, WCHAR *str, unsigned int max_len, unsigned int *len_str, int width, SIZE *size, WCHAR *modstr, int *len_before, int *len_ellip)
Definition: text.c:159
FORCEINLINE BOOL IsCJKT(WCHAR wch)
Definition: text.c:335
#define CR
Definition: text.c:111
static const WCHAR KinsokuClassA[]
Definition: text.c:353
INT WINAPI DrawTextExWorker(HDC hdc, LPWSTR str, INT i_count, LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp)
Definition: text.c:1071
#define ALPHA_PREFIX
Definition: text.c:114
static int TEXT_Reprefix(const WCHAR *str, unsigned int ns, const ellipsis_data *pe)
Definition: text.c:588
static void TEXT_PathEllipsify(HDC hdc, WCHAR *str, unsigned int max_len, unsigned int *len_str, int width, SIZE *size, WCHAR *modstr, ellipsis_data *pellip)
Definition: text.c:265
#define FORWARD_SLASH
Definition: text.c:117
static void TEXT_WordBreak(HDC hdc, WCHAR *str, unsigned int max_str, unsigned int *len_str, int width, int format, unsigned int chars_fit, unsigned int *chars_used, SIZE *size)
Definition: text.c:426
#define TAB
Definition: text.c:109
#define PREFIX
Definition: text.c:113
static const WCHAR ELLIPSISW[]
Definition: text.c:120
static void TEXT_SkipChars(int *new_count, const WCHAR **new_str, int start_count, const WCHAR *start_str, int max, int n, int prefix)
Definition: text.c:540
BOOL * LPBOOL
Definition: windef.h:162
#define WINAPI
Definition: msvc.h:6
#define GM_COMPATIBLE
Definition: wingdi.h:864
HRGN WINAPI CreateRectRgn(_In_ int, _In_ int, _In_ int, _In_ int)
int WINAPI GetGraphicsMode(_In_ HDC)
int WINAPI IntersectClipRect(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1539
BOOL WINAPI GdiFlush(void)
Definition: misc.c:44
BOOL WINAPI MoveToEx(_In_ HDC, _In_ int, _In_ int, _Out_opt_ LPPOINT)
int WINAPI GetClipRgn(_In_ HDC, _In_ HRGN)
#define RGN_COPY
Definition: wingdi.h:357
#define ETO_CLIPPED
Definition: wingdi.h:648
BOOL WINAPI GetWindowExtEx(_In_ HDC, _Out_ LPSIZE)
Definition: coord.c:411
BOOL WINAPI GetViewportExtEx(_In_ HDC, _Out_ LPSIZE)
Definition: coord.c:351
HPEN WINAPI CreatePen(_In_ int, _In_ int, _In_ COLORREF)
int WINAPI SelectClipRgn(_In_ HDC, _In_opt_ HRGN)
BOOL WINAPI LineTo(_In_ HDC, _In_ int, _In_ int)
#define PS_SOLID
Definition: wingdi.h:586
#define DT_NOPREFIX
Definition: winuser.h:537
#define DT_EXTERNALLEADING
Definition: winuser.h:533
#define DT_CENTER
Definition: winuser.h:527
#define DT_END_ELLIPSIS
Definition: winuser.h:529
#define DT_SINGLELINE
Definition: winuser.h:540
#define DT_TABSTOP
Definition: winuser.h:541
#define DT_NOCLIP
Definition: winuser.h:536
#define DT_RTLREADING
Definition: winuser.h:539
#define DT_MODIFYSTRING
Definition: winuser.h:535
#define DT_WORDBREAK
Definition: winuser.h:544
#define DT_VCENTER
Definition: winuser.h:543
#define DT_BOTTOM
Definition: winuser.h:525
_In_ int _Inout_ LPRECT lprc
Definition: winuser.h:4456
#define DT_WORD_ELLIPSIS
Definition: winuser.h:531
#define DT_RIGHT
Definition: winuser.h:538
#define DT_EXPANDTABS
Definition: winuser.h:532
#define DT_CALCRECT
Definition: winuser.h:526
#define DT_EDITCONTROL
Definition: winuser.h:528
#define DT_PATH_ELLIPSIS
Definition: winuser.h:530
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185