Use the .NET framework to shorten a path string with an ellipsis

Just perfect!

Is there a way to do the same thing in WPF?

I am providing more information regarding the PathCompactPath function to help programmers avoid its use in .NET Framework version 2.0.

http://www.missico.com/personal/support/visual_basic_tips.htm#PathCompactPath[^]

''' <summary>
''' Truncates a file path to fit within a given pixel width by replacing path components with ellipses.
''' </summary>
''' <param name="hdc">[in] A handle to the device context used for font metrics.</param>
''' <param name="lpszPath">[in, out] A pointer to a null-terminated string of length MAX_PATH that contains the path to be modified. On return, this buffer will contain the modified string.</param>
''' <param name="dx">[in] The width, in pixels, in which the string must fit.</param>
''' <returns>Returns TRUE if the path was successfully compacted to the specified width. Returns FALSE on failure, or if the base portion of the path would not fit the specified width.</returns>
''' <remarks>
''' <para>This Shell Lightweight Utility function uses the font currently selected in hDC to calculate the width of the text. This function will not compact the path beyond the base file name preceded by ellipses.</para>
''' <para>The .NET Framework version 2.0 contains the TextRenderer.MeasureText method, which can reproduce the functionality of the PathCompactPath function, as shown in the following example.</para>
''' <example>
''' <code>
'''    Public Function CompactPath(ByVal text As String, ByVal control As Control) As String
''' 
'''        'make a copy because the measure text call is instructed to modify string
'''        Dim sResult As String = String.Copy(text)
''' 
'''        TextRenderer.MeasureText(sResult, control.Font, control.ClientSize, TextFormatFlags.PathEllipsis Or TextFormatFlags.ModifyString)
'''  
'''        Return sResult
''' 
'''    End Function
''' </code>
''' </example>
''' </remarks>
<Obsolete("In .NET 2.0, use TextRenderer.MeasureText with TextFormatFlags.PathEllipsis", True)> _
Declare Auto Function PathCompactPath Lib "shlwapi.dll" ( _
    ByVal hdc As IntPtr, _
    ByVal lpszPath As System.Text.StringBuilder, _
    ByVal dx As Int32) As Boolean
 
''' <summary>
''' Truncates a file path to fit within a given pixel width by replacing path components with ellipses.
''' </summary>
''' <returns>Returns the path compacted to the specified width. This function will not compact the path beyond the base file name preceded by ellipses. Therefore, the base portion of the path may not always fit within the specified width.</returns>
''' <remarks>
''' <para>Works well with monospace/fixed-width fonts. Tends to compact text too much when using proportional fonts.</para>
''' </remarks>
Public Function CompactPath(ByVal path As String, ByVal control As Control) As String
    Const MAX_PATH As Integer = 260
 
    Dim oPath As New System.Text.StringBuilder(path, MAX_PATH)
    Dim oGraphics As System.Drawing.Graphics = control.CreateGraphics
 
    Try
 
        If PathCompactPath(oGraphics.GetHdc, oPath, control.ClientSize.Width) Then
            'okay
        Else
            'failure or base name too long for specified width
        End If
 
    Finally
 
        If Not (oGraphics Is Nothing) Then
 
            'if you do not release the device context then you will get
            '   An unhandled exception of type 'System.InvalidOperationException' occurred in system.drawing.dll
            '   The object is currently in use elsewhere.
 
            oGraphics.ReleaseHdc()
            oGraphics.Dispose()
 
        End If
 
    End Try
 
    Return oPath.ToString
End Function

When I run this code as it is and use it to change the Text attribute of a check box it runs a little long. That is easily fixed by reducing the width of the field by 22 when calling the function.

Another problem that I had with this setup is that I would get a string returned with the exact same length as the original string, which would then be written to the check box text label as c:\this\is\...\test[]a\very\long, where [] is that box character that means that there is no glyph to represent the character in the string. I stepped through the string character by character and found that the [] character was Nothing, literally, when I assigned the [] to a Char type it was reported as Nothing. So I had to include the following code in my path shrinking routine to catch this Nothing and get rid of it and everything after it.

Public Function ShrinkString(ByVal strString As String, ByVal intWidth As Integer, ByVal Font As Drawing.Font, ByVal FormatFlags As Windows.Forms.TextFormatFlags) As String

    Dim strWorking As String = String.Copy(strString)
    Dim strResult As String = ""
    Dim charResult As Char = ""

    TextRenderer.MeasureText(strWorking, Font, New Drawing.Size(intWidth, 0), FormatFlags Or TextFormatFlags.ModifyString)

    For Each charResult In strWorking
        If charResult = Nothing Then
            Exit For
        End If
        strResult &= charResult
    Next

    Return strResult

End Function

If you want to see this Nothing character, step through this code and watch charResult in the Locals window. You'll also notice that the strWorking doesn't have a " on the end of it.

I'm in VS2005 using a .Net 2.0 program.

Chris Barth

Nice article, though this method seems to use a 'hack' to return a string for display purposes only, it modifies the internal string buffer (changes the character after the ellipses to \0). The problem here is that trying to get the index of the null character using IndexOf('\0') works only if the string was shortened, but if additional characters were added (yes, it adds additional characters to the string if it's not long enough) IndexOf('\0') simply doesn't work and returns -1, any idea how can I get the modified string without using hacks or reflection?

Waleed Eissa
Software Developer Sydney

MSDN for DrawTextEx function which is internally used by TextRenderer.MeasureText has the following requirements:

If dwDTFormat includes DT_MODIFYSTRING, the function could add up to four additional characters to this string. The buffer containing the string should be large enough to accommodate these extra characters.

So, in some circumstances (in my testing usually on Win2k), function will fail with AccessViolationException, because writing to the protected memory occurs.

Liberavi animam meam!

For things like menu items that autosize to the text this snippet (in C#) will truncate the string to the null character. ModifyString leaves the end of the original string in place an demarcates the end of the new string with a \0.

string s = string.Copy(input);<br />
<br />
TextRenderer.MeasureText(s, toolStrip1.Font, new Size(250, 0), TextFormatFlags.PathEllipsis | TextFormatFlags.ModifyString);<br />
<br />
int nullPos = s.IndexOf('\0');<br />
if (nullPos != -1)<br />
     s = s.Substring(0, nullPos);<br />
<br />
result= s;

I would prefer a shortened path of e.g. "C:\...\Folders\test.txt"
Any suggestions on how to shorten the path like this? There must exist a simple way, as this is the common formation for recent files in the windows menus?

Best regards,
Zach

ppp

hi!
i use http://www.csharp411.com/truncate-file-path-with-ellipsis/[^].
but it shows some chars from first folders... hth.
regards,
chris

Note that this feature has apparently been removed from .NET 3.0:

http://msdn2.microsoft.com/en-us/library/system.windows.forms.textformatflags.aspx[^]

"ModifyString - Has no effect on the drawn text."

It always was quite bizarre to be able to alter string objects directly, instead of receiving a reference to a new string.
If you use Reflector, you could probably reimplement this feature with PInvoke.

Looking at the documentation, not sure what that actually means. I don't think it was removed, as this stil works for 3.5. What I think it means is that if specified alone without any other format flags, the text will be drawn without any modifications, although the docs don't really make that clear, or if it makes any difference, because if you don'r specify any other formaqt flags, you aren't really doing anything anyway. Bizarre!

Please rate my articles!
Greg Osborne

Um.. wasn't MyString passed ByVal anyway? Not sure why you're copying it.

nevermind

I hadn't noticed that behaviour in VB.Net before.... D'Oh! | :doh:

I thought this was interesting too. The first param of the MeasureText method is actually ByVal so the only way for the framework to get a new string back to the caller is for it to modify the existing object by manipulating its properties (instead of assigning a new string object). If it were ByRef, it could change the pointer to the object w/o modifying the string passed in.

Therefore, the same thing would happen to the caller of CompactString unless we actually make a copy of that string as a new object instance and turn that over to MeasureText to manipulate.

Tim Greenfield
Software Architect and Engineer

I'll give $100 to the first person who can engineer a compromise of security from the fact that strings in .NET aren't quite as immutable as Microsoft claim.

This sort of thing might seem trivial but even I have fallen into the trap of rewriting that algorithm myself, then realizing that there was already something in the framework to do it.

Nice beginner tip!

Use the .NET framework to shorten a path string with an ellipsis

Introduction

Background

Using the Code

Points of Interest

License

Comments and Discussions