Why doesn't .Font.Reset work in Find/Replace VBA Macro? - vba

Question

I have a particular word in my document that has various inline formatting from previous authors. I want to find that word and strip out its inline formatting. If I were using the keyboard, I would select the items one at a time, applying CTRL+Spacebar to each. Instead, I wrote a macro. In general I don't want to assume the nature of the inline formatting; I don't want to worry if it's bold or italics or anything else; I just want to execute a generic CTRL+Spacebar, which translates to .Font.Reset in VBA. This doesn't work, though. Here's my code, which does work, but please see the comments I added, which collectively ask why .Font.Reset doesn't work:
Sub Inline_Formatting_Replacement()
Dim MyDocRange As Range
Set MyDocRange = ActiveDocument.Range
With MyDocRange.Find
.ClearFormatting
.Text = "word_with_inline_formatting"
With .Replacement
.ClearFormatting
.Text = "word_with_inline_formatting"
.Font.Bold = False 'I shouldn't have to use this.
.Font.Italic = False 'I shouldn't have to use this.
.Font.Reset 'This should work instead of using .Bold and .Italic, _
'but this line does nothing. Why?
End With
.Forward = True
.Wrap = wdFindStop
.Execute Replace:=wdReplaceAll
End With
End Sub

Answer 1

As Cindy Meister pointed out, Font.Reset is a method, not a property.
You're configuring Range.Find.Replacement.Font, telling the object model what you want to replace and how it should be formatted. That works when you invoke read/write properties, because read/write properties store state. Methods act on that state.
It makes more sense when you understand how properties work - here's an example:
Option Explicit
Private internalState As Boolean
Public Property Get State() As Boolean
'invoked when .State is on the right-hand side of an expression, e.g. foo = obj.State
State = internalState
End Property
Public Property Let State(ByVal value As Boolean)
'invoked when .State is on the left-hand side of an expression, e.g. obj.State = foo
'the "value" parameter is the result of the right-hand side expression.
internalState = value
End Property
Imagine this internalState contains the information about whether the font should be bold or not: the Font property on the object returned by Replacement is a Font object, i.e. an instance of the Font class. So when you do .Bold = False you're encapsulating that value inside the internal state of that Font object.
Now say you also have a method in that imaginary class module:
Public Sub Reset()
internalState = False
End Sub
Now I don't know what Reset really does - one would have to peek at the source code for that... or see if the documentation has anything useful:
Removes manual character formatting (formatting not applied using a style). For example, if you manually format a word as bold and the underlying style is plain text (not bold), the Reset method removes the bold format.
https://msdn.microsoft.com/en-us/vba/word-vba/articles/font-reset-method-word
So why doesn't it reset the Font of the Replacement object? It's actually a very good question: one could reasonably expect that invoking Reset on the Replacement.Font would effectively "reset" that font.
I'm not very familiar with the ms-word object model (Cindy is a pro though!), but in order for the .Reset to work as a replacement, I believe the Font class would need to do something like this:
Option Explicit
Private doReset As Boolean
Public Property Get ShouldReset() As Boolean
ShouldReset = doReset
End Property
Public Sub Reset()
'does whatever it does
'...
doReset = True
End Sub
And then when the replacement is actually carried out, Word can inspect ShouldReset and invoke the method on the Font instance of the affected Range - which is a different instance than the Font instance on the Replacement object.
Except it wouldn't make any sense for a Font to do something like above, because of course if you invoke Reset then it should reset - what's missing is something like a ReplacementFont class that could reasonably hold that state/information... and it doesn't exist.
If VBA had functions as first-class citizens, then you could perhaps do something like this bastardized nonsensical pseudo-code:
Set .ReplacementAction = New Function(ByVal r As Range)
r.ClearFormatting
r.Text = "word_with_inline_formatting"
r.Font.Reset
End Function
And then when you'd go Find.Execute, the hypothetical ReplacementAction function would pass the actual Range as a parameter to this ...delegated action, and .Reset would operate against the target Range.Font when it's invoked, as opposed to operating on the Replacement.Font when it's setup.
Alas, VBA can't do delegate stuff... or can it?.

Answer 2

I'm pretty sure that calling Find.Replacement.Font.Reset just clears out any replacement font information, so when you do the replace, the font is not changed.
I'm running into a similar effect, where I want to remove character styling from text globally using find/replace and I haven't found any way to do that.
Replacement.Font, .Style, etc seem to have no way of setting them to "clear out any specific font/style/etc". The only choices are to do nothing or set specific values.
As a result in my case I'll have to write a loop that finds each search hit individually and does the equivalent to ctrl-space on the resulting range. This unfortunately would be much slower than the global replace.