DrawText rewrite

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



 <<diff40.txt>> 
Bill Medland (medbi01@accpac.com)
Major rewrite of the DrawText functions which should provide a reasonable
base for further development.  It includes improved handling of tabs and
ellipses.

Index: wine/dlls/user/text.c
===================================================================
RCS file: /home/wine/wine/dlls/user/text.c,v
retrieving revision 1.16
diff -u -r1.16 text.c
--- wine/dlls/user/text.c	2002/01/04 21:26:56	1.16
+++ wine/dlls/user/text.c	2002/01/07 19:54:46
@@ -6,6 +6,7 @@
  */
 
 #include <string.h>
+#include <assert.h>
 
 #include "windef.h"
 #include "wingdi.h"
@@ -25,249 +26,706 @@
 #define SPACE  32
 #define PREFIX 38
 
-#define ELLIPSIS "..."
 #define FORWARD_SLASH '/'
 #define BACK_SLASH '\\'
 
-static const WCHAR SPACEW[] = {' ', 0};
-static const WCHAR oW[] = {'o', 0};
 static const WCHAR ELLIPSISW[] = {'.','.','.', 0};
-static const WCHAR FORWARD_SLASHW[] = {'/', 0};
-static const WCHAR BACK_SLASHW[] = {'\\', 0};
 
-#define SWAP_INT(a,b)  { int t = a; a = b; b = t; }
+#define countof(a) (sizeof(a)/sizeof(a[0]))
 
-static int tabstop = 8;
-static int tabwidth;
-static int spacewidth;
-static int prefix_offset;
+/* A structure to describe a segment or portion of a line, to simplify handling
+ * of tabs.  This ensures that the we don't keep parsing the line.
+ */
+typedef struct tab_sDrawTextLineSegment
+{
+    WCHAR *str;		// Where the segment is stored
+    int nChar;		// The number of characters in the segment
+    int xStart;		// The offset of the string in logical coordinates
+                        // from the line's origin
+} sDrawTextLineSegment;
 
-/* ### start build ### */
-extern WORD CALLBACK TEXT_CallTo16_word_wlw(GRAYSTRINGPROC16,WORD,LONG,WORD);
-/* ### stop build ### */
+/* A structure to pass information between the functions of the DrawText
+ * processing.  in/out refers to passing to the "next line" function.
+ */
+typedef struct tab_sDrawTextLine
+{
+    HDC hdc;		// [in] The handle to the Device Context to use
+    int tabwidth;	// [in] The width in logical units of a tab column
+    int max_width;      // [in] Maximum width in logical coordinates
+    const WCHAR *str;   // [in/out] The pointer to the remainder of the string
+                        //          to be processed.
+    int count;          // [in/out] The number of characters remaining in the
+                        //          string. (Strictly, the number of WCHAR's 
+                        //          which, according to MSDN, may include some
+                        //          Unicode surrogates in two WCHARs)
+    UINT format;        // [in] The format flags bitset passed to the DrawText
+                        //      (or similar) function
+    int last_line;      // [in] Set TRUE if this is the last line for which
+                        //      there is room as far as ellipsification is
+                        //      concerned.  Note that this may be FALSE and yet
+                        //      no further line will be output.
+    int buflen;         // [in] The number of WCHARs in buffer
+    WCHAR *buffer;      // [in*out] A buffer provided by the caller into which
+                        //          the callee transfers the string, possibly
+                        //          including modifications.
+    sDrawTextLineSegment *seg;	// [in*out] An array to receive the line
+                                // segments
+    int max_segs;       // [in] The number of entries in the seg[] array
+    int num_segs;       // [out] The number of entries used in the seg[] array
+    int prefix_segment; // [out] The segment number containing the prefixed
+                        //       character to be underlined; < 0 if none
+    int prefix_offset;  // [out] Which character of the segment (see prefix_
+                        //       segment) should be underlined.
+    SIZE size;          // [out] Actual size of the line (for centring etc)
+    int total_chars;    // [out] Total of the seg->nChars;
+} sDrawTextLine;
 
-struct gray_string_info
+/*********************************************************************
+ *                      TEXT_Ellipsify (static)
+ *
+ *  Add an ellipsis to the end of the given string whilst ensuring it fits.
+ *
+ * If the ellipsis alone doesn't fit then it will be returned anyway.
+ *
+ * Arguments
+ *   hdc        [in] The handle to the DC that defines the font.
+ *   str        [in/out] The string that needs to be modified
+ *   max_str    [in] The dimension of str (number of WCHAR).
+ *   len_str    [in/out] The number of characters in str
+ *   width      [in] The maximum width permitted (in logical coordinates)
+ *   size       [out] The dimensions of the text
+ *
+ * See for example Microsoft article Q249678.
+ *
+ * For now we will simply use three dots rather than worrying about whether
+ * the font contains an explicit ellipsis character.
+ */
+static void TEXT_Ellipsify (HDC hdc, WCHAR *str, unsigned int max_len,
+                            unsigned int *len_str, int width, SIZE *size)
 {
-    GRAYSTRINGPROC16 proc;
-    LPARAM           param;
-};
+    unsigned int len_ellipsis;
 
-/* callback for 16-bit gray string proc */
-static BOOL CALLBACK gray_string_callback( HDC hdc, LPARAM param, INT len )
+    len_ellipsis = strlenW (ELLIPSISW);
+    if (len_ellipsis > max_len) len_ellipsis = max_len;
+    if (*len_str > max_len - len_ellipsis)
+        *len_str = max_len - len_ellipsis;
+
+    for ( ; ; )
+    {
+        strncpyW (str + *len_str, ELLIPSISW, len_ellipsis);
+
+        if (!GetTextExtentExPointW (hdc, str, *len_str + len_ellipsis, width,
+                                    NULL, NULL, size)) break;
+
+        if (!*len_str || size->cx <= width) break;
+
+        (*len_str)--;
+    }
+    *len_str += len_ellipsis;
+}
+
+/*********************************************************************
+ *                      TEXT_PathElllipsify (static)
+ *
+ * Add an ellipsis to the provided string in order to make it fit within
+ * the width.  The ellipsis is added as specified for the DT_PATH_ELLIPSIS
+ * flag.
+ *
+ * See Also TEXT_Ellipsify
+ *
+ * Arguments
+ *   hdc        [in] The handle to the DC that defines the font.
+ *   str        [in/out] The string that needs to be modified
+ *   max_str    [in] The dimension of str (number of WCHAR).
+ *   len_str    [in/out] The number of characters in str
+ *   width      [in] The maximum width permitted (in logical coordinates)
+ *   size       [out] The dimensions of the text
+ *
+ * For now we will simply use three dots rather than worrying about whether
+ * the font contains an explicit ellipsis character.
+ *
+ * The resulting string consists of as much as possible of the following:
+ * 1. The ellipsis itself
+ * 2. The last \ or / of the string (if any)
+ * 3. Everything after the last \ or / of the string (if any) or the whole
+ *    string if there is no / or \.
+ * 4. All the stuff before the / or \, which is placed before the ellipsis.
+ */
+static void TEXT_PathEllipsify (HDC hdc, WCHAR *str, unsigned int max_len,
+                                unsigned int *len_str, int width, SIZE *size)
 {
-    const struct gray_string_info *info = (struct gray_string_info *)param;
-    return TEXT_CallTo16_word_wlw( info->proc, hdc, info->param, len );
+    int len_ellipsis;
+    int len_trailing;
+    WCHAR *lastBkSlash, *lastFwdSlash, *lastSlash;
+
+    len_ellipsis = strlenW (ELLIPSISW);
+    if (!max_len) return;
+    if (len_ellipsis >= max_len) len_ellipsis = max_len - 1;
+    if (*len_str + len_ellipsis >= max_len)
+        *len_str = max_len - len_ellipsis-1;
+        /* Hopefully this will never happen, otherwise it would probably lose
+         * the wrong character
+         */
+    str[*len_str] = '\0'; /* to simplify things */
+
+    lastBkSlash  = strrchrW (str, BACK_SLASH);
+    lastFwdSlash = strrchrW (str, FORWARD_SLASH);
+    lastSlash = lastBkSlash > lastFwdSlash ? lastBkSlash : lastFwdSlash;
+    if (!lastSlash) lastSlash = str;
+    len_trailing = *len_str - (lastSlash - str);
+
+    /* overlap-safe movement to the right */
+    memmove (lastSlash+len_ellipsis, lastSlash, len_trailing * sizeof(WCHAR));
+    strncpyW (lastSlash, ELLIPSISW, len_ellipsis);
+    len_trailing += len_ellipsis;
+    /* From this point on lastSlash actually points to the ellipsis in front
+     * of the last slash and len_trailing includes the ellipsis
+     */
+
+    for ( ; ; )
+    {
+        if (!GetTextExtentExPointW (hdc, str, *len_str + len_ellipsis, width,
+                                    NULL, NULL, size)) break;
+
+        if (lastSlash == str || size->cx <= width) break;
+
+        /* overlap-safe movement to the left */
+        memmove (lastSlash-1, lastSlash, len_trailing * sizeof(WCHAR));
+        lastSlash--;
+        
+        assert (*len_str);
+        (*len_str)--;
+    }
+    *len_str += len_ellipsis;
 }
 
+/*********************************************************************
+ *                      TEXT_WordBreak (static)
+ *
+ *  Perform wordbreak processing on the given string
+ *
+ * Assumes that DT_WORDBREAK has been specified and not all the characters
+ * fit.
+ *
+ * Note that the Windows processing has some strange properties.  In particular
+ * leading and trailing spaces are not stripped except for the first space of a
+ * line created by a wordbreak.
+ *
+ * Arguments
+ *   hdc        [in] The handle to the DC that defines the font.
+ *   str        [in/out] The string that needs to be broken.
+ *   max_str    [in] The dimension of str (number of WCHAR).
+ *   len_str    [in/out] The number of characters in str
+ *   width      [in] The maximum width permitted
+ *   format     [in] The format flags in effect
+ *   chars_fit  [in] The maximum number of characters of str that are already
+ *              known to fit; chars_fit+1 is known not to fit.
+ *   chars_used [out] The number of characters of str that have been "used" and
+ *              do not need to be included in later text.  For example this will
+ *              include any spaces that have been discarded from the start of 
+ *              the next line.
+ *   size       [out] The size of the returned text in logical coordinates
+ *
+ * Pedantic assumption - Assumes that the text length is montonically increasing
+ * with number of characters (i.e. no weird kernings)
+ *
+ * Algorithm
+ * 
+ * Work back from the last character that did fit to either a space or the last
+ * character of a word, whichever is met first.
+ * If there was one or the first character didn't fit then
+ *     break the line after that character
+ *     and if the next character is a space then discard it.
+ * Suppose there was none (and the first character did fit).
+ *     If Break Within Word is permitted
+ *         break the word after the last character that fits (there must be
+ *         at least one; none is caught earlier).
+ *     Otherwise
+ *         discard any trailing space.
+ *         include the whole word; it may be ellipsified later
+ *
+ * Break Within Word is permitted under a set of circumstances that are not
+ * totally clear yet.  Currently our best guess is:
+ *     If DT_EDITCONTROL is in effect and neither DT_WORD_ELLIPSIS nor
+ *     DT_PATH_ELLIPSIS is
+ */
 
+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)
+{
+    WCHAR *p;
+    int word_fits;
+    assert (format & DT_WORDBREAK);
+    assert (chars_fit < *len_str);
+
+    /* Work back from the last character that did fit to either a space or the
+     * last character of a word, whichever is met first.
+     */
+    p = str + chars_fit;
+    word_fits = TRUE;
+    if (!chars_fit)
+        ; /* we pretend that it fits anyway */
+    else if (*p == SPACE) /* chars_fit < *len_str so this is valid */
+        p--; /* the word just fitted */
+    else
+    {
+        while (p > str && *(--p) != SPACE)
+            ;
+        word_fits = (p != str || *p == SPACE);
+    }
+    /* If there was one or the first character didn't fit then */
+    if (word_fits)
+    {
+        /* break the line after that character */
+        p++;
+        *len_str = p - str;
+        /* and if the next character is a space then discard it. */
+        *chars_used = *len_str;
+        if (*p == SPACE)
+            (*chars_used)++;
+    }
+    /* Suppose there was none. */
+    else
+    {
+        /* If DT_EDITCONTROL is in effect and DT_WORD_ELLIPSIS is not then */
+        if ((format & (DT_EDITCONTROL | DT_WORD_ELLIPSIS | DT_PATH_ELLIPSIS)) ==
+            DT_EDITCONTROL)
+        {
+            /* break the word after the last character that fits (there must be
+             * at least one; none is caught earlier).
+             */
+            *len_str = chars_fit;
+            *chars_used = chars_fit;
+
+            /* FIXME - possible error.  Since the next character is now removed
+             * this could make the text longer so that it no longer fits, and
+             * so we need a loop to test and shrink.
+             */
+        }
+        /* Otherwise */
+        else
+        {
+            /* discard any trailing space. */
+            const WCHAR *e = str + *len_str;
+            p = str + chars_fit;
+            while (p < e && *p != SPACE)
+                p++;
+            *chars_used = p - str;
+            if (p < e) /* i.e. loop failed because *p == SPACE */
+                (*chars_used)++;
+
+            /* include the whole word; it may be ellipsified later */
+            *len_str = p - str;
+            /* Possible optimisation; if DT_WORD_ELLIPSIS only use chars_fit+1
+             * so that it will be too long
+             */
+        }
+    }
+    /* Remeasure the string */
+    GetTextExtentExPointW (hdc, str, *len_str, 0, NULL, NULL, size);
+}
+
+/*********************************************************************
+ *                      TEXT_SkipChars
+ *
+ *  Skip over the given number of characters, bearing in mind prefix
+ *  substitution and the fact that a character may take more than one
+ *  WCHAR (Unicode surrogates are two words long) (and there may have been
+ *  a trailing &)
+ *
+ * Parameters
+ *   new_str    [out] The updated pointer
+ *   new_count  [out] The updated count
+ *   start_count [in] The count of remaining characters corresponding to the
+ *                    start of the string
+ *   start_str  [in] The starting point of the string
+ *   max        [in] The number of characters actually in this segment of the
+ *                   string (the & counts)
+ *   n          [in] The number of characters to skip (if prefix then
+ *                   &c counts as one)
+ *   prefix     [in] Apply prefix substitution
+ *
+ * Return Values
+ *   none
+ *
+ * Remarks
+ *   There must be at least n characters in the string
+ *   We need max because the "line" may have ended with a & followed by a tab
+ *   or newline etc. which we don't want to swallow
+ */
+
+static void TEXT_SkipChars (const WCHAR **new_str, int *new_count,
+                            int start_count, const WCHAR *start_str,
+                            int max, int n, int prefix)
+{
+    /* This is specific to wide characters, MSDN doesn't say anything much
+     * about Unicode surrogates yet and it isn't clear if _wcsinc will
+     * correctly handle them so we'll just do this the easy way for now
+     */
+
+    if (prefix)
+    {
+        const WCHAR *str_on_entry = start_str;
+        assert (max >= n);
+        max -= n;
+        while (n--)
+            if (*start_str++ == PREFIX && max--)
+                start_str++;
+            else;
+        start_count -= (start_str - str_on_entry);
+    }
+    else
+    {
+        start_str += n;
+        start_count -= n;
+    }
+    *new_str = start_str;
+    *new_count = start_count;
+}
+  
 /*********************************************************************
+ *                      TEXT_Reprefix
+ *
+ *  Reanalyse the text to find the prefixed character.  This is called when
+ *  wordbreaking or ellipsification has shortened the string such that the
+ *  previously noted prefixed character is no longer visible.
+ *
+ * Parameters
+ *   str        [in] The original string segment (including all characters)
+ *   n1         [in] The number of characters visible before the path ellipsis
+ *   n2         [in] The number of characters replaced by the path ellipsis
+ *   ne         [in] The number of characters in the path ellipsis, ignored if
+ *              n2 is zero
+ *   n3         [in] The number of characters visible after the path ellipsis
+ *
+ * Return Values
+ *   The prefix offset within the new string segment (the one that contains the
+ *   ellipses and does not contain the prefix characters) (-1 if none)
+ *
+ * Remarks
+ *   We know that n1+n2+n3 must be strictly less than the length of the segment
+ *   (because otherwise there would be no need to call this function)
+ */
+
+static int TEXT_Reprefix (const WCHAR *str, unsigned int n1, unsigned int n2,
+                          unsigned int ne, unsigned int n3)
+{
+    int result = -1;
+    unsigned int i = 0;
+    unsigned int n = n1 + n2 + n3;
+    if (!n2) ne = 0;
+    while (i < n)
+    {
+        if (i == n1)
+        {
+            /* Reached the path ellipsis; jump over it */
+            str += n2;
+            i += n2;
+            if (!n3) break; /* Nothing after the path ellipsis */
+        }
+        if (*str++ == PREFIX)
+        {
+            result = (i < n1) ? i : i - n2 + ne;
+            str++;
+        }
+        else;
+        i++;
+    }
+    return result;
+}
+  
+/*********************************************************************
+ *  Returns true if and only if the remainder of the line is a single 
+ *  newline representation or nothing
+ */
+
+static int remainder_is_none_or_newline (int num_chars, const WCHAR *str)
+{
+    if (!num_chars) return TRUE;
+    if (*str != LF && *str != CR) return FALSE;
+    if (!--num_chars) return TRUE;
+    if (*str == *(str+1)) return FALSE;
+    str++;
+    if (*str != CR && *str != LF) return FALSE;
+    if (--num_chars) return FALSE;
+    return TRUE;
+}
+
+/*********************************************************************
+ *                      TEXT_NextLineW
+ *
  *  Return next line of text from a string.
- * 
- * hdc - handle to DC.
- * str - string to parse into lines.
- * count - length of str.
- * dest - destination in which to return line.
- * len - dest buffer size in chars on input, copied length into dest on output.
- * width - maximum width of line in pixels.
- * format - format type passed to DrawText.
- *
- * Returns pointer to next char in str after end of the line
- * or NULL if end of str reached.
- *
- * FIXME:
- * GetTextExtentPoint is used to get the width of each character, 
- * rather than GetCharABCWidth...  So the whitespace between
- * characters is ignored, and the reported len is too great.
- */
-static const WCHAR *TEXT_NextLineW( HDC hdc, const WCHAR *str, int *count,
-                                  WCHAR *dest, int *len, int width, WORD format)
-{
-    int i = 0, j = 0, k;
-    int plen = 0;
-    int numspaces;
+ *
+ * Use GetTextExtentExPoint so that we don't need to think about how to measure
+ * the text
+ */
+static void TEXT_NextLineW (sDrawTextLine *line)
+{
+    WCHAR *pdest;
+    const WCHAR *pEndBuf;
+    int x_so_far;
+    sDrawTextLineSegment *pseg;
+    int num_chars;
     SIZE size;
-    int lasttab = 0;
-    int wb_i = 0, wb_j = 0, wb_count = 0;
-    int maxl = *len;
+    int max_seg_width;
+    int ellipsified;
+    int line_fits;
+
+    line->prefix_segment = -1;
+    line->num_segs = 0;
+    line->total_chars = 0;
+    line->size.cx = 0;
+    line->size.cy = 0;
+    pdest = line->buffer;
+    x_so_far = 0;
+    pseg = line->seg;
+    pEndBuf = pdest + line->buflen;
 
-    while (*count && j < maxl)
+    /* For each line segment */
+    while (line->count) /* and several break statements at the bottom */
     {
-	switch (str[i])
-	{
-	case CR:
-	case LF:
-	    if (!(format & DT_SINGLELINE))
-	    {
-		if ((*count > 1) && (str[i] == CR) && (str[i+1] == LF))
+        int len_before_ellipsis;
+        int prefix_offset;
+        int word_broken;
+        int seg_start_count;
+        const WCHAR *seg_start_str;
+
+        word_broken = FALSE;
+        /* Skip leading tabs */
+        if (line->count && *line->str == TAB && (line->format & DT_EXPANDTABS))
+        {
+            /* optimised to reduce unnecessary division */
+            x_so_far = ((x_so_far/line->tabwidth)+1)*line->tabwidth; /* Skip TO tab */
+            line->count--, line->str++;
+            while (line->count && *line->str == TAB)
+            {
+                line->count--, line->str++;
+                x_so_far += line->tabwidth; /* Skip BY tab */
+            }
+        }
+
+        seg_start_count = line->count;
+        seg_start_str = line->str;
+
+        /* Set up the segment */
+        if (line->num_segs >= line->max_segs)
+        {
+            FIXME ("Need to handle more line segments\n");
+            break;
+        }
+        pseg->str = pdest;
+        pseg->xStart = x_so_far;
+        prefix_offset = -1;
+
+        /* Copy the string to the buffer with prefix substitution */
+        while (line->count)
+        {
+            if (*line->str == TAB && (line->format & DT_EXPANDTABS))
+                break;
+            else if ((*line->str == CR || *line->str == LF) && !(line->format & DT_SINGLELINE))
+                break;
+            else
+            {
+                --line->count;
+                if (*line->str == PREFIX && !(line->format & DT_NOPREFIX))
                 {
-		    (*count)--;
-                    i++;
+                    line->str++;
+                    prefix_offset = pdest - pseg->str;
+                    /* Win95.  If there is no next char or it  is an effective
+                     * CR, LF or TAB then it still overrides the previous one.
+                     */
                 }
-		i++;
-		*len = j;
-		(*count)--;
-		return (&str[i]);
-	    }
-	    dest[j++] = str[i++];
-	    if (!(format & DT_NOCLIP) || !(format & DT_NOPREFIX) ||
-		(format & DT_WORDBREAK))
-	    {
-		if (!GetTextExtentPointW(hdc, &dest[j-1], 1, &size))
-		    return NULL;
-		plen += size.cx;
-	    }
-	    break;
-	    
-	case PREFIX:
-	    if (!(format & DT_NOPREFIX) && *count > 1)
+                else if (pdest < pEndBuf)
+                    *pdest++ = *line->str++;
+                else
                 {
-                if (str[++i] == PREFIX)
-		    (*count)--;
-		else {
-                    prefix_offset = j;
-                    break;
+                    FIXME ("Buffer overflow\n");
+                    return;
                 }
-	    }
-            dest[j++] = str[i++];
-            if (!(format & DT_NOCLIP) || !(format & DT_NOPREFIX) ||
-                (format & DT_WORDBREAK))
-            {
-                if (!GetTextExtentPointW(hdc, &dest[j-1], 1, &size))
-                    return NULL;
-                plen += size.cx;
             }
-	    break;
-	    
-	case TAB:
-	    if (format & DT_EXPANDTABS)
-	    {
-		wb_i = ++i;
-		wb_j = j;
-		wb_count = *count;
-
-		if (!GetTextExtentPointW(hdc, &dest[lasttab], j - lasttab, &size))
-		    return NULL;
-
-		numspaces = (tabwidth - size.cx) / spacewidth;
-		for (k = 0; k < numspaces; k++)
-		    dest[j++] = SPACE;
-		plen += tabwidth - size.cx;
-		lasttab = wb_j + numspaces;
-	    }
-	    else
-	    {
-		dest[j++] = str[i++];
-		if (!(format & DT_NOCLIP) || !(format & DT_NOPREFIX) ||
-		    (format & DT_WORDBREAK))
-		{
-		    if (!GetTextExtentPointW(hdc, &dest[j-1], 1, &size))
-			return NULL;
-		    plen += size.cx;
-		}
-	    }
-	    break;
-
-	case SPACE:
-	    dest[j++] = str[i++];
-	    if (!(format & DT_NOCLIP) || !(format & DT_NOPREFIX) ||
-		(format & DT_WORDBREAK))
-	    {
-		wb_i = i;
-		wb_j = j - 1;
-		wb_count = *count;
-		if (!GetTextExtentPointW(hdc, &dest[j-1], 1, &size))
-		    return NULL;
-		plen += size.cx;
-	    }
-	    break;
-
-	default:
-	    dest[j++] = str[i++];
-	    if (!(format & DT_NOCLIP) || !(format & DT_NOPREFIX) ||
-		(format & DT_WORDBREAK))
-	    {
-		if (!GetTextExtentPointW(hdc, &dest[j-1], 1, &size))
-		    return NULL;
-		plen += size.cx;
-	    }
-	}
-
-	(*count)--;
-	if (!(format & DT_NOCLIP) || (format & DT_WORDBREAK))
-	{
-	    if (plen > width)
-	    {
-		if (format & DT_WORDBREAK)
-		{
-		    if (wb_j)
-		    {
-			*len = wb_j;
-			*count = wb_count - 1;
-			return (&str[wb_i]);
-		    }
-		}
-		else
-		{
-		    *len = j;
-		    return (&str[i]);
-		}
-	    }
-	}
+        }
+        /* Beware. pprefix_offset may be beyond the string */
+        pseg->nChar = pdest - pseg->str;
+
+        /* What if nChars is zero */
+        /* Measure the segment */
+        max_seg_width = line->max_width - x_so_far;
+        GetTextExtentExPointW (line->hdc, pseg->str, pseg->nChar, max_seg_width,
+                               &num_chars, NULL, &size);
+
+        /* Perform word break and ellipsification */
+
+        /* The Microsoft handling of various combinations of formats is wierd.
+         * The following may very easily be incorrect if several formats are
+         * combined.
+         */
+        ellipsified = FALSE;
+        line_fits = (num_chars >= pseg->nChar);
+        if ((line->format & DT_WORDBREAK) && !line_fits)
+        {
+            int chars_used;
+            TEXT_WordBreak (line->hdc, pseg->str, pEndBuf-pseg->str,
+                            &pseg->nChar, max_seg_width, line->format, 
+                            num_chars, &chars_used, &size);
+            line_fits = (size.cx <= max_seg_width);
+            /* So now we need to recorrect the line->str etc. and prefix */
+            pdest = pseg->str + pseg->nChar;
+            TEXT_SkipChars (&line->str, &line->count,
+                            seg_start_count,  seg_start_str,
+                            line->str - seg_start_str, chars_used,
+                            !(line->format & DT_NOPREFIX));
+            /* potential optimisation; only if there were any PREFIX */
+
+            word_broken = TRUE;
+        }
+        if ((line->format & DT_PATH_ELLIPSIS) && !line_fits)
+        {
+            TEXT_PathEllipsify (line->hdc, pseg->str, pEndBuf-pseg->str,
+                                &pseg->nChar, max_seg_width, &size);
+            line_fits = (size.cx <= max_seg_width);
+        }
+        if ((line->format & DT_WORD_ELLIPSIS) && !line_fits)
+        {
+            ellipsified = TRUE;
+            TEXT_Ellipsify (line->hdc, pseg->str, pEndBuf-pseg->str,
+                            &pseg->nChar, max_seg_width, &size);
+            line_fits = (size.cx <= max_seg_width);
+        }
+        /* NB we may end up ellipsifying a word-broken string */
+        if ((line->format & DT_END_ELLIPSIS) && !ellipsified &&
+            ((line->last_line && line->count) ||
+             (remainder_is_none_or_newline (line->count, line->str) &&
+              !line_fits)))
+             
+        {
+            ellipsified = TRUE;
+            TEXT_Ellipsify (line->hdc, pseg->str, pEndBuf-pseg->str,
+                            &pseg->nChar, max_seg_width, &size);
+        }
+        len_before_ellipsis = pseg->nChar;
+        if (ellipsified) len_before_ellipsis -= strlenW (ELLIPSISW);
+        if (prefix_offset >= len_before_ellipsis)
+            prefix_offset = TEXT_Reprefix (seg_start_str, len_before_ellipsis, 0, 3, 0);
+
+        x_so_far += size.cx;
+        line->total_chars += pseg->nChar;
+        if (size.cy > line->size.cy) line->size.cy = size.cy;
+
+        if (prefix_offset >= 0)
+        {
+            line->prefix_segment = line->num_segs;
+            line->prefix_offset = prefix_offset;
+        }
+
+        /* See if that was the last segment of the line */
+        line->num_segs++;
+        pseg++;
+
+        if (word_broken)
+            break;
+        else if (!line->count)
+            break; /* end of the input string */
+        else if (*line->str == CR)
+        {
+            line->count--, line->str++;
+            if (line->count && *line->str == LF)
+                line->count--, line->str++;
+            break;
+        }
+        else if (*line->str == LF)
+        {
+            line->count--, line->str++;
+            if (line->count && *line->str == CR)
+                line->count--, line->str++;
+            break;
+        }
+        /* Else it was a Tab and we go around again */
     }
-    
-    *len = j;
-    return NULL;
+    line->size.cx = x_so_far;
 }
 
 
 /***********************************************************************
- *           DrawText    (USER.85)
+ *                      TEXT_DrawUnderscore
+ *
+ *  Draw the underline under the prefixed character
+ *
+ * Parameters
+ *   hdc        [in] The handle of the DC for drawing
+ *   x          [in] The x location of the line segment (logical coordinates)
+ *   y          [in] The y location of where the underscore should appear
+ *                   (logical coordinates)
+ *   str        [in] The text of the line segment
+ *   offset     [in] The offset of the underscored character within str
  */
-INT16 WINAPI DrawText16( HDC16 hdc, LPCSTR str, INT16 count, LPRECT16 rect, UINT16 flags )
+
+static void TEXT_DrawUnderscore (HDC hdc, int x, int y, const WCHAR *str, int offset)
 {
-    INT16 ret;
+    int prefix_x;
+    int prefix_end;
+    SIZE size;
+    HPEN hpen;
+    HPEN oldPen;
 
-    if (rect)
-    {
-        RECT rect32;
-        CONV_RECT16TO32( rect, &rect32 );
-        ret = DrawTextA( hdc, str, count, &rect32, flags );
-        CONV_RECT32TO16( &rect32, rect );
-    }
-    else ret = DrawTextA( hdc, str, count, NULL, flags);
-    return ret;
+    GetTextExtentPointW (hdc, str, offset, &size);
+    prefix_x = x + size.cx;
+    GetTextExtentPointW (hdc, str, offset+1, &size);
+    prefix_end = x + size.cx - 1;
+    /* The above method may eventually be slightly wrong due to kerning etc. */
+
+    hpen = CreatePen (PS_SOLID, 1, GetTextColor (hdc));
+    oldPen = SelectObject (hdc, hpen);
+    MoveToEx (hdc, prefix_x, y, NULL);
+    LineTo (hdc, prefix_end, y);
+    SelectObject (hdc, oldPen);
+    DeleteObject (hpen);
 }
 
-
 /***********************************************************************
- *           DrawTextExW    (USER32.@)
+ * TEXT_DrawTextW
+ *
+ * The core of the DrawText/DrawTextEx functions.
+ *
+ * Parameters
+ *
+ * The parameters are as for DrawText or DrawTextEx, except for fEx.
+ *
+ * fEx 0 if called from one of the DrawText functions and non-0 if called from
+ *     one of the DrawTextEx functions.
  */
 #define MAX_STATIC_BUFFER 1024
-INT WINAPI DrawTextExW( HDC hdc, LPWSTR str, INT i_count,
-                        LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp )
+#define MAX_LINE_SEGS 256
+static INT WINAPI TEXT_DrawTextW (HDC hdc, LPWSTR str, INT count,
+                                  LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp,
+                                  int fEx)
 {
-    SIZE size;
-    const WCHAR *strPtr;
-    static WCHAR line[MAX_STATIC_BUFFER];
-    int len, lh, count=i_count;
-    int prefix_x = 0;
-    int prefix_end = 0;
+    /* Why are we using static buffers anyway? */
+    static WCHAR line_buffer[MAX_STATIC_BUFFER];
+    static sDrawTextLineSegment seg_buffer [MAX_LINE_SEGS];
+    int lh;
     TEXTMETRICW tm;
     int lmargin = 0, rmargin = 0;
     int x = rect->left, y = rect->top;
-    int width = rect->right - rect->left;
     int max_width = 0;
+    sDrawTextLine line;
 
     TRACE("%s, %d , [(%d,%d),(%d,%d)]\n", debugstr_wn (str, count), count,
 	  rect->left, rect->top, rect->right, rect->bottom);
 
-   if (dtp) TRACE("Params: iTabLength=%d, iLeftMargin=%d, iRightMargin=%d\n",
+    if (dtp) TRACE("Params: iTabLength=%d, iLeftMargin=%d, iRightMargin=%d\n",
           dtp->iTabLength, dtp->iLeftMargin, dtp->iRightMargin);
 
+    /* if (flags & (DT_PREFIXONLY | DT_HIDEPREFIX | DT_NOFULLWIDTHCHARBREAK )
+        FIXME ("Using new DT_* settings\n"); */
+
     if (!str) return 0;
     if (count == -1) count = strlenW(str);
     if (count == 0) return 0;
-    strPtr = str;
+
+    if (flags & DT_SINGLELINE)
+        flags &= ~DT_WORDBREAK;
 
     GetTextMetricsW(hdc, &tm);
     if (flags & DT_EXTERNALLEADING)
@@ -282,165 +740,94 @@
         if (!(flags & (DT_CENTER | DT_RIGHT)))
             x += lmargin;
         dtp->uiLengthDrawn = 0;     /* This param RECEIVES number of chars processed */
+        /* Should rmargin modify the rectangle width ? */
     }
 
-    if (flags & DT_TABSTOP)
-	tabstop = dtp ? dtp->iTabLength : flags >> 8;
-
-    if (flags & DT_EXPANDTABS)
+    /* Tab settings */
     {
-	GetTextExtentPointW(hdc, SPACEW, 1, &size);
-	spacewidth = size.cx;
-	GetTextExtentPointW(hdc, oW, 1, &size);
-	tabwidth = size.cx * tabstop;
+        int tabstop;
+        tabstop = (flags & DT_TABSTOP) ?
+                      fEx ?
+                          (dtp ? dtp->iTabLength : 8) :
+                          (flags >> 8) & 0xff :
+                      8;
+        if ((!fEx) && (flags & DT_TABSTOP))
+            flags &= 0xffff00ff;
+        /* Not yet confirmed that the flags corresponding to bits 8-15 are
+         * functional in the Ex functions, but I am sure they will be so we
+         * don't clear them.
+         */
+
+        if (flags & DT_EXPANDTABS)
+        {
+	    line.tabwidth = tm.tmAveCharWidth * tabstop;
+        }
     }
 
-    if (flags & DT_CALCRECT) flags |= DT_NOCLIP;
+    if (flags & DT_CALCRECT) flags |= DT_NOCLIP; /* Are you sure? */
 
-    do
-    {
-	prefix_offset = -1;
-	len = MAX_STATIC_BUFFER;
-	strPtr = TEXT_NextLineW(hdc, strPtr, &count, line, &len, width, flags);
+    line.hdc = hdc;
+    line.str = str;
+    line.max_width = rect->right - rect->left;
+    line.count = count;
+    line.format = flags;
+    line.buffer = line_buffer;
+    line.buflen = countof(line_buffer);
+    line.seg = seg_buffer;
+    line.max_segs = countof(seg_buffer);
 
-	if (prefix_offset != -1)
-	{
-	    GetTextExtentPointW(hdc, line, prefix_offset, &size);
-	    prefix_x = size.cx;
-	    GetTextExtentPointW(hdc, line, prefix_offset + 1, &size);
-	    prefix_end = size.cx - 1;
-	}
 
-	if (!GetTextExtentPointW(hdc, line, len, &size)) return 0;
+    do /* for each line */
+    {
+        line.last_line = !(flags & DT_NOCLIP) && y + ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) > rect->bottom;
+	TEXT_NextLineW(&line);
+
 	if (flags & DT_CENTER) x = (rect->left + rect->right -
-				    size.cx) / 2;
-	else if (flags & DT_RIGHT) x = rect->right - size.cx;
+				    line.size.cx) / 2;
+	else if (flags & DT_RIGHT) x = rect->right - line.size.cx;
 
 	if (flags & DT_SINGLELINE)
 	{
 	    if (flags & DT_VCENTER) y = rect->top +
-	    	(rect->bottom - rect->top) / 2 - size.cy / 2;
-	    else if (flags & DT_BOTTOM) y = rect->bottom - size.cy;
+	    	(rect->bottom - rect->top) / 2 - line.size.cy / 2;
+	    else if (flags & DT_BOTTOM) y = rect->bottom - line.size.cy;
 
-	    if (flags & (DT_PATH_ELLIPSIS | DT_END_ELLIPSIS | DT_WORD_ELLIPSIS))
-	    {
-	        WCHAR swapStr[sizeof(line)];
-	        WCHAR* fnameDelim = NULL;
-	        int totalLen = i_count >= 0 ? i_count : strlenW(str);
-
-		if (size.cx > width)
-	        {
-	            int fnameLen = totalLen;
-
-	            /* allow room for '...' */
-	            count = min(totalLen+3, sizeof(line)-3);
-
-                    if (flags & DT_WORD_ELLIPSIS)
-	                flags |= DT_WORDBREAK;
-
-		    if (flags & DT_PATH_ELLIPSIS)
-	            {
-			WCHAR* lastBkSlash = NULL;
-			WCHAR* lastFwdSlash = NULL;
-	                strncpyW(line, str, totalLen);
-                        line[totalLen] = '\0';
-	                lastBkSlash = strrchrW(line, BACK_SLASHW[0]);
-	                lastFwdSlash = strrchrW(line, FORWARD_SLASHW[0]);
-                        fnameDelim = lastBkSlash > lastFwdSlash ? lastBkSlash : lastFwdSlash;
-
-	                if (fnameDelim)
-	                    fnameLen = &line[totalLen] - fnameDelim;
-	                else
-	                    fnameDelim = (WCHAR*)str;
-
-	                strcpyW(swapStr, ELLIPSISW);
-	                strncpyW(swapStr+strlenW(swapStr), fnameDelim, fnameLen);
-	                swapStr[fnameLen+3] = '\0';
-	                strncpyW(swapStr+strlenW(swapStr), str, totalLen - fnameLen);
-	                swapStr[totalLen+3] = '\0';
-                    }
-                    else  /* DT_END_ELLIPSIS | DT_WORD_ELLIPSIS */
-	            {
-	                strcpyW(swapStr, ELLIPSISW);
-	                strncpyW(swapStr+strlenW(swapStr), str, totalLen);
-	            }
-
-                    len = MAX_STATIC_BUFFER;
-	            TEXT_NextLineW(hdc, swapStr, &count, line, &len, width, flags);
-
-	            /* if only the ELLIPSIS will fit, just let it be clipped */
-	            len = max(3, len);
-	            GetTextExtentPointW(hdc, line, len, &size);
-
-	            /* FIXME:
-	             * NextLine uses GetTextExtentPoint for each character,
-	             * rather than GetCharABCWidth...  So the whitespace between
-	             * characters is ignored in the width measurement, and the
-	             * reported len is too great.  To compensate, we must get
-	             * the width of the entire line and adjust len accordingly.
-	            */
-	            while ((size.cx > width) && (len > 3))
-	            {
-	                line[--len] = '\0';
-	                GetTextExtentPointW(hdc, line, len, &size);
-	            }
-
-	            if (fnameLen < len-3) /* some of the path will fit */
-	            {
-	                /* put the ELLIPSIS between the path and filename */
-	                strncpyW(swapStr, &line[fnameLen+3], len-3-fnameLen);
-	                swapStr[len-3-fnameLen] = '\0';
-	                strcatW(swapStr, ELLIPSISW);
-	                strncpyW(swapStr+strlenW(swapStr), &line[3], fnameLen);
-	            }
-	            else
-	            {
-	                /* move the ELLIPSIS to the end */
-	                strncpyW(swapStr, &line[3], len-3);
-	                swapStr[len-3] = '\0';
-	                strcpyW(swapStr+strlenW(swapStr), ELLIPSISW);
-	            }
-
-	            strncpyW(line, swapStr, len);
-	            line[len] = '\0';
-	            strPtr = NULL;
-	        }
-               if (flags & DT_MODIFYSTRING)
-                    strcpyW(str, swapStr);
-	    }
 	}
 	if (!(flags & DT_CALCRECT))
 	{
-           if (!ExtTextOutW( hdc, x, y,
-                             ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
-                             ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
-                    rect, line, len, NULL ))  return 0;
-            if (prefix_offset != -1)
+            sDrawTextLineSegment *seg;
+            for (seg = line.seg; line.num_segs--; seg++)
+            {
+                if (!ExtTextOutW( hdc, x+seg->xStart, y,
+                                 ((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
+                                 ((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
+                                 rect, seg->str, seg->nChar, NULL ))  return 0;
+            }
+            if (line.prefix_segment >= 0)
             {
-                HPEN hpen = CreatePen( PS_SOLID, 1, GetTextColor(hdc) );
-                HPEN oldPen = SelectObject( hdc, hpen );
-                MoveToEx(hdc, x + prefix_x, y + tm.tmAscent + 1, NULL );
-                LineTo(hdc, x + prefix_end + 1, y + tm.tmAscent + 1 );
-                SelectObject( hdc, oldPen );
-                DeleteObject( hpen );
+                seg = line.seg + line.prefix_segment;
+                TEXT_DrawUnderscore (hdc, x + seg->xStart, y + tm.tmAscent + 1,
+                                     seg->str, line.prefix_offset);
             }
 	}
-	else if (size.cx > max_width)
-	    max_width = size.cx;
+	else if (line.size.cx > max_width)
+	    max_width = line.size.cx;
+            /* What if DT_EDITCONTROL? */
 
+        if (dtp)
+            dtp->uiLengthDrawn += line.total_chars;
 	y += lh;
-	if (strPtr)
+	if (line.count)
 	{
 	    if (!(flags & DT_NOCLIP))
 	    {
-		if (y > rect->bottom - lh)
+		if (((flags & DT_EDITCONTROL) ? y + lh - 1 : y) > rect->bottom)
 		    break;
+                /* NB Even with DT_EDITCONTROL the first line is always drawn */
 	    }
 	}
-        if (dtp)
-            dtp->uiLengthDrawn += len;
     }
-    while (strPtr);
+    while (line.count);
 
     if (flags & DT_CALCRECT)
     {
@@ -448,15 +835,23 @@
 	rect->bottom = y;
         if (dtp)
             rect->right += lmargin + rmargin;
+        /* Are you sure ? */
     }
     return y - rect->top;
 }
 
 /***********************************************************************
- *           DrawTextExA    (USER32.@)
+ * TEXT_DrawTextA
+ *
+ * A-W conversion wrapper for TEXT_DrawTextW
+ *
+ * Parameters
+ *
+ * The parameters are as for TEXT_DrawTextW except that str is in A format
  */
-INT WINAPI DrawTextExA( HDC hdc, LPSTR str, INT count,
-                        LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp )
+static INT WINAPI TEXT_DrawTextA( HDC hdc, LPSTR str, int count,
+                                  LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp,
+                                  int fEx)
 {
    WCHAR *wstr;
    INT ret = 0;
@@ -469,7 +864,7 @@
    if (wstr)
    {
        MultiByteToWideChar( CP_ACP, 0, str, count, wstr, wcount );
-       ret = DrawTextExW( hdc, wstr, wcount, rect, flags, NULL );
+       ret = TEXT_DrawTextW( hdc, wstr, wcount, rect, flags, dtp, fEx );
        if (flags & DT_MODIFYSTRING)
             WideCharToMultiByte( CP_ACP, 0, wstr, -1, str, count, NULL, NULL );
        HeapFree(GetProcessHeap(), 0, wstr);
@@ -478,11 +873,29 @@
 }
 
 /***********************************************************************
+ *           DrawTextExW    (USER32.@)
+ */
+INT WINAPI DrawTextExW( HDC hdc, LPWSTR str, INT count,
+                        LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp )
+{
+    return TEXT_DrawTextW( hdc, str, count, rect, flags, dtp, 1 );
+}
+
+/***********************************************************************
+ *           DrawTextExA    (USER32.@)
+ */
+INT WINAPI DrawTextExA( HDC hdc, LPSTR str, INT count,
+                        LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp )
+{
+    return TEXT_DrawTextA( hdc, str, count, rect, flags, dtp, 1 );
+}
+
+/***********************************************************************
  *           DrawTextW    (USER32.@)
  */
 INT WINAPI DrawTextW( HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags )
 {
-    return DrawTextExW(hdc, (LPWSTR)str, count, rect, flags, NULL);
+    return TEXT_DrawTextW( hdc, (LPWSTR)str, count, rect, flags, NULL, 0 );
 }
 
 /***********************************************************************
@@ -490,10 +903,48 @@
  */
 INT WINAPI DrawTextA( HDC hdc, LPCSTR str, INT count, LPRECT rect, UINT flags )
 {
-    return DrawTextExA( hdc, (LPSTR)str, count, rect, flags, NULL );
+    return TEXT_DrawTextA( hdc, (LPSTR)str, count, rect, flags, NULL, 0 );
 }
 
 /***********************************************************************
+ *           DrawText    (USER.85)
+ */
+INT16 WINAPI DrawText16( HDC16 hdc, LPCSTR str, INT16 count, LPRECT16 rect, UINT16 flags )
+{
+    INT16 ret;
+
+    if (rect)
+    {
+        RECT rect32;
+        CONV_RECT16TO32( rect, &rect32 );
+        ret = TEXT_DrawTextA( hdc, (LPSTR)str, count, &rect32, flags, NULL, 0 );
+        CONV_RECT32TO16( &rect32, rect );
+    }
+    else ret = TEXT_DrawTextA( hdc, (LPSTR)str, count, NULL, flags, NULL, 0 );
+    return ret;
+}
+
+/*----------------------------------------------------------------------------*/
+
+/* ### start build ### */
+extern WORD CALLBACK TEXT_CallTo16_word_wlw(GRAYSTRINGPROC16,WORD,LONG,WORD);
+/* ### stop build ### */
+
+struct gray_string_info
+{
+    GRAYSTRINGPROC16 proc;
+    LPARAM           param;
+};
+
+/* callback for 16-bit gray string proc */
+static BOOL CALLBACK gray_string_callback( HDC hdc, LPARAM param, INT len )
+{
+    const struct gray_string_info *info = (struct gray_string_info *)param;
+    return TEXT_CallTo16_word_wlw( info->proc, hdc, info->param, len );
+}
+
+
+/***********************************************************************
  *           TEXT_GrayString
  *
  * FIXME: The call to 16-bit code only works because the wine GDI is a 16-bit

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux