Converting all cells to text
This code has basically the same performance issue as your last question, and the performance solution is pretty much the same.  Other things to note:


This is more of a nag than anything, but you should really remove
dead code that is commented out.
The variable Cell is never declared. You should put Option Explicit at the top of all of your code modules. See Why should I
dimension my variables in VBA
really? over on SO.
You don't return a value, so this should really be a Sub, not a
Function.  If you don't want it to appear in the macro list,
declare it as Private. I'd get into the habit of always
explicitly declaring your scope.
You have a bug.  You explain pretty clearly in your question that
the .Value of a cell can differ dramatically from the .Text of a
cell depending on the formatting. However, when you test the length
of the cell values, you're checking against the Value that you
already point out is not dependant on the formatting.  You need to
test the Text against your width.
You have another possible bug (not addressed in the code below) -
for proportional width fonts, the value referred to by ColumnWidth
is based on the width of the character '0' (see the
documentation).
If you happen to be using a font where any character is wider than
'0' (for example 'X' in my browser's default font), you can't reliably use the ColumnWidth as a proxy for the
length of a string that it can display.
255 is the magic number, yes it is. Since you're testing the maximum
width of a text rendered cell to this value, and using it in
multiple places in your code to provide formatting information, make
it a constant and give it an appropriate name.
I'm assuming that the call to RefreshScreen is to provide some
sort of indication to the user that something is actually happening
instead of a hung script.  I'd remove it completely.  If you call
DoEvents Excel will have a chance to update the screen buffer. 
This is not only more performant (it avoids a function call), but it
will also be clearer to the reader what is going on. Even better
would be to simply omit it, as redrawing the screen is what is
killing your in performance in the first place (see below).
Personally, I would cache the column widths and reset them when you
are done instead of using the arbitrary value '20'.  This upholds
the principle of least astonishment.
You set the NumberFormat to text for the entire Worksheet at the
end of the Function.  Setting it for individual cells inside your
loop is not only redundant, but forces a ScreenUpdate. This is
killing your performance. Basically, what is happening is that you are updating the display once for every cell in the UsedRange.
This is incredibly expensive.  Turn ScreenUpdating off instead.
As I mentioned in comments to your previous question, updating cells
is more expensive in terms of performance than you might guess. 
When you are working with large ranges of cells, you should pull
them into an array if at all possible, then write the entire array
back at once. This lowers your "Excel overhead" almost
quadratically.
You should avoid using the Cells collection (it is entirely
dependant on what object is active) and the Selection object
(almost every operation can be performed with the Range you
already have a reference to).
Use With blocks to your advantage, especially in loops.  Every
 '.' operator that you see in your code causes an object deference
 call.  Wrapping sections where the same object is used repeatedly
 in a With block essentially caches the result of the deference
 instead of repeatedly performing it.
Similar note with pulling cell values from a Range.  Accessing
 the object is much more expensive than storing it.  If you have to
 reference the same value twice (looking at you, If Cell.Text &lt;&gt; Cell.Value And Len(Cell.Value) &lt;= 255 Then), cache it.


The above notes basically boil down to something more like this:

Const MaxTextLength = 255

Private Sub ConvertAllCellsToText()
    StartNewTask "Converting all cells to text"
    Application.ScreenUpdating = False

    Dim MyRange As Range
    Set MyRange = ActiveSheet.UsedRange
    Dim cache() As Long
    cache = GetColumnWidths(MyRange)

    With MyRange
        .ColumnWidth = MaxTextLength
        Dim Values() As Variant
        ReDim Values(.Rows.Count, .Columns.Count)

        Dim col As Long
        Dim row As Long

        For row = 0 To UBound(Values, 1)
            For col = 0 To UBound(Values, 2)
                Dim temp As String
                temp = .Cells(row + 1, col + 1).Text
                If Len(temp) &lt;= MaxTextLength Then
                    Values(row, col) = temp
                End If
            Next col
        Next row
        .NumberFormat = "@"
    End With

    MyRange = Values
    SetColumnWidths MyRange, cache
    Application.ScreenUpdating = True
End Sub

Private Function GetColumnWidths(Target As Range) As Long()
    Dim output() As Long
    ReDim output(1 To Target.Columns.Count)
    Dim index As Long
    For index = 1 To Target.Columns.Count
        output(index) = Target.Columns(index).ColumnWidth
    Next index
    GetColumnWidths = output
End Function

Private Sub SetColumnWidths(Target As Range, widths() As Long)
    Dim index As Long
    For index = LBound(widths) To UBound(widths)
        Target.Columns(index).ColumnWidth = widths(index)
    Next index
End Sub


NOTE: I didn't benchmark this, but I'd ballpark about 100 times faster.

EDIT: Almost forgot.  If you have a bunch of numbers in your sheet, you'll want to ignore the numbers stored as text errors to get another nominal performance gain.  Call it before you turn ScreenUpdating back on.