private void ActivateDesktopAlert(Shipment shipment)
{
RadDesktopAlert alert = new RadDesktopAlert();
var closedEventBinding = new EventBinding() { EventName = "Closed", RaiseOnHandledEvents = true};
BindingOperations.SetBinding( closedEventBinding, EventBinding.CommandProperty, new Binding() { Source = (this.DataContext as ViewModel).AlertClosedCommand });
var eventBindings = EventToCommandBehavior.GetEventBindings(alert);
eventBindings.Add(closedEventBinding);
alert.CanMove = false;
switch (shipment.DeliveryType)
{
case DeliveryType.Truck:
alert.Style = this.Resources["TruckStyle"] as Style;
break;
case DeliveryType.Train:
alert.Style = this.Resources["TrainStyle"] as Style;
break;
case DeliveryType.Ship:
alert.Style = this.Resources["ShipStyle"] as Style;
break;
}
alert.DataContext = shipment;
this.manager.ShowAlert(alert);
}
public void ProtectedViewWindowBeforeClose([In, MarshalAs(UnmanagedType.IDispatch)] object protViewWindow, [In] object protectedViewCloseReason, [In][Out] ref object cancel)
{
if (!Validate("ProtectedViewWindowBeforeClose"))
{
Invoker.ReleaseParamsArray(protViewWindow, protectedViewCloseReason, cancel);
return;
}
NetOffice.PowerPointApi.ProtectedViewWindow newProtViewWindow = Factory.CreateKnownObjectFromComProxy <NetOffice.PowerPointApi.ProtectedViewWindow>(EventClass, protViewWindow, NetOffice.PowerPointApi.ProtectedViewWindow.LateBindingApiWrapperType);
NetOffice.PowerPointApi.Enums.PpProtectedViewCloseReason newProtectedViewCloseReason = (NetOffice.PowerPointApi.Enums.PpProtectedViewCloseReason)protectedViewCloseReason;
object[] paramsArray = new object[3];
paramsArray[0] = newProtViewWindow;
paramsArray[1] = newProtectedViewCloseReason;
paramsArray.SetValue(cancel, 2);
EventBinding.RaiseCustomEvent("ProtectedViewWindowBeforeClose", ref paramsArray);
cancel = ToBoolean(paramsArray[2]);
}
public void AfterDragDropOnSlide([In, MarshalAs(UnmanagedType.IDispatch)] object sld, [In] object x, [In] object y)
{
if (!Validate("AfterDragDropOnSlide"))
{
Invoker.ReleaseParamsArray(sld, x, y);
return;
}
NetOffice.PowerPointApi.Slide newSld = Factory.CreateKnownObjectFromComProxy <NetOffice.PowerPointApi.Slide>(EventClass, sld, NetOffice.PowerPointApi.Slide.LateBindingApiWrapperType);
Single newX = ToSingle(x);
Single newY = ToSingle(y);
object[] paramsArray = new object[3];
paramsArray[0] = newSld;
paramsArray[1] = newX;
paramsArray[2] = newY;
EventBinding.RaiseCustomEvent("AfterDragDropOnSlide", ref paramsArray);
}
public void Select([In] object elementID, [In] object arg1, [In] object arg2)
{
if (!Validate("Select"))
{
Invoker.ReleaseParamsArray(elementID, arg1, arg2);
return;
}
Int32 newElementID = ToInt32(elementID);
Int32 newArg1 = ToInt32(arg1);
Int32 newArg2 = ToInt32(arg2);
object[] paramsArray = new object[3];
paramsArray[0] = newElementID;
paramsArray[1] = newArg1;
paramsArray[2] = newArg2;
EventBinding.RaiseCustomEvent("Select", ref paramsArray);
}
/// <summary>
///
/// </summary>
/// <param name="sh"></param>
/// <param name="targetPivotTable"></param>
/// <param name="targetRange"></param>
public void SheetPivotTableAfterValueChange([In, MarshalAs(UnmanagedType.IDispatch)] object sh, [In, MarshalAs(UnmanagedType.IDispatch)] object targetPivotTable, [In, MarshalAs(UnmanagedType.IDispatch)] object targetRange)
{
if (!Validate("SheetPivotTableAfterValueChange"))
{
Invoker.ReleaseParamsArray(sh, targetPivotTable, targetRange);
return;
}
object newSh = Factory.CreateEventArgumentObjectFromComProxy(EventClass, sh) as object;
NetOffice.ExcelApi.PivotTable newTargetPivotTable = Factory.CreateKnownObjectFromComProxy <NetOffice.ExcelApi.PivotTable>(EventClass, targetPivotTable, typeof(NetOffice.ExcelApi.PivotTable));
NetOffice.ExcelApi.Range newTargetRange = Factory.CreateKnownObjectFromComProxy <NetOffice.ExcelApi.Range>(EventClass, targetRange, typeof(NetOffice.ExcelApi.Range));
object[] paramsArray = new object[3];
paramsArray[0] = newSh;
paramsArray[1] = newTargetPivotTable;
paramsArray[2] = newTargetRange;
EventBinding.RaiseCustomEvent("SheetPivotTableAfterValueChange", ref paramsArray);
}
/// <summary>
///
/// </summary>
/// <param name="fMoreData"></param>
/// <param name="adStatus"></param>
/// <param name="pRecordset"></param>
public virtual void EndOfRecordset([In][Out] ref object fMoreData, [In] object adStatus, [In, MarshalAs(UnmanagedType.IDispatch)] object pRecordset)
{
if (!Validate("EndOfRecordset"))
{
Invoker.ReleaseParamsArray(fMoreData, adStatus, pRecordset);
return;
}
NetOffice.ADODBApi.Enums.EventStatusEnum newadStatus = (NetOffice.ADODBApi.Enums.EventStatusEnum)adStatus;
NetOffice.ADODBApi._Recordset newpRecordset = Factory.CreateEventArgumentObjectFromComProxy(EventClass, pRecordset) as NetOffice.ADODBApi._Recordset;
object[] paramsArray = new object[3];
paramsArray.SetValue(fMoreData, 0);
paramsArray[1] = newadStatus;
paramsArray[2] = newpRecordset;
EventBinding.RaiseCustomEvent("EndOfRecordset", ref paramsArray);
fMoreData = ToBoolean(paramsArray[0]);
}
/// <summary>
///
/// </summary>
/// <param name="drawObject"></param>
/// <param name="chartObject"></param>
/// <param name="cancel"></param>
public void BeforeRender([In, MarshalAs(UnmanagedType.IDispatch)] object drawObject, [In, MarshalAs(UnmanagedType.IDispatch)] object chartObject, [In, MarshalAs(UnmanagedType.IDispatch)] object cancel)
{
if (!Validate("BeforeRender"))
{
Invoker.ReleaseParamsArray(drawObject, chartObject, cancel);
return;
}
object newdrawObject = Factory.CreateEventArgumentObjectFromComProxy(EventClass, drawObject) as object;
object newchartObject = Factory.CreateEventArgumentObjectFromComProxy(EventClass, chartObject) as object;
object newCancel = Factory.CreateEventArgumentObjectFromComProxy(EventClass, cancel) as object;
object[] paramsArray = new object[3];
paramsArray[0] = newdrawObject;
paramsArray[1] = newchartObject;
paramsArray[2] = newCancel;
EventBinding.RaiseCustomEvent("BeforeRender", ref paramsArray);
}
public void XMLBeforeDelete([In, MarshalAs(UnmanagedType.IDispatch)] object deletedRange, [In, MarshalAs(UnmanagedType.IDispatch)] object oldXMLNode, [In] object inUndoRedo)
{
if (!Validate("XMLBeforeDelete"))
{
Invoker.ReleaseParamsArray(deletedRange, oldXMLNode, inUndoRedo);
return;
}
NetOffice.WordApi.Range newDeletedRange = Factory.CreateKnownObjectFromComProxy <NetOffice.WordApi.Range>(EventClass, deletedRange, NetOffice.WordApi.Range.LateBindingApiWrapperType);
NetOffice.WordApi.XMLNode newOldXMLNode = Factory.CreateKnownObjectFromComProxy <NetOffice.WordApi.XMLNode>(EventClass, oldXMLNode, NetOffice.WordApi.XMLNode.LateBindingApiWrapperType);
bool newInUndoRedo = Convert.ToBoolean(inUndoRedo);
object[] paramsArray = new object[3];
paramsArray[0] = newDeletedRange;
paramsArray[1] = newOldXMLNode;
paramsArray[2] = newInUndoRedo;
EventBinding.RaiseCustomEvent("XMLBeforeDelete", ref paramsArray);
}
public void ShapeLinkDeleted([In, MarshalAs(UnmanagedType.IDispatch)] object shape, [In] object dataRecordsetID, [In] object dataRowID)
{
if (!Validate("ShapeLinkDeleted"))
{
Invoker.ReleaseParamsArray(shape, dataRecordsetID, dataRowID);
return;
}
NetOffice.VisioApi.IVShape newShape = Factory.CreateEventArgumentObjectFromComProxy(EventClass, shape) as NetOffice.VisioApi.IVShape;
Int32 newDataRecordsetID = ToInt32(dataRecordsetID);
Int32 newDataRowID = ToInt32(dataRowID);
object[] paramsArray = new object[3];
paramsArray[0] = newShape;
paramsArray[1] = newDataRecordsetID;
paramsArray[2] = newDataRowID;
EventBinding.RaiseCustomEvent("ShapeLinkDeleted", ref paramsArray);
}
/// <summary>
///
/// </summary>
/// <param name="drawObject"></param>
/// <param name="chartObject"></param>
/// <param name="cancel"></param>
public void BeforeRender([In, MarshalAs(UnmanagedType.IDispatch)] object drawObject, [In, MarshalAs(UnmanagedType.IDispatch)] object chartObject, [In, MarshalAs(UnmanagedType.IDispatch)] object cancel)
{
if (!Validate("BeforeRender"))
{
Invoker.ReleaseParamsArray(drawObject, chartObject, cancel);
return;
}
NetOffice.OWC10Api.ChChartDraw newdrawObject = Factory.CreateKnownObjectFromComProxy <NetOffice.OWC10Api.ChChartDraw>(EventClass, drawObject, typeof(NetOffice.OWC10Api.ChChartDraw));
object newchartObject = Factory.CreateEventArgumentObjectFromComProxy(EventClass, chartObject) as object;
NetOffice.OWC10Api.ByRef newCancel = Factory.CreateKnownObjectFromComProxy <NetOffice.OWC10Api.ByRef>(EventClass, cancel, typeof(NetOffice.OWC10Api.ByRef));
object[] paramsArray = new object[3];
paramsArray[0] = newdrawObject;
paramsArray[1] = newchartObject;
paramsArray[2] = newCancel;
EventBinding.RaiseCustomEvent("BeforeRender", ref paramsArray);
}
/// <summary>
///
/// </summary>
/// <param name="keyCode"></param>
/// <param name="shift"></param>
/// <param name="cancel"></param>
public void BeforeKeyUp([In] object keyCode, [In] object shift, [In, MarshalAs(UnmanagedType.IDispatch)] object cancel)
{
if (!Validate("BeforeKeyUp"))
{
Invoker.ReleaseParamsArray(keyCode, shift, cancel);
return;
}
Int32 newKeyCode = Convert.ToInt32(keyCode);
Int32 newShift = Convert.ToInt32(shift);
NetOffice.OWC10Api.ByRef newCancel = Factory.CreateKnownObjectFromComProxy <NetOffice.OWC10Api.ByRef>(EventClass, cancel, typeof(NetOffice.OWC10Api.ByRef));
object[] paramsArray = new object[3];
paramsArray[0] = newKeyCode;
paramsArray[1] = newShift;
paramsArray[2] = newCancel;
EventBinding.RaiseCustomEvent("BeforeKeyUp", ref paramsArray);
}
public void MouseOver([In] object button, [In] object shift, [In, MarshalAs(UnmanagedType.IDispatch)] object target)
{
if (!Validate("MouseOver"))
{
Invoker.ReleaseParamsArray(button, shift, target);
return;
}
Int32 newButton = Convert.ToInt32(button);
Int32 newShift = Convert.ToInt32(shift);
NetOffice.OWC10Api._Range newTarget = Factory.CreateEventArgumentObjectFromComProxy(EventClass, target) as NetOffice.OWC10Api._Range;
object[] paramsArray = new object[3];
paramsArray[0] = newButton;
paramsArray[1] = newShift;
paramsArray[2] = newTarget;
EventBinding.RaiseCustomEvent("MouseOver", ref paramsArray);
}
public void MouseUp([In] object button, [In] object shift, [In] object x, [In] object y)
{
if (!Validate("MouseUp"))
{
Invoker.ReleaseParamsArray(button, shift, x, y);
return;
}
NetOffice.OutlookApi.Enums.OlMouseButton newButton = (NetOffice.OutlookApi.Enums.OlMouseButton)button;
NetOffice.OutlookApi.Enums.OlShiftState newShift = (NetOffice.OutlookApi.Enums.OlShiftState)shift;
Single newX = ToSingle(x);
Single newY = ToSingle(y);
object[] paramsArray = new object[4];
paramsArray[0] = newButton;
paramsArray[1] = newShift;
paramsArray[2] = newX;
paramsArray[3] = newY;
EventBinding.RaiseCustomEvent("MouseUp", ref paramsArray);
}
/// <summary>
///
/// </summary>
/// <param name="wb"></param>
/// <param name="saveAsUI"></param>
/// <param name="cancel"></param>
public void WorkbookBeforeSave([In, MarshalAs(UnmanagedType.IDispatch)] object wb, [In] object saveAsUI, [In][Out] ref object cancel)
{
if (!Validate("WorkbookBeforeSave"))
{
Invoker.ReleaseParamsArray(wb, saveAsUI, cancel);
return;
}
NetOffice.ExcelApi.Workbook newWb = Factory.CreateKnownObjectFromComProxy <NetOffice.ExcelApi.Workbook>(EventClass, wb, typeof(NetOffice.ExcelApi.Workbook));
bool newSaveAsUI = ToBoolean(saveAsUI);
object[] paramsArray = new object[3];
paramsArray[0] = newWb;
paramsArray[1] = newSaveAsUI;
paramsArray.SetValue(cancel, 2);
EventBinding.RaiseCustomEvent("WorkbookBeforeSave", ref paramsArray);
cancel = ToBoolean(paramsArray[2]);
}
public void BeforeItemPaste([In][Out] ref object clipboardContent, [In, MarshalAs(UnmanagedType.IDispatch)] object target, [In][Out] ref object cancel)
{
if (!Validate("BeforeItemPaste"))
{
Invoker.ReleaseParamsArray(clipboardContent, target, cancel);
return;
}
NetOffice.OutlookApi.MAPIFolder newTarget = Factory.CreateEventArgumentObjectFromComProxy(EventClass, target) as NetOffice.OutlookApi.MAPIFolder;
object[] paramsArray = new object[3];
paramsArray.SetValue(clipboardContent, 0);
paramsArray[1] = newTarget;
paramsArray.SetValue(cancel, 2);
EventBinding.RaiseCustomEvent("BeforeItemPaste", ref paramsArray);
clipboardContent = (object)paramsArray[0];
cancel = ToBoolean(paramsArray[2]);
}
public void CustomAction([In, MarshalAs(UnmanagedType.IDispatch)] object action, [In, MarshalAs(UnmanagedType.IDispatch)] object response, [In][Out] ref object cancel)
{
if (!Validate("CustomAction"))
{
Invoker.ReleaseParamsArray(action, response, cancel);
return;
}
object newAction = Factory.CreateEventArgumentObjectFromComProxy(EventClass, action) as object;
object newResponse = Factory.CreateEventArgumentObjectFromComProxy(EventClass, response) as object;
object[] paramsArray = new object[3];
paramsArray[0] = newAction;
paramsArray[1] = newResponse;
paramsArray.SetValue(cancel, 2);
EventBinding.RaiseCustomEvent("CustomAction", ref paramsArray);
cancel = ToBoolean(paramsArray[2]);
}
/// <summary>
///
/// </summary>
/// <param name="keyCode"></param>
/// <param name="keyButtonState"></param>
/// <param name="cancelDefault"></param>
public void KeyUp([In] object keyCode, [In] object keyButtonState, [In][Out] ref object cancelDefault)
{
if (!Validate("KeyUp"))
{
Invoker.ReleaseParamsArray(keyCode, keyButtonState, cancelDefault);
return;
}
Int32 newKeyCode = ToInt32(keyCode);
Int32 newKeyButtonState = ToInt32(keyButtonState);
object[] paramsArray = new object[3];
paramsArray[0] = newKeyCode;
paramsArray[1] = newKeyButtonState;
paramsArray.SetValue(cancelDefault, 2);
EventBinding.RaiseCustomEvent("KeyUp", ref paramsArray);
cancelDefault = ToBoolean(paramsArray[2]);
}
public void MoveComplete([In] object adReason, [In, MarshalAs(UnmanagedType.IDispatch)] object pError, [In] object adStatus, [In, MarshalAs(UnmanagedType.IDispatch)] object pRecordset)
{
if (!Validate("MoveComplete"))
{
Invoker.ReleaseParamsArray(adReason, pError, adStatus, pRecordset);
return;
}
NetOffice.ADODBApi.Enums.EventReasonEnum newadReason = (NetOffice.ADODBApi.Enums.EventReasonEnum)adReason;
NetOffice.ADODBApi.Error newpError = Factory.CreateKnownObjectFromComProxy <NetOffice.ADODBApi.Error>(EventClass, pError, NetOffice.ADODBApi.Error.LateBindingApiWrapperType);
NetOffice.ADODBApi.Enums.EventStatusEnum newadStatus = (NetOffice.ADODBApi.Enums.EventStatusEnum)adStatus;
NetOffice.ADODBApi._Recordset newpRecordset = Factory.CreateEventArgumentObjectFromComProxy(EventClass, pRecordset) as NetOffice.ADODBApi._Recordset;
object[] paramsArray = new object[4];
paramsArray[0] = newadReason;
paramsArray[1] = newpError;
paramsArray[2] = newadStatus;
paramsArray[3] = newpRecordset;
EventBinding.RaiseCustomEvent("MoveComplete", ref paramsArray);
}
public void BeforeXmlExport([In, MarshalAs(UnmanagedType.IDispatch)] object map, [In] object url, [In][Out] ref object cancel)
{
if (!Validate("BeforeXmlExport"))
{
Invoker.ReleaseParamsArray(map, url, cancel);
return;
}
NetOffice.ExcelApi.XmlMap newMap = Factory.CreateKnownObjectFromComProxy <NetOffice.ExcelApi.XmlMap>(EventClass, map, NetOffice.ExcelApi.XmlMap.LateBindingApiWrapperType);
string newUrl = ToString(url);
object[] paramsArray = new object[3];
paramsArray[0] = newMap;
paramsArray[1] = newUrl;
paramsArray.SetValue(cancel, 2);
EventBinding.RaiseCustomEvent("BeforeXmlExport", ref paramsArray);
cancel = ToBoolean(paramsArray[2]);
}
public void BeforeItemMove([In, MarshalAs(UnmanagedType.IDispatch)] object item, [In, MarshalAs(UnmanagedType.IDispatch)] object moveTo, [In][Out] ref object cancel)
{
if (!Validate("BeforeItemMove"))
{
Invoker.ReleaseParamsArray(item, moveTo, cancel);
return;
}
object newItem = Factory.CreateEventArgumentObjectFromComProxy(EventClass, item) as object;
NetOffice.OutlookApi.MAPIFolder newMoveTo = Factory.CreateEventArgumentObjectFromComProxy(EventClass, moveTo) as NetOffice.OutlookApi.MAPIFolder;
object[] paramsArray = new object[3];
paramsArray[0] = newItem;
paramsArray[1] = newMoveTo;
paramsArray.SetValue(cancel, 2);
EventBinding.RaiseCustomEvent("BeforeItemMove", ref paramsArray);
cancel = ToBoolean(paramsArray[2]);
}
public void SheetBeforeRightClick([In, MarshalAs(UnmanagedType.IDispatch)] object sh, [In, MarshalAs(UnmanagedType.IDispatch)] object target, [In][Out] ref object cancel)
{
if (!Validate("SheetBeforeRightClick"))
{
Invoker.ReleaseParamsArray(sh, target, cancel);
return;
}
object newSh = Factory.CreateEventArgumentObjectFromComProxy(EventClass, sh) as object;
NetOffice.ExcelApi.Range newTarget = Factory.CreateKnownObjectFromComProxy <NetOffice.ExcelApi.Range>(EventClass, target, NetOffice.ExcelApi.Range.LateBindingApiWrapperType);
object[] paramsArray = new object[3];
paramsArray[0] = newSh;
paramsArray[1] = newTarget;
paramsArray.SetValue(cancel, 2);
EventBinding.RaiseCustomEvent("SheetBeforeRightClick", ref paramsArray);
cancel = ToBoolean(paramsArray[2]);
}
/// <summary>
///
/// </summary>
/// <param name="pvWindow"></param>
/// <param name="closeReason"></param>
/// <param name="cancel"></param>
public void ProtectedViewWindowBeforeClose([In, MarshalAs(UnmanagedType.IDispatch)] object pvWindow, [In] object closeReason, [In][Out] ref object cancel)
{
if (!Validate("ProtectedViewWindowBeforeClose"))
{
Invoker.ReleaseParamsArray(pvWindow, closeReason, cancel);
return;
}
NetOffice.WordApi.ProtectedViewWindow newPvWindow = Factory.CreateKnownObjectFromComProxy <NetOffice.WordApi.ProtectedViewWindow>(EventClass, pvWindow, typeof(NetOffice.WordApi.ProtectedViewWindow));
Int32 newCloseReason = ToInt32(closeReason);
object[] paramsArray = new object[3];
paramsArray[0] = newPvWindow;
paramsArray[1] = newCloseReason;
paramsArray.SetValue(cancel, 2);
EventBinding.RaiseCustomEvent("ProtectedViewWindowBeforeClose", ref paramsArray);
cancel = ToBoolean(paramsArray[2]);
}
public void Click([In, MarshalAs(UnmanagedType.IDispatch)] object commandBarControl, [In][Out] ref object handled, [In][Out] ref object cancelDefault)
{
if (!Validate("Click"))
{
Invoker.ReleaseParamsArray(commandBarControl, handled, cancelDefault);
return;
}
object newCommandBarControl = Factory.CreateEventArgumentObjectFromComProxy(EventClass, commandBarControl) as object;
object[] paramsArray = new object[3];
paramsArray[0] = newCommandBarControl;
paramsArray.SetValue(handled, 1);
paramsArray.SetValue(cancelDefault, 2);
EventBinding.RaiseCustomEvent("Click", ref paramsArray);
handled = ToBoolean(paramsArray[1]);
cancelDefault = ToBoolean(paramsArray[2]);
}
public void TestMapOneArgumentCallback()
{
confirmationValue = INIT_VALUE;
IEventBinding binding = new EventBinding();
binding.Key(SomeEnum.ONE).To(oneArgumentCallback);
EventCallbackType type = binding.typeForCallback(oneArgumentCallback);
object[] value = binding.value as object[];
Delegate extracted = value[0] as Delegate;
Assert.AreEqual(EventCallbackType.ONE_ARGUMENT, type);
object[] parameters = new object[1];
parameters [0] = new TestEvent("TEST", null, INIT_VALUE);
extracted.DynamicInvoke(parameters);
//Calling the method should change the confirmationValue
Assert.AreEqual(confirmationValue, INIT_VALUE * INIT_VALUE);
}
/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="menu"></param>
/// <param name="cancel"></param>
public void BeforeContextMenu([In] object x, [In] object y, [In, MarshalAs(UnmanagedType.IDispatch)] object menu, [In, MarshalAs(UnmanagedType.IDispatch)] object cancel)
{
if (!Validate("BeforeContextMenu"))
{
Invoker.ReleaseParamsArray(x, y, menu, cancel);
return;
}
Int32 newx = ToInt32(x);
Int32 newy = ToInt32(y);
NetOffice.OWC10Api.ByRef newMenu = Factory.CreateKnownObjectFromComProxy <NetOffice.OWC10Api.ByRef>(EventClass, menu, typeof(NetOffice.OWC10Api.ByRef));
NetOffice.OWC10Api.ByRef newCancel = Factory.CreateKnownObjectFromComProxy <NetOffice.OWC10Api.ByRef>(EventClass, cancel, typeof(NetOffice.OWC10Api.ByRef));
object[] paramsArray = new object[4];
paramsArray[0] = newx;
paramsArray[1] = newy;
paramsArray[2] = newMenu;
paramsArray[3] = newCancel;
EventBinding.RaiseCustomEvent("BeforeContextMenu", ref paramsArray);
}
/// <summary>
///
/// </summary>
/// <param name="button"></param>
/// <param name="shift"></param>
/// <param name="x"></param>
/// <param name="y"></param>
public void MouseUp([In] object button, [In] object shift, [In] object x, [In] object y)
{
if (!Validate("MouseUp"))
{
Invoker.ReleaseParamsArray(button, shift, x, y);
return;
}
Int32 newButton = ToInt32(button);
Int32 newShift = ToInt32(shift);
Int32 newx = ToInt32(x);
Int32 newy = ToInt32(y);
object[] paramsArray = new object[4];
paramsArray[0] = newButton;
paramsArray[1] = newShift;
paramsArray[2] = newx;
paramsArray[3] = newy;
EventBinding.RaiseCustomEvent("MouseUp", ref paramsArray);
}
/// <summary>
///
/// </summary>
/// <param name="accept"></param>
/// <param name="finalValue"></param>
/// <param name="cancel"></param>
/// <param name="errorDescription"></param>
public void EndEdit([In] object accept, [In, MarshalAs(UnmanagedType.IDispatch)] object finalValue, [In, MarshalAs(UnmanagedType.IDispatch)] object cancel, [In, MarshalAs(UnmanagedType.IDispatch)] object errorDescription)
{
if (!Validate("EndEdit"))
{
Invoker.ReleaseParamsArray(accept, finalValue, cancel, errorDescription);
return;
}
bool newAccept = ToBoolean(accept);
NetOffice.OWC10Api.ByRef newFinalValue = Factory.CreateKnownObjectFromComProxy <NetOffice.OWC10Api.ByRef>(EventClass, finalValue, typeof(NetOffice.OWC10Api.ByRef));
NetOffice.OWC10Api.ByRef newCancel = Factory.CreateKnownObjectFromComProxy <NetOffice.OWC10Api.ByRef>(EventClass, cancel, typeof(NetOffice.OWC10Api.ByRef));
NetOffice.OWC10Api.ByRef newErrorDescription = Factory.CreateKnownObjectFromComProxy <NetOffice.OWC10Api.ByRef>(EventClass, errorDescription, typeof(NetOffice.OWC10Api.ByRef));
object[] paramsArray = new object[4];
paramsArray[0] = newAccept;
paramsArray[1] = newFinalValue;
paramsArray[2] = newCancel;
paramsArray[3] = newErrorDescription;
EventBinding.RaiseCustomEvent("EndEdit", ref paramsArray);
}
/// <summary>
///
/// </summary>
/// <param name="button"></param>
/// <param name="shift"></param>
/// <param name="x"></param>
/// <param name="y"></param>
public void MouseUp([In][Out] ref object button, [In][Out] ref object shift, [In][Out] ref object x, [In][Out] ref object y)
{
if (!Validate("MouseUp"))
{
Invoker.ReleaseParamsArray(button, shift, x, y);
return;
}
object[] paramsArray = new object[4];
paramsArray.SetValue(button, 0);
paramsArray.SetValue(shift, 1);
paramsArray.SetValue(x, 2);
paramsArray.SetValue(y, 3);
EventBinding.RaiseCustomEvent("MouseUp", ref paramsArray);
button = ToInt16(paramsArray[0]);
shift = ToInt16(paramsArray[1]);
x = ToSingle(paramsArray[2]);
y = ToSingle(paramsArray[3]);
}
public void XMLSelectionChange([In, MarshalAs(UnmanagedType.IDispatch)] object sel, [In, MarshalAs(UnmanagedType.IDispatch)] object oldXMLNode, [In, MarshalAs(UnmanagedType.IDispatch)] object newXMLNode, [In][Out] ref object reason)
{
if (!Validate("XMLSelectionChange"))
{
Invoker.ReleaseParamsArray(sel, oldXMLNode, newXMLNode, reason);
return;
}
NetOffice.WordApi.Selection newSel = Factory.CreateKnownObjectFromComProxy <NetOffice.WordApi.Selection>(EventClass, sel, NetOffice.WordApi.Selection.LateBindingApiWrapperType);
NetOffice.WordApi.XMLNode newOldXMLNode = Factory.CreateKnownObjectFromComProxy <NetOffice.WordApi.XMLNode>(EventClass, oldXMLNode, NetOffice.WordApi.XMLNode.LateBindingApiWrapperType);
NetOffice.WordApi.XMLNode newNewXMLNode = Factory.CreateKnownObjectFromComProxy <NetOffice.WordApi.XMLNode>(EventClass, newXMLNode, NetOffice.WordApi.XMLNode.LateBindingApiWrapperType);
object[] paramsArray = new object[4];
paramsArray[0] = newSel;
paramsArray[1] = newOldXMLNode;
paramsArray[2] = newNewXMLNode;
paramsArray.SetValue(reason, 3);
EventBinding.RaiseCustomEvent("XMLSelectionChange", ref paramsArray);
reason = ToInt32(paramsArray[3]);
}
public void MailMergeWizardStateChange([In, MarshalAs(UnmanagedType.IDispatch)] object doc, [In][Out] ref object fromState, [In][Out] ref object toState, [In][Out] ref object handled)
{
if (!Validate("MailMergeWizardStateChange"))
{
Invoker.ReleaseParamsArray(doc, fromState, toState, handled);
return;
}
NetOffice.WordApi.Document newDoc = Factory.CreateKnownObjectFromComProxy <NetOffice.WordApi.Document>(EventClass, doc, NetOffice.WordApi.Document.LateBindingApiWrapperType);
object[] paramsArray = new object[4];
paramsArray[0] = newDoc;
paramsArray.SetValue(fromState, 1);
paramsArray.SetValue(toState, 2);
paramsArray.SetValue(handled, 3);
EventBinding.RaiseCustomEvent("MailMergeWizardStateChange", ref paramsArray);
fromState = ToInt32(paramsArray[1]);
toState = ToInt32(paramsArray[2]);
handled = ToBoolean(paramsArray[3]);
}
/// <summary>
///
/// </summary>
/// <param name="button"></param>
/// <param name="shift"></param>
/// <param name="x"></param>
/// <param name="y"></param>
public void MouseMove([In] object button, [In] object shift, [In] object x, [In] object y)
{
if (!Validate("MouseMove"))
{
Invoker.ReleaseParamsArray(button, shift, x, y);
return;
}
Int16 newButton = ToInt16(button);
Int16 newShift = ToInt16(shift);
Single newX = ToSingle(x);
Single newY = ToSingle(y);
object[] paramsArray = new object[4];
paramsArray[0] = newButton;
paramsArray[1] = newShift;
paramsArray[2] = newX;
paramsArray[3] = newY;
EventBinding.RaiseCustomEvent("MouseMove", ref paramsArray);
}
public ListensToEvents()
{
_binding = GlobalEventStream.Events.AddEventHandler<GlobalEvent>(HandleEvent);
}
private void OnEvent(IntPtr client, int ev, IntPtr ex_data, IntPtr arg1_ptr, IntPtr arg2_ptr)
{
#if DEBUG
Log(string.Format("OnEvent - pinvoke callback START | ev={0}", EvToStr(ev)));
#endif
var arg1 = Marshal.PtrToStringAuto(arg1_ptr);
var arg2 = Marshal.PtrToStringAuto(arg2_ptr);
UnityThreadHelper.Dispatcher.Dispatch(()=>{
#if DEBUG
Log(string.Format("OnEvent - main thread START | arg1={0}, arg2={1}", arg1, arg2));
#endif
try {
switch(ev)
{
case PC_EV_USER_DEFINED_PUSH:
if(eventHandlers.ContainsKey(arg1))
{
var source = eventHandlers[arg1];
EventBinding[] bindings = new EventBinding[source.Count];
source.CopyTo(bindings);
foreach(var bind in bindings)
{
bind.handler(arg2);
if(bind.once)
RemoveEventHandler(arg1, bind.handler, true);
}
}
break;
case PC_EV_CONNECTED:
OnConnectSuccess();
break;
case PC_EV_CONNECT_ERROR:
OnConnectFail(arg1);
break;
case PC_EV_CONNECT_FAILED:
OnConnectFail(arg1);
break;
case PC_EV_DISCONNECT:
OnDisconnect(null); // probably disconnect by client self
break;
case PC_EV_KICKED_BY_SERVER:
OnDisconnect(EvToStr(ev));
break;
case PC_EV_UNEXPECTED_DISCONNECT:
OnError(arg1);
break;
case PC_EV_PROTO_ERROR:
OnError(arg1);
break;
}
} catch (Exception ex) {
LogError("OnEvent - main thread EXCEPTION |\n" + ex.ToString());
}
#if DEBUG
Log(string.Format("OnEvent - main thread END"));
#endif
});
#if DEBUG
Log(string.Format("OnEvent - pinvoke callback END"));
#endif
}
public void RemoveEventHandler(string eventName, Action<string> handler, bool once = false)
{
if(! eventHandlers.ContainsKey(eventName))
return;
var e = new EventBinding{
handler = handler,
once = once,
};
eventHandlers[eventName].Remove(e);
}
public static void Main()
{
PopulatedOrganization wonkaFactory = new PopulatedOrganization();
Organization chocolateDepartment = new Organization();
#region SINGLE OBJECT EVENT BINDING
// create the event binding for single object
EventBinding<Organization, string> eventBinding =
new EventBinding<Organization, string>();
// specify the source object and the path to the source binding property that contains the event
// we want to bind to
eventBinding.SourceObj = wonkaFactory;
eventBinding.SourcePathLinks =
StringCodePathResolver.ResolveStringPath("TheMostImportantDepartment").ToList();
// do the binding itself
eventBinding.Bind();
// specify the event name (it can be done either before or after bind()
// method is called
eventBinding.EventName = "SomethingHappenedInOrgEvent";
// add the event hanlder whose signature is similar to that of
// SomethingHappenedInOrgEvent event to the binding
eventBinding.TheEvent += eventBinding_SomethingHappenedInTheDepartment;
// nothing is printed to the console because wonkaFactory.TheMostImportantDepartment
// is still not set to chocolateDepartment object
chocolateDepartment.FireSomethingHappenedEvent("Augustus Gloop went to the chocolate creek. (Before the department added - should not show)" );
// set wonkaFactory.TheMostImportantDepartment
wonkaFactory.TheMostImportantDepartment = chocolateDepartment;
// this message is printed on the console
chocolateDepartment.FireSomethingHappenedEvent("Augustus Gloop is out of the game (should show)");
// unbind the event
eventBinding.Unbind();
#endregion SINGLE OBJECT EVENT BINDING
#region COLLECTION EVENT BINDING
// create the collection AllDepartments
wonkaFactory.AllDepartments = new ObservableCollection<Organization>();
// add chocolate department to it
wonkaFactory.AllDepartments.Add(chocolateDepartment);
// create collection event binding
CollectionEventBinding<Organization, string> collectionEventBinding =
new CollectionEventBinding<Organization, string>();
// set the objects that contain the event we want to bind to
// to be "AllDepartments" collection property of "wonkaFactory" object
collectionEventBinding.SourceObj = wonkaFactory;
collectionEventBinding.SourcePathLinks =
StringCodePathResolver.ResolveStringPath("AllDepartments").ToList();
// bind the event
collectionEventBinding.Bind();
// set the event name (can be done before or after the binding)
collectionEventBinding.EventName = "SomethingHappenedInOrgEvent";
// add event handler
collectionEventBinding.TheEvent += collectionEventBinding_TheEvent;
// create gumDepartment
Organization gumDepartment = new Organization();
// fire an event (should not be handled since gumDepartment is not part of the collection yet)
gumDepartment.FireSomethingHappenedEvent("We had great sales (Before the department is added - should not show)");
// Add gum department to the collection
wonkaFactory.AllDepartments.Add(gumDepartment);
// fire the event (should be handled, since now gumDepartment is part of the collection)
gumDepartment.FireSomethingHappenedEvent("We had great sales (After the department is added - should show)");
// remove gum department from All Department collection
// collectionEventBinding should be sufficiently smart to disconnect
// the event of gumDepartment object from the handler
wonkaFactory.AllDepartments.Remove(gumDepartment);
// fire the event again - (the handler should not run, since gumDepartment has been removed from the collection)
gumDepartment.FireSomethingHappenedEvent("We had great sales (After the department is Removed - should not show)");
#endregion COLLECTION EVENT BINDING
}
public void AddEventHandler(string eventName, Action<string> handler, bool once = false)
{
var e = new EventBinding{
handler = handler,
once = once,
};
if(! eventHandlers.ContainsKey(eventName))
eventHandlers.Add(eventName, new List<EventBinding>());
if(! eventHandlers[eventName].Contains(e))
eventHandlers[eventName].Add(e);
}
