Improved DiskMap unicode support

mzagozda · mzagozda · commit 651faa1e7357 · 2026-04-10T03:22:30.000+02:00
diff --git a/src/plugins/diskmap/DiskMap/GUI.DirectoryLine.h b/src/plugins/diskmap/DiskMap/GUI.DirectoryLine.h
@@ -71,6 +71,18 @@ class CDirectoryLine : public CChildWindow
     // string for storing a copy of the path with an ellipsis
     TCHAR _pathtemp[MAX_PATH + 3];
 
+    // Wide-char versions of path fields for GDI rendering.
+    // Paths are stored internally as UTF-8 (char), but GDI ANSI functions
+    // use the system ANSI code page and cannot render UTF-8 correctly.
+    // These wide versions are kept in sync with _path/_rootLen and are used
+    // exclusively for measuring and drawing text via the W GDI variants.
+    wchar_t _pathW[MAX_PATH + 4];
+    int _pathWLen;
+    int _rootLenW;
+    wchar_t _pathtempW[MAX_PATH + 3];
+    wchar_t const* _pathstrW;
+    int _pathlenW;
+
     // Cached values - colors: active/inactive
     COLORREF _backColor;
     COLORREF _rootColor;
@@ -132,6 +144,13 @@ class CDirectoryLine : public CChildWindow
         this->_nodeCount = nodeid;
         this->_nodes[this->_nodeCount].xright = LAST_NODEX;
 
+        // Build wide-char version of path for GDI rendering (paths are UTF-8 internally)
+        this->_pathWLen = MultiByteToWideChar(CP_UTF8, 0, this->_path->GetString(), (int)this->_path->GetLength(), this->_pathW, ARRAYSIZE(this->_pathW) - 1);
+        if (this->_pathWLen < 0)
+            this->_pathWLen = 0;
+        this->_pathW[this->_pathWLen] = L'\0';
+        this->_rootLenW = MultiByteToWideChar(CP_UTF8, 0, this->_path->GetString(), this->_rootLen, NULL, 0);
+
         this->_sizeCached = FALSE;
         this->Repaint();
     }
@@ -193,11 +212,13 @@ class CDirectoryLine : public CChildWindow
         SIZE sz;
         int sizewidth = 0;
         int pathwidth = 0;
+        // dx holds per-wide-char pixel positions; wide length <= UTF-8 byte length
         int dx[MAX_PATH + 3];
-        GetTextExtentExPoint(hdc, this->_path->GetString(), (int)this->_path->GetLength(), 0, NULL, dx, &sz);
+        GetTextExtentExPointW(hdc, this->_pathW, this->_pathWLen, 0, NULL, dx, &sz);
         pathwidth = sz.cx;
         if (this->_disksize >= 0)
         {
+            // Size strings are ASCII-only formatted numbers; ANSI call is correct here
             GetTextExtentPoint32(hdc, this->_sizestrlong->GetString(), (int)this->_sizestrlong->GetLength(), &sz);
             sizewidth = sz.cx + 2;
 
@@ -228,50 +249,60 @@ class CDirectoryLine : public CChildWindow
 			}*/
         }
 
+        // Map each node's UTF-8 byte offset to its wide-char position for dx indexing.
+        // Backslashes are always single-byte ASCII in UTF-8 so the positions differ only
+        // when non-ASCII characters appear before the backslash.
+        const char* utf8path = this->_path->GetString();
+        int nodeWPos[MAX_PATH / 2 + 1];
+        for (int i = 0; i < this->_nodeCount; i++)
+        {
+            nodeWPos[i] = MultiByteToWideChar(CP_UTF8, 0, utf8path, this->_nodes[i].strpos, NULL, 0);
+        }
+
         if (pathwidth <= width)
         {
-            this->_pathstr = this->_path->GetString();
-            this->_pathlen = (int)this->_path->GetLength();
+            this->_pathstrW = this->_pathW;
+            this->_pathlenW = this->_pathWLen;
 
-            this->_rootX = dx[this->_rootLen - 1] + rct.left;
+            this->_rootX = dx[this->_rootLenW - 1] + rct.left;
 
             for (int i = 0; i < this->_nodeCount; i++)
             {
-                int ppos = this->_nodes[i].strpos;
-                this->_nodes[i].xright = dx[ppos - 1] + rct.left;
+                int wpos = nodeWPos[i];
+                this->_nodes[i].xright = dx[wpos - 1] + rct.left;
             }
         }
         else
         {
-            TCHAR* ostr = this->_pathtemp;
+            wchar_t* ostr = this->_pathtempW;
             int ostrlen = 0;
             if (width > this->_dotsWidth)
             {
-                TCHAR const* str = this->_path->GetString();
-                int strlen = (int)this->_path->GetLength();
+                wchar_t const* str = this->_pathW;
+                int strlen = this->_pathWLen;
 
                 int remwidth = width - this->_dotsWidth;
 
                 int p = 0;
-                while (p < strlen && dx[p] <= remwidth && str[p] != TEXT('\\'))
+                while (p < strlen && dx[p] <= remwidth && str[p] != L'\\')
                 {
                     ostr[p] = str[p];
                     p++;
                     ostrlen++;
                 }
-                BOOL found = (str[p] == TEXT('\\'));
+                BOOL found = (str[p] == L'\\');
 
-                while (p < strlen && dx[p] <= remwidth && str[p] == TEXT('\\'))
+                while (p < strlen && dx[p] <= remwidth && str[p] == L'\\')
                 {
                     ostr[p] = str[p];
                     p++;
                     ostrlen++;
                 }
-                BOOL whole = (str[p] != TEXT('\\'));
+                BOOL whole = (str[p] != L'\\');
 
-                ostr[ostrlen++] = TEXT('.');
-                ostr[ostrlen++] = TEXT('.');
-                ostr[ostrlen++] = TEXT('.');
+                ostr[ostrlen++] = L'.';
+                ostr[ostrlen++] = L'.';
+                ostr[ostrlen++] = L'.';
 
                 if (found && whole)
                 {
@@ -287,20 +318,20 @@ class CDirectoryLine : public CChildWindow
                     {
                         ostr[ostrlen++] = str[i];
                     }
-                    if (this->_rootLen > rp)
+                    if (this->_rootLenW > rp)
                     {
-                        this->_rootX = dx[this->_rootLen - 1] + rct.left - dx[rp] + this->_dotsWidth + dx[p - 1];
+                        this->_rootX = dx[this->_rootLenW - 1] + rct.left - dx[rp] + this->_dotsWidth + dx[p - 1];
                     }
                     else
                     {
                         this->_rootX = dx[p - 1] + rct.left;
                     }
                     for (i = 0; i < this->_nodeCount; i++)
                     {
-                        int ppos = this->_nodes[i].strpos;
-                        if (ppos > rp)
+                        int wpos = nodeWPos[i];
+                        if (wpos > rp)
                         {
-                            this->_nodes[i].xright = dx[ppos - 1] + rct.left - dx[rp] + this->_dotsWidth + dx[p - 1];
+                            this->_nodes[i].xright = dx[wpos - 1] + rct.left - dx[rp] + this->_dotsWidth + dx[p - 1];
                         }
                         else
                         {
@@ -322,12 +353,12 @@ class CDirectoryLine : public CChildWindow
                 //TODO: node clean - nothing!
                 this->_nodes[0].xright = LAST_NODEX;
             }
-            ostr[ostrlen] = TEXT('\0');
-            this->_pathstr = ostr;
-            this->_pathlen = ostrlen;
+            ostr[ostrlen] = L'\0';
+            this->_pathstrW = ostr;
+            this->_pathlenW = ostrlen;
         }
 
-        if ((size_t)this->_rootLen == this->_path->GetLength())
+        if (this->_rootLenW == this->_pathWLen)
         {
             this->_rootX = -1;
         }
@@ -479,7 +510,7 @@ class CDirectoryLine : public CChildWindow
             {
                 //root string
                 trct.right = this->_rootX;
-                ExtTextOut(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE | ETO_CLIPPED, &trct, this->_pathstr, this->_pathlen, NULL);
+                ExtTextOutW(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE | ETO_CLIPPED, &trct, this->_pathstrW, this->_pathlenW, NULL);
                 trct.right = rct.right;
             }
             trct.left = this->_rootX;
@@ -496,27 +527,27 @@ class CDirectoryLine : public CChildWindow
                     int oR = trct.right;
                     int nr = this->_nodes[this->_mouseNode].xright;
                     trct.right = nr;
-                    ExtTextOut(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE | ETO_CLIPPED, &trct, this->_pathstr, this->_pathlen, NULL);
+                    ExtTextOutW(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE | ETO_CLIPPED, &trct, this->_pathstrW, this->_pathlenW, NULL);
                     trct.left = nr;
                     trct.right = oR;
                 }
                 else
                 {
                     //whole string highlighted
-                    ExtTextOut(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE | ETO_CLIPPED, &trct, this->_pathstr, this->_pathlen, NULL);
+                    ExtTextOutW(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE | ETO_CLIPPED, &trct, this->_pathstrW, this->_pathlenW, NULL);
                 }
             }
             if (!isLastNodeHighlighted)
             {
                 //normal - remaining part
                 SetTextColor(hdc, this->_textColor);
-                ExtTextOut(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE | ETO_CLIPPED, &trct, this->_pathstr, this->_pathlen, NULL);
+                ExtTextOutW(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE | ETO_CLIPPED, &trct, this->_pathstrW, this->_pathlenW, NULL);
             }
         }
         else
         {
             //root string only
-            ExtTextOut(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE | ETO_CLIPPED, &rct, this->_pathstr, this->_pathlen, NULL);
+            ExtTextOutW(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE | ETO_CLIPPED, &rct, this->_pathstrW, this->_pathlenW, NULL);
         }
 
         SelectFont(hdc, hfold);
@@ -618,6 +649,12 @@ class CDirectoryLine : public CChildWindow
         this->_dotsWidth = 0;
         this->_id = 0;
 
+        this->_pathW[0] = L'\0';
+        this->_pathWLen = 0;
+        this->_rootLenW = 0;
+        this->_pathstrW = this->_pathW;
+        this->_pathlenW = 0;
+
         this->_connector = NULL;
 
         this->OnSystemChange();
diff --git a/src/plugins/diskmap/DiskMap/GUI.ToolTip.h b/src/plugins/diskmap/DiskMap/GUI.ToolTip.h
@@ -109,6 +109,9 @@ class CFileInfoTooltip : public CFrameWindow
 
     TCHAR _stitle[2 * MAX_PATH + 1];
     size_t _stitlelen;
+    // Wide version of _stitle for GDI rendering (path is UTF-8 internally)
+    wchar_t _stitleW[2 * MAX_PATH + 1];
+    size_t _stitlelenW;
     TCHAR _sftype[MAX_TYPELEN];
     size_t _sftypelen;
 
@@ -159,6 +162,8 @@ class CFileInfoTooltip : public CFrameWindow
         {
             this->_stitle[0] = TEXT('\0');
             this->_stitlelen = 0;
+            this->_stitleW[0] = L'\0';
+            this->_stitlelenW = 0;
             return;
         }
 
@@ -189,6 +194,10 @@ class CFileInfoTooltip : public CFrameWindow
         {
             this->_stitlelen = this->_file->GetFullName(this->_stitle, ARRAYSIZE(this->_stitle));
         }
+
+        // Convert the UTF-8 path title to wide for GDI rendering
+        this->_stitlelenW = (size_t)MultiByteToWideChar(CP_UTF8, 0, this->_stitle, (int)this->_stitlelen, this->_stitleW, ARRAYSIZE(this->_stitleW) - 1);
+        this->_stitleW[this->_stitlelenW] = L'\0';
     }
 
     void MakeDirty()
@@ -219,6 +228,8 @@ class CFileInfoTooltip : public CFrameWindow
         this->_sFormatter = NULL;
 
         this->_stitlelen = 0;
+        this->_stitleW[0] = L'\0';
+        this->_stitlelenW = 0;
         this->_sftypelen = 0;
 
         this->_headers[TT_LID_CREATETIME] = new CZResourceString(IDS_DISKMAP_TTIP_TIMECREATE);
@@ -414,7 +425,7 @@ class CFileInfoTooltip : public CFrameWindow
 
         HFONT hfold;
         hfold = SelectFont(hdc, this->_hftitle);
-        GetTextExtentPoint32(hdc, this->_stitle, (int)this->_stitlelen, &sz);
+        GetTextExtentPoint32W(hdc, this->_stitleW, (int)this->_stitlelenW, &sz);
         wsz.cx = max(sz.cx + 32 + TT_MARGIN_X + TT_MARGIN_X, wsz.cx);
         this->_headerheight += sz.cy;
 
@@ -563,7 +574,7 @@ class CFileInfoTooltip : public CFrameWindow
         int linepos = TT_MARGIN_Y + max(16, szc.cy + TT_MARGIN_Y / 2);
         RECT rct = oR;
         rct.bottom = linepos + 1;
-        ExtTextOut(hdc, TT_MARGIN_X + TT_MARGIN_X + 32 + TT_MARGIN_X / 2, TT_MARGIN_Y + 0, ETO_OPAQUE, &rct, this->_stitle, (UINT)this->_stitlelen, NULL);
+        ExtTextOutW(hdc, TT_MARGIN_X + TT_MARGIN_X + 32 + TT_MARGIN_X / 2, TT_MARGIN_Y + 0, ETO_OPAQUE, &rct, this->_stitleW, (UINT)this->_stitlelenW, NULL);
 
         //Dividing line
         MoveToEx(hdc, TT_MARGIN_X + TT_MARGIN_X + 32, linepos, NULL);

Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,18 @@ class CDirectoryLine : public CChildWindow`
`71`	`71`	`// string for storing a copy of the path with an ellipsis`
`72`	`72`	`TCHAR _pathtemp[MAX_PATH + 3];`
`73`	`73`
	`74`	`+ // Wide-char versions of path fields for GDI rendering.`
	`75`	`+ // Paths are stored internally as UTF-8 (char), but GDI ANSI functions`
	`76`	`+ // use the system ANSI code page and cannot render UTF-8 correctly.`
	`77`	`+ // These wide versions are kept in sync with _path/_rootLen and are used`
	`78`	`+ // exclusively for measuring and drawing text via the W GDI variants.`
	`79`	`+ wchar_t _pathW[MAX_PATH + 4];`
	`80`	`+ int _pathWLen;`
	`81`	`+ int _rootLenW;`
	`82`	`+ wchar_t _pathtempW[MAX_PATH + 3];`
	`83`	`+ wchar_t const* _pathstrW;`
	`84`	`+ int _pathlenW;`
	`85`	`+`
`74`	`86`	`// Cached values - colors: active/inactive`
`75`	`87`	`COLORREF _backColor;`
`76`	`88`	`COLORREF _rootColor;`
`@@ -132,6 +144,13 @@ class CDirectoryLine : public CChildWindow`
`132`	`144`	`this->_nodeCount = nodeid;`
`133`	`145`	`this->_nodes[this->_nodeCount].xright = LAST_NODEX;`
`134`	`146`
	`147`	`+ // Build wide-char version of path for GDI rendering (paths are UTF-8 internally)`
	`148`	`+ this->_pathWLen = MultiByteToWideChar(CP_UTF8, 0, this->_path->GetString(), (int)this->_path->GetLength(), this->_pathW, ARRAYSIZE(this->_pathW) - 1);`
	`149`	`+ if (this->_pathWLen < 0)`
	`150`	`+ this->_pathWLen = 0;`
	`151`	`+ this->_pathW[this->_pathWLen] = L'\0';`
	`152`	`+ this->_rootLenW = MultiByteToWideChar(CP_UTF8, 0, this->_path->GetString(), this->_rootLen, NULL, 0);`
	`153`	`+`
`135`	`154`	`this->_sizeCached = FALSE;`
`136`	`155`	`this->Repaint();`
`137`	`156`	`}`
`@@ -193,11 +212,13 @@ class CDirectoryLine : public CChildWindow`
`193`	`212`	`SIZE sz;`
`194`	`213`	`int sizewidth = 0;`
`195`	`214`	`int pathwidth = 0;`
	`215`	`+ // dx holds per-wide-char pixel positions; wide length <= UTF-8 byte length`
`196`	`216`	`int dx[MAX_PATH + 3];`
`197`		`- GetTextExtentExPoint(hdc, this->_path->GetString(), (int)this->_path->GetLength(), 0, NULL, dx, &sz);`
	`217`	`+ GetTextExtentExPointW(hdc, this->_pathW, this->_pathWLen, 0, NULL, dx, &sz);`
`198`	`218`	`pathwidth = sz.cx;`
`199`	`219`	`if (this->_disksize >= 0)`
`200`	`220`	`{`
	`221`	`+ // Size strings are ASCII-only formatted numbers; ANSI call is correct here`
`201`	`222`	`GetTextExtentPoint32(hdc, this->_sizestrlong->GetString(), (int)this->_sizestrlong->GetLength(), &sz);`
`202`	`223`	`sizewidth = sz.cx + 2;`
`203`	`224`
`@@ -228,50 +249,60 @@ class CDirectoryLine : public CChildWindow`
`228`	`249`	`}*/`
`229`	`250`	`}`
`230`	`251`
	`252`	`+ // Map each node's UTF-8 byte offset to its wide-char position for dx indexing.`
	`253`	`+ // Backslashes are always single-byte ASCII in UTF-8 so the positions differ only`
	`254`	`+ // when non-ASCII characters appear before the backslash.`
	`255`	`+ const char* utf8path = this->_path->GetString();`
	`256`	`+ int nodeWPos[MAX_PATH / 2 + 1];`
	`257`	`+ for (int i = 0; i < this->_nodeCount; i++)`
	`258`	`+ {`
	`259`	`+ nodeWPos[i] = MultiByteToWideChar(CP_UTF8, 0, utf8path, this->_nodes[i].strpos, NULL, 0);`
	`260`	`+ }`
	`261`	`+`
`231`	`262`	`if (pathwidth <= width)`
`232`	`263`	`{`
`233`		`- this->_pathstr = this->_path->GetString();`
`234`		`- this->_pathlen = (int)this->_path->GetLength();`
	`264`	`+ this->_pathstrW = this->_pathW;`
	`265`	`+ this->_pathlenW = this->_pathWLen;`
`235`	`266`
`236`		`- this->_rootX = dx[this->_rootLen - 1] + rct.left;`
	`267`	`+ this->_rootX = dx[this->_rootLenW - 1] + rct.left;`
`237`	`268`
`238`	`269`	`for (int i = 0; i < this->_nodeCount; i++)`
`239`	`270`	`{`
`240`		`- int ppos = this->_nodes[i].strpos;`
`241`		`- this->_nodes[i].xright = dx[ppos - 1] + rct.left;`
	`271`	`+ int wpos = nodeWPos[i];`
	`272`	`+ this->_nodes[i].xright = dx[wpos - 1] + rct.left;`
`242`	`273`	`}`
`243`	`274`	`}`
`244`	`275`	`else`
`245`	`276`	`{`
`246`		`- TCHAR* ostr = this->_pathtemp;`
	`277`	`+ wchar_t* ostr = this->_pathtempW;`
`247`	`278`	`int ostrlen = 0;`
`248`	`279`	`if (width > this->_dotsWidth)`
`249`	`280`	`{`
`250`		`- TCHAR const* str = this->_path->GetString();`
`251`		`- int strlen = (int)this->_path->GetLength();`
	`281`	`+ wchar_t const* str = this->_pathW;`
	`282`	`+ int strlen = this->_pathWLen;`
`252`	`283`
`253`	`284`	`int remwidth = width - this->_dotsWidth;`
`254`	`285`
`255`	`286`	`int p = 0;`
`256`		`- while (p < strlen && dx[p] <= remwidth && str[p] != TEXT('\\'))`
	`287`	`+ while (p < strlen && dx[p] <= remwidth && str[p] != L'\\')`
`257`	`288`	`{`
`258`	`289`	`ostr[p] = str[p];`
`259`	`290`	`p++;`
`260`	`291`	`ostrlen++;`
`261`	`292`	`}`
`262`		`- BOOL found = (str[p] == TEXT('\\'));`
	`293`	`+ BOOL found = (str[p] == L'\\');`
`263`	`294`
`264`		`- while (p < strlen && dx[p] <= remwidth && str[p] == TEXT('\\'))`
	`295`	`+ while (p < strlen && dx[p] <= remwidth && str[p] == L'\\')`
`265`	`296`	`{`
`266`	`297`	`ostr[p] = str[p];`
`267`	`298`	`p++;`
`268`	`299`	`ostrlen++;`
`269`	`300`	`}`
`270`		`- BOOL whole = (str[p] != TEXT('\\'));`
	`301`	`+ BOOL whole = (str[p] != L'\\');`
`271`	`302`
`272`		`- ostr[ostrlen++] = TEXT('.');`
`273`		`- ostr[ostrlen++] = TEXT('.');`
`274`		`- ostr[ostrlen++] = TEXT('.');`
	`303`	`+ ostr[ostrlen++] = L'.';`
	`304`	`+ ostr[ostrlen++] = L'.';`
	`305`	`+ ostr[ostrlen++] = L'.';`
`275`	`306`
`276`	`307`	`if (found && whole)`
`277`	`308`	`{`
`@@ -287,20 +318,20 @@ class CDirectoryLine : public CChildWindow`
`287`	`318`	`{`
`288`	`319`	`ostr[ostrlen++] = str[i];`
`289`	`320`	`}`
`290`		`- if (this->_rootLen > rp)`
	`321`	`+ if (this->_rootLenW > rp)`
`291`	`322`	`{`
`292`		`- this->_rootX = dx[this->_rootLen - 1] + rct.left - dx[rp] + this->_dotsWidth + dx[p - 1];`
	`323`	`+ this->_rootX = dx[this->_rootLenW - 1] + rct.left - dx[rp] + this->_dotsWidth + dx[p - 1];`
`293`	`324`	`}`
`294`	`325`	`else`
`295`	`326`	`{`
`296`	`327`	`this->_rootX = dx[p - 1] + rct.left;`
`297`	`328`	`}`
`298`	`329`	`for (i = 0; i < this->_nodeCount; i++)`
`299`	`330`	`{`
`300`		`- int ppos = this->_nodes[i].strpos;`
`301`		`- if (ppos > rp)`
	`331`	`+ int wpos = nodeWPos[i];`
	`332`	`+ if (wpos > rp)`
`302`	`333`	`{`
`303`		`- this->_nodes[i].xright = dx[ppos - 1] + rct.left - dx[rp] + this->_dotsWidth + dx[p - 1];`
	`334`	`+ this->_nodes[i].xright = dx[wpos - 1] + rct.left - dx[rp] + this->_dotsWidth + dx[p - 1];`
`304`	`335`	`}`
`305`	`336`	`else`
`306`	`337`	`{`
`@@ -322,12 +353,12 @@ class CDirectoryLine : public CChildWindow`
`322`	`353`	`//TODO: node clean - nothing!`
`323`	`354`	`this->_nodes[0].xright = LAST_NODEX;`
`324`	`355`	`}`
`325`		`- ostr[ostrlen] = TEXT('\0');`
`326`		`- this->_pathstr = ostr;`
`327`		`- this->_pathlen = ostrlen;`
	`356`	`+ ostr[ostrlen] = L'\0';`
	`357`	`+ this->_pathstrW = ostr;`
	`358`	`+ this->_pathlenW = ostrlen;`
`328`	`359`	`}`
`329`	`360`
`330`		`- if ((size_t)this->_rootLen == this->_path->GetLength())`
	`361`	`+ if (this->_rootLenW == this->_pathWLen)`
`331`	`362`	`{`
`332`	`363`	`this->_rootX = -1;`
`333`	`364`	`}`
`@@ -479,7 +510,7 @@ class CDirectoryLine : public CChildWindow`
`479`	`510`	`{`
`480`	`511`	`//root string`
`481`	`512`	`trct.right = this->_rootX;`
`482`		`- ExtTextOut(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE \| ETO_CLIPPED, &trct, this->_pathstr, this->_pathlen, NULL);`
	`513`	`+ ExtTextOutW(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE \| ETO_CLIPPED, &trct, this->_pathstrW, this->_pathlenW, NULL);`
`483`	`514`	`trct.right = rct.right;`
`484`	`515`	`}`
`485`	`516`	`trct.left = this->_rootX;`
`@@ -496,27 +527,27 @@ class CDirectoryLine : public CChildWindow`
`496`	`527`	`int oR = trct.right;`
`497`	`528`	`int nr = this->_nodes[this->_mouseNode].xright;`
`498`	`529`	`trct.right = nr;`
`499`		`- ExtTextOut(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE \| ETO_CLIPPED, &trct, this->_pathstr, this->_pathlen, NULL);`
	`530`	`+ ExtTextOutW(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE \| ETO_CLIPPED, &trct, this->_pathstrW, this->_pathlenW, NULL);`
`500`	`531`	`trct.left = nr;`
`501`	`532`	`trct.right = oR;`
`502`	`533`	`}`
`503`	`534`	`else`
`504`	`535`	`{`
`505`	`536`	`//whole string highlighted`
`506`		`- ExtTextOut(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE \| ETO_CLIPPED, &trct, this->_pathstr, this->_pathlen, NULL);`
	`537`	`+ ExtTextOutW(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE \| ETO_CLIPPED, &trct, this->_pathstrW, this->_pathlenW, NULL);`
`507`	`538`	`}`
`508`	`539`	`}`
`509`	`540`	`if (!isLastNodeHighlighted)`
`510`	`541`	`{`
`511`	`542`	`//normal - remaining part`
`512`	`543`	`SetTextColor(hdc, this->_textColor);`
`513`		`- ExtTextOut(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE \| ETO_CLIPPED, &trct, this->_pathstr, this->_pathlen, NULL);`
	`544`	`+ ExtTextOutW(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE \| ETO_CLIPPED, &trct, this->_pathstrW, this->_pathlenW, NULL);`
`514`	`545`	`}`
`515`	`546`	`}`
`516`	`547`	`else`
`517`	`548`	`{`
`518`	`549`	`//root string only`
`519`		`- ExtTextOut(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE \| ETO_CLIPPED, &rct, this->_pathstr, this->_pathlen, NULL);`
	`550`	`+ ExtTextOutW(hdc, rct.left + 1, rct.top + texttop, ETO_OPAQUE \| ETO_CLIPPED, &rct, this->_pathstrW, this->_pathlenW, NULL);`
`520`	`551`	`}`
`521`	`552`
`522`	`553`	`SelectFont(hdc, hfold);`
`@@ -618,6 +649,12 @@ class CDirectoryLine : public CChildWindow`
`618`	`649`	`this->_dotsWidth = 0;`
`619`	`650`	`this->_id = 0;`
`620`	`651`
	`652`	`+ this->_pathW[0] = L'\0';`
	`653`	`+ this->_pathWLen = 0;`
	`654`	`+ this->_rootLenW = 0;`
	`655`	`+ this->_pathstrW = this->_pathW;`
	`656`	`+ this->_pathlenW = 0;`
	`657`	`+`
`621`	`658`	`this->_connector = NULL;`
`622`	`659`
`623`	`660`	`this->OnSystemChange();`