void AddinBaseOnStartup(object sender, EventArgs eventArgs)
{
VstoContribLog.Debug(_ => _("AddinBase.Startup raised, initialising ribbon factory controller"));
context.AddinBase.Startup -= AddinBaseOnStartup;
InitialiseRibbonFactoryController(ribbonFactoryController, context.Application);
}
void WordApplicationOnDocumentChange()
{
var enumDescription = WordRibbonType.WordDocument.GetEnumDescription();
if (wordApplication.Documents.Count == 0)
{
VstoContribLog.Debug(_ => _("Application.DocumentChange raised, no documents currently open"));
foreach (var viewInstance in wordApplication.Windows)
{
NewView(this, new NewViewEventArgs(viewInstance, null, enumDescription));
}
}
else
{
var activeDocument = wordApplication.ActiveDocument;
if (closedDocuments.Contains(activeDocument.GetHashCode()))
{
VstoContribLog.Debug(_ => _("Application.DocumentChange raised ActiveDocument: {0} is closing, ignoring event", activeDocument.ToLogFormat()));
return;
}
var activeWindow = wordApplication.ActiveWindow;
VstoContribLog.Debug(_ => _("Application.DocumentChange raised, ActiveDocument: {0}, ActiveWindow: {1}",
activeDocument.ToLogFormat(), activeWindow.ToLogFormat()));
NewView(this, new NewViewEventArgs(activeWindow, activeDocument, enumDescription));
}
}
private IRibbonViewModel BuildViewModel(string ribbonType, object viewInstance, object viewContext)
{
var viewModelType = ribbonTypeLookup[ribbonType];
VstoContribLog.Info(_ => _("Building ViewModel of type {1} for ribbon {1} with context {2}",
viewModelType.Name, ribbonType, viewContext.ToLogFormat()));
var ribbonViewModel = vstoContribContext.ViewModelFactory.Resolve(viewModelType);
ribbonViewModel.VstoFactory = vstoContribContext.VstoFactory;
if (ribbonUiLookup.ContainsKey(ribbonType))
{
var ribbonUi = ribbonUiLookup[ribbonType];
VstoContribLog.Debug(_ => _("Setting RibbonUi [{0}] for ViewModel", ribbonUi.ToLogFormat()));
ribbonViewModel.RibbonUi = ribbonUi;
}
else if (ribbonUiLookup.ContainsKey(DefaultRibbon))
{
var ribbonUi = ribbonUiLookup[DefaultRibbon];
VstoContribLog.Info(_ => _("Ribbon type was not found, but default was. Setting RibbonUi [{0}] for ViewModel", ribbonUi.ToLogFormat()));
ribbonViewModel.RibbonUi = ribbonUi;
}
ribbonViewModel.CurrentView = viewInstance;
ListenForINotifyPropertyChanged(ribbonViewModel);
ribbonViewModel.Initialised(viewContext == NullContext.Instance ? null : viewContext);
return(ribbonViewModel);
}
void MonitorWorkbookClosed(object sender, WorkbookClosedEventArgs e)
{
VstoContribLog.Debug(log => log("Excel raised WorkbookClosed({0}) event", e.Workbook.ToLogFormat()));
var handler = ViewClosed;
if (handler == null)
{
return;
}
if (workbooks.ContainsKey(e.Workbook))
{
var windows = workbooks[e.Workbook];
foreach (var window in windows)
{
handler(this, new ViewClosedEventArgs(window, e.Workbook));
if (!IsMdi())
{
window.ReleaseComObject();
}
}
workbooks.Remove(e.Workbook);
}
if (!excelApplication.Workbooks.OfType <Workbook>().Except(new[] { e.Workbook }).Any())
{
nullContextOpen = true;
foreach (Window window in excelApplication.Windows)
{
NewView(this, new NewViewEventArgs(window, NullContext.Instance, ExcelRibbonType.ExcelWorkbook.GetEnumDescription()));
}
}
}
private void CleanupViewModel(object context)
{
VstoContribLog.Debug(_ => _("Cleaning up viewmodel for context: {0}", context.ToLogFormat()));
if (!contextToViewModelLookup.ContainsKey(context))
{
VstoContribLog.Warn(_ => _("Cannot find ViewModel to cleanup: {0}", context.ToLogFormat()));
return;
}
var viewModelInstance = contextToViewModelLookup[context];
VstoContribLog.Info(_ => _("ViewModel is {0}", viewModelInstance.ToLogFormat()));
var notifyOfPropertyChanged = viewModelInstance as INotifyPropertyChanged;
if (notifyOfPropertyChanged != null)
{
notifyOfPropertyChanged.PropertyChanged -= NotifiesOfPropertyChangedPropertyChanged;
}
viewModelInstance.Cleanup();
vstoContribContext.ViewModelFactory.Release(viewModelInstance);
customTaskPaneRegister.CleanupViewModel(viewModelInstance);
contextToViewModelLookup.Remove(context);
}
public void RibbonLoaded(IRibbonUI ribbonUi)
{
ribbonUiLookup.Add(currentlyLoadingRibbon, ribbonUi);
VstoContribLog.Debug(_ => _("ribbonTypeLookup.ContainsKey({0}) = {1}", currentlyLoadingRibbon, ribbonTypeLookup.ContainsKey(currentlyLoadingRibbon)));
if (!ribbonTypeLookup.ContainsKey(currentlyLoadingRibbon))
{
return;
}
var viewModelType = ribbonTypeLookup[currentlyLoadingRibbon];
foreach (var viewModelLookup in contextToViewModelLookup.Values
.Where(viewModel => viewModel.GetType() == viewModelType && viewModel.RibbonUi == null))
{
VstoContribLog.Debug(_ => _("Setting RibbonUi [{0}] for ViewModel", ribbonUi.ToLogFormat()));
viewModelLookup.RibbonUi = ribbonUi;
InvalidateRibbonForViewModel(viewModelLookup);
}
if (!ribbonUiLookup.ContainsKey(DefaultRibbon))
{
ribbonUiLookup[DefaultRibbon] = ribbonUi;
}
}
// ReSharper restore InconsistentNaming
/// <summary>
/// Gets the custom UI.
/// </summary>
/// <param name="ribbonId">The ribbon id.</param>
/// <returns></returns>
public string GetCustomUI(string ribbonId)
{
VstoContribLog.Info(_ => _("Office called GetCustomUI({0})", ribbonId));
var customUI = ribbonFactoryController.GetCustomUI(ribbonId);
VstoContribLog.Debug(_ => _("Provided ribbon xml for ribbonId {0}:\r\n\r\n{1}", ribbonId, customUI));
return(customUI);
}
public void Invoke(IRibbonControl control, Expression <Action> caller, params object[] parameters)
{
try
{
var methodName = caller.GetMethodName();
CallbackTarget callbackTarget =
vstoContribContext.TagToCallbackTargetLookup[control.Tag + methodName];
var view = (object)control.Context;
IRibbonViewModel viewModelInstance = ribbonViewModelResolver.ResolveInstanceFor(view);
VstoContribLog.Debug(l => l("Ribbon callback {0} being invoked on {1} (View: {2}, ViewModel: {3})",
methodName, control.Id, view.ToLogFormat(), viewModelInstance.ToLogFormat()));
Type type = viewModelInstance.GetType();
PropertyInfo property = type.GetProperty(callbackTarget.Method);
if (property != null)
{
type.InvokeMember(callbackTarget.Method,
BindingFlags.SetProperty,
null,
viewModelInstance,
new[]
{
parameters.Single()
});
}
else
{
type.InvokeMember(callbackTarget.Method,
BindingFlags.InvokeMethod,
null,
viewModelInstance,
new[]
{
control
}
.Concat(parameters)
.ToArray());
}
}
catch (TargetInvocationException e)
{
var innerEx = e.InnerException;
PreserveStackTrace(innerEx);
if (vstoContribContext.ErrorHandlers.Count == 0)
{
Trace.TraceError(innerEx.ToString());
}
var handled = vstoContribContext.ErrorHandlers.Any(errorHandler => errorHandler.Handle(innerEx));
if (!handled)
{
throw innerEx;
}
}
}
public WordScenarios()
{
wordFacade = new Word2013Facade();
ribbonUI = new RibbonUITestDouble();
VstoContribLog.ToTrace();
VstoContribLog.SetLevel(VstoContribLogLevel.Debug);
testAddInBase = new TestAddInBase();
sut = new WordRibbonFactory(testAddInBase);
}
public ExcelScenario()
{
excelFacade = new Excel2013Facade();
ribbonUI = new RibbonUITestDouble();
VstoContribLog.ToTrace();
VstoContribLog.SetLevel(VstoContribLogLevel.Debug);
testAddInBase = new TestAddInBase();
sut = new ExcelRibbonFactory(testAddInBase);
}
void ViewProviderViewClosed(object sender, ViewClosedEventArgs e)
{
VstoContribLog.Debug(_ => _("ViewProvider.ViewClosed Raised, View: {0}, Context: {1}",
e.View.ToLogFormat(), e.Context.ToLogFormat()));
//TODO write test around context/view cleanup
customTaskPaneRegister.Cleanup(e.View);
CleanupViewModel(e.Context);
viewProvider.CleanupReferencesTo(e.View, e.Context);
}
public object InvokeGet(IRibbonControl control, Expression <Action> caller, params object[] parameters)
{
if (control.Context == null)
{
return(null);
}
var methodName = caller.GetMethodName();
CallbackTarget callbackTarget = vstoContribContext.TagToCallbackTargetLookup[control.Tag + methodName];
var view = (object)control.Context;
IRibbonViewModel viewModelInstance = ribbonViewModelResolver.ResolveInstanceFor(view);
VstoContribLog.Debug(l => l("Ribbon callback {0} being invoked on {1} (View: {2}, ViewModel: {3})",
methodName, control.Id, view.ToLogFormat(), viewModelInstance.ToLogFormat()));
Type type = viewModelInstance.GetType();
PropertyInfo property = type.GetProperty(callbackTarget.Method);
if (property != null)
{
return(type.InvokeMember(callbackTarget.Method,
BindingFlags.GetProperty,
null,
viewModelInstance,
null));
}
try
{
return(type.InvokeMember(callbackTarget.Method,
BindingFlags.InvokeMethod,
null,
viewModelInstance,
new[]
{
control
}
.Concat(parameters)
.ToArray()));
}
catch (MissingMethodException)
{
throw new InvalidOperationException(
string.Format("Expecting method with signature: {0}.{1}(IRibbonControl control)",
type.Name,
callbackTarget.Method));
}
}
void NotifiesOfPropertyChangedPropertyChanged(object sender, PropertyChangedEventArgs e)
{
var viewModel = (IRibbonViewModel)sender;
var senderType = sender.GetType();
foreach (var invalidatedControl in
notifyChangeTargetLookup[senderType]
.Where(property => property.Key == e.PropertyName)
.Select(pair => pair.Value)
.Distinct()
.Where(invalidatedControl => viewModel.RibbonUi != null))
{
VstoContribLog.Debug(_ => _("Invalidating {0} due to property change notification", invalidatedControl));
viewModel.RibbonUi.InvalidateControl(invalidatedControl);
}
}
void Activate(Workbook wb, Window wn)
{
VstoContribLog.Debug(log => log("Excel raised WorkbookOpen(wb: {0}, wn: {1}) event", wb.ToLogFormat(), wn.ToLogFormat()));
if (IsMdi() && !workbooks[wb].Contains(singleWindow))
{
workbooks[wb].Add(singleWindow);
}
if (!IsMdi() && !workbooks[wb].Contains(wn))
{
var windows = workbooks[wb];
if (windows.All(w => ((dynamic)w).Hwnd != ((dynamic)wn).Hwnd))
{
windows.Add(wn);
NewView(this, new NewViewEventArgs(wn, wb, ExcelRibbonType.ExcelWorkbook.GetEnumDescription()));
}
}
}
/// <summary>
/// Registers the open word documents.
/// </summary>
public void RegisterOpenDocuments()
{
VstoContribLog.Debug(_ => _("Registering all already open documents"));
using (var documents = wordApplication.Documents.WithComCleanup())
{
foreach (Document document in documents.Resource)
{
using (var windows = document.Windows.WithComCleanup())
{
foreach (Window window in windows.Resource)
{
WordApplicationWindowActivate(document, window);
}
}
}
}
}
static IEnumerable <Type> GetTRibbonTypesInAssemblies(IEnumerable <Assembly> assemblies)
{
VstoContribLog.Debug(_ => _("Discovering ViewModels"));
Type ribbonViewModelType = typeof(IRibbonViewModel);
return(assemblies
.Select(assembly =>
{
VstoContribLog.Debug(_ => _("Discovering ViewModels in {0}", assembly.GetName().Name));
var types = assembly.GetTypes();
var viewModelTypes = types.Where(ribbonViewModelType.IsAssignableFrom).ToArray();
VstoContribLog.Debug(_ => _("Found:{0}", string.Join(string.Empty, viewModelTypes.Select(vm => "\r\n " + vm.Name))));
return viewModelTypes;
}
)
.SelectMany(vm => vm));
}
protected override Office.IRibbonExtensibility CreateRibbonExtensibilityObject()
{
//Required for WPF support
if (System.Windows.Application.Current == null)
{
new Application {
ShutdownMode = ShutdownMode.OnExplicitShutdown
}
}
;
VstoContribLog.ToTrace();
VstoContribLog.SetLevel(VstoContribLogLevel.Debug);
return(new ExcelRibbonFactory(this, typeof(AddinModule).Assembly)
{
ViewModelFactory = new AutofacViewModelFactory(new AddinModule())
});
}
void ViewProviderNewView(object sender, NewViewEventArgs e)
{
VstoContribLog.Debug(_ => _("ViewProvider.NewView Raised, Type: {0}, View: {1}, Context: {2}",
e.RibbonType, e.ViewInstance.ToLogFormat(), e.ViewContext.ToLogFormat()));
if (ribbonUiLookup.ContainsKey("default"))
{
ribbonUiLookup.Add(e.RibbonType, ribbonUiLookup["default"]);
ribbonUiLookup.Remove("default");
}
var viewModel = GetOrCreateViewModel(e.RibbonType, e.ViewContext ?? NullContext.Instance, e.ViewInstance);
if (viewModel == null)
{
return;
}
customTaskPaneRegister.RegisterCustomTaskPanes(viewModel, e.ViewInstance, e.ViewContext);
InvalidateRibbonForViewModel(viewModel);
e.Handled = true;
}
IRibbonViewModel GetOrCreateViewModel(string ribbonType, object viewContext, object viewInstance)
{
if (!ribbonTypeLookup.ContainsKey(ribbonType))
{
return(null);
}
if (contextToViewModelLookup.ContainsKey(viewContext))
{
//Tell viewmodel there is a new view active
var ribbonViewModel = contextToViewModelLookup[viewContext];
VstoContribLog.Debug(_ => _("ViewModel {0} found for context {1}", ribbonViewModel.ToLogFormat(), viewContext.ToLogFormat()));
ribbonViewModel.CurrentView = viewInstance;
return(ribbonViewModel);
}
currentlyLoadingRibbon = ribbonType;
IRibbonViewModel buildViewModel = BuildViewModel(ribbonType, viewInstance, viewContext);
contextToViewModelLookup.Add(viewContext, buildViewModel);
return(buildViewModel);
}
void WordApplicationWindowActivate(Document doc, Window wn)
{
VstoContribLog.Info(_ => _("Application.WindowActivate raised, Document: {0}, Window: {1}",
doc.ToLogFormat(), wn.ToLogFormat()));
if (!documents.ContainsKey(doc))
{
documents.Add(doc, new List <Window>());
var documentWrapper = new DocumentWrapper(doc);
documentWrapper.Closed += DocumentClosed;
documentWrappers.Add(doc, documentWrapper);
}
//Check if we have this window registered
if (documents[doc].Any(window => window == wn))
{
return;
}
documents[doc].Add(wn);
NewView(this, new NewViewEventArgs(wn, doc, WordRibbonType.WordDocument.GetEnumDescription()));
}
void WordApplicationDocumentOpen(Document doc)
{
VstoContribLog.Debug(_ => _("Application.DocumentOpen raised, Document: {0}", doc.ToLogFormat()));
WordApplicationWindowActivate(doc, doc.ActiveWindow);
}
void WorkbookOpen(Workbook wb)
{
VstoContribLog.Debug(log => log("Excel raised WorkbookOpen({0}) event", wb.ToLogFormat()));
OnInitialise(wb);
}
/// <summary>
/// Ribbon_s the load.
/// </summary>
/// <param name="ribbonUi">The ribbon UI.</param>
// ReSharper disable InconsistentNaming
public virtual void Ribbon_Load(IRibbonUI ribbonUi)
{
VstoContribLog.Debug(_ => _("Ribbon_Load event raised: {0}", ribbonUi.ToLogFormat()));
ribbonFactoryController.RibbonLoaded(ribbonUi);
}
