private unsafe static int TryExcelImpl12(int xlFunction, out object result, params object[] parameters)
{
int xlReturn;
// Set up the memory to hold the result from the call
XlOper12 resultOper = new XlOper12();
resultOper.xlType = XlType12.XlTypeEmpty;
XlOper12 *pResultOper = &resultOper; // No need to pin for local struct
// Special kind of ObjectArrayMarshaler for the parameters (rank 1)
using (XlMarshalXlOperArrayContext paramMarshaler
= new XlMarshalXlOperArrayContext(1, true))
{
XlOper12 **ppOperParameters = (XlOper12 **)paramMarshaler.ObjectArrayReturn(parameters);
xlReturn = Excel12v(xlFunction, parameters.Length, ppOperParameters, pResultOper);
}
// pResultOper now holds the result of the evaluated function
// Get ObjectMarshaler for the return value
result = XlMarshalContext.ObjectParam((IntPtr)pResultOper);
// And free any memory allocated by Excel
Excel12v(xlFree, 1, &pResultOper, (XlOper12 *)IntPtr.Zero);
return(xlReturn);
}
// This is the function we register with Excel
// All the IntPtrs are XLOPER12*
public unsafe XlOper12 *RtdWrapper(XlOper12 *topic1, XlOper12 *topic2, XlOper12 *topic3, XlOper12 *topic4,
XlOper12 *topic5, XlOper12 *topic6, XlOper12 *topic7, XlOper12 *topic8)
{
var callParamIndex = 2;
_callParams[2] = topic1;
_callParams[3] = topic2;
_callParams[4] = topic3;
_callParams[5] = topic4;
_callParams[6] = topic5;
_callParams[7] = topic6;
_callParams[8] = topic7;
_callParams[9] = topic8;
callParamIndex = 9;
int countParams = LastNonMissingIndex(_callParams, callParamIndex) + 1;
try
{
int xlReturn = XlCallImpl.Excel12v(XlCallImpl.xlfRtd, countParams, _callParams, _resultXloper12);
if (xlReturn == 0) // xlReturnSuccess)
{
_resultXloper12->xlType |= XlType12.XlBitXLFree;
return(_resultXloper12);
}
}
catch (Exception e)
{
Logger.Initialization.Error(e, "RTD call from wrapper failed with Exception");
}
return(_errorValueXloper12);
}
public unsafe static uint GetCurrentSheetId12()
{
XlOper12 SRef = new XlOper12();
SRef.xlType = XlType12.XlTypeSReference;
//SRef.srefValue.Count = 1;
//SRef.srefValue.Reference.RowFirst = 1;
//SRef.srefValue.Reference.RowLast = 1;
//SRef.srefValue.Reference.ColumnFirst = 1;
//SRef.srefValue.Reference.ColumnLast = 1;
XlOper12 resultOper = new XlOper12();
XlOper12 *pResultOper = &resultOper;
XlOper12 * pSRef = &SRef;
XlOper12 **ppSRef = &(pSRef);
int xlReturn;
xlReturn = Excel12v(xlSheetNm, 1, ppSRef, pResultOper);
if (xlReturn == 0)
{
XlOper12 ResultRef = new XlOper12();
xlReturn = Excel12v(xlSheetId, 1, (XlOper12 **)&(pResultOper), &ResultRef);
if (xlReturn == 0 && ResultRef.xlType == XlType12.XlTypeReference)
{
return(ResultRef.refValue.SheetId);
}
}
return(0);
}
private unsafe static int TryExcelImpl12(int xlFunction, out object result, params object[] parameters)
{
int xlReturn;
// Set up the memory to hold the result from the call
XlOper12 resultOper = new XlOper12();
resultOper.xlType = XlType12.XlTypeEmpty;
int i = sizeof(XlOper12);
XlOper12 *pResultOper = &resultOper; // No need to pin for local struct
// Special kind of ObjectArrayMarshaler for the parameters (rank 1)
using (XlObjectArray12Marshaler paramMarshaler = new XlObjectArray12Marshaler(1, true))
{
XlOper12 **ppOperParameters = (XlOper12 **)paramMarshaler.MarshalManagedToNative(parameters);
xlReturn = Excel12v(xlFunction, parameters.Length, ppOperParameters, pResultOper);
}
// pResultOper now holds the result of the evaluated function
// Get ObjectMarshaler for the return value
ICustomMarshaler m = XlObject12Marshaler.GetInstance("");
result = m.MarshalNativeToManaged((IntPtr)pResultOper);
// And free any memory allocated by Excel
Excel12v(xlFree, 1, &pResultOper, (XlOper12 *)IntPtr.Zero);
return(xlReturn);
}
public unsafe static IntPtr GetCurrentSheetId12()
{
// In a macro type function, xlSheetNm seems to return the Active sheet instead of the Current sheet.
// So we first try to get the Current sheet from the caller.
IntPtr retval = GetCallerSheetId12();
if (retval != IntPtr.Zero)
{
return(retval);
}
// Else we try the old way.
XlOper12 SRef = new XlOper12();
SRef.xlType = XlType12.XlTypeSReference;
//SRef.srefValue.Count = 1;
//SRef.srefValue.Reference.RowFirst = 1;
//SRef.srefValue.Reference.RowLast = 1;
//SRef.srefValue.Reference.ColumnFirst = 1;
//SRef.srefValue.Reference.ColumnLast = 1;
XlOper12 resultOper = new XlOper12();
XlOper12 *pResultOper = &resultOper;
XlOper12 * pSRef = &SRef;
XlOper12 **ppSRef = &(pSRef);
int xlReturn;
xlReturn = Excel12v(xlSheetNm, 1, ppSRef, pResultOper);
if (xlReturn == 0)
{
XlOper12 resultRef = new XlOper12();
XlOper12 *pResultRef = &resultRef;
xlReturn = Excel12v(xlSheetId, 1, (XlOper12 **)&(pResultOper), pResultRef);
// Done with pResultOper - Free
Excel12v(xlFree, 1, &pResultOper, (XlOper12 *)IntPtr.Zero);
if (xlReturn == 0)
{
if (resultRef.xlType == XlType12.XlTypeReference)
{
retval = resultRef.refValue.SheetId;
}
// Done with ResultRef - Free it too
Excel12v(xlFree, 1, &pResultRef, (XlOper12 *)IntPtr.Zero);
}
// CONSIDER: As a small optimisation, we could combine the two calls the xlFree. But then we'd have to manage an array here.
}
return(retval);
}
readonly XlOper12 **_callParams; // Array with MaxCallParams Xloper12s
// readonly XlString12** _callParamStrings; // Array with MaxCallParams XlString12s Only used for spill-over strings from long parameters
public RtdWrapperHelper(string progId, object rtdWrapperOptions)
{
_progId = progId;
_rtdWrapperOptions = rtdWrapperOptions;
// TODO: Can't easily use the regular marshallers, because we want to opt out of the memory management
// TODO: But we should refactor this conversion code a bit
int size = Marshal.SizeOf(typeof(XlOper12));
int stringSize = Marshal.SizeOf(typeof(XlString12)) + ((XlString12.MaxLength - 1) /* 1 char is in Data[1] */ * 2 /* 2 bytes per char */);
_progIdXloper12 = (XlOper12 *)Marshal.AllocCoTaskMem(size);
_progIdXloper12->xlType = XlType12.XlTypeString;
_progIdXloper12->pstrValue = (XlString12 *)Marshal.AllocCoTaskMem(stringSize);
XlString12 *pdest = _progIdXloper12->pstrValue;
ushort charCount = (ushort)Math.Min(progId.Length, XlString12.MaxLength);
fixed(char *psrc = progId)
{
char *ps = psrc;
char *pd = pdest->Data;
for (int k = 0; k < charCount; k++)
{
*(pd++) = *(ps++);
}
}
pdest->Length = charCount;
_emptyStringXloper12 = (XlOper12 *)Marshal.AllocCoTaskMem(size);
_emptyStringXloper12->xlType = XlType12.XlTypeString;
_emptyStringXloper12->pstrValue = (XlString12 *)Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(XlString12)));
_emptyStringXloper12->pstrValue->Length = 0;
_errorValueXloper12 = (XlOper12 *)Marshal.AllocCoTaskMem(size);
_errorValueXloper12->errValue = 15; // ExcelErrorValue
_errorValueXloper12->xlType = XlType12.XlTypeError;
_resultXloper12 = (XlOper12 *)Marshal.AllocCoTaskMem(size);
_resultXloper12->xlType = XlType12.XlTypeEmpty;
_callParams = (XlOper12 **)Marshal.AllocCoTaskMem(IntPtr.Size * MaxCallParams);
_callParams[0] = _progIdXloper12;
_callParams[1] = _emptyStringXloper12;
// _callParamStrings = (XlString12**)Marshal.AllocCoTaskMem(stringSize * MaxCallParams);
}
public unsafe static IntPtr GetCallerSheetId12()
{
IntPtr retval = IntPtr.Zero;
XlOper12 resultOper = new XlOper12();
XlOper12* pResultOper = &resultOper;
int xlReturn;
xlReturn = Excel12v(xlfCaller, 0, (XlOper12**)IntPtr.Zero, pResultOper);
if (xlReturn == 0)
{
if (resultOper.xlType == XlType12.XlTypeReference)
{
retval = resultOper.refValue.SheetId;
Excel12v(xlFree, 1, &pResultOper, (XlOper12*)IntPtr.Zero);
}
}
return retval;
}
internal unsafe static void SetExcelReference12(XlOper12 *pOper, XlOper12.XlMultiRef12 *pMultiRef, object /*ExcelReference*/ r)
{
IntPtr sheetId = ExcelReferenceGetSheetId(r);
int[][] rects = ExcelReferenceGetRectangles(r);
int rectCount = rects.GetLength(0);
pOper->xlType = XlType12.XlTypeReference;
pOper->refValue.SheetId = sheetId;
pOper->refValue.pMultiRef = pMultiRef;
pOper->refValue.pMultiRef->Count = (ushort)rectCount;
XlOper12.XlRectangle12 *pRectangles = (XlOper12.XlRectangle12 *)(&pOper->refValue.pMultiRef->Rectangles);
for (int i = 0; i < rectCount; i++)
{
pRectangles[i].RowFirst = rects[i][0];
pRectangles[i].RowLast = rects[i][1];
pRectangles[i].ColumnFirst = rects[i][2];
pRectangles[i].ColumnLast = rects[i][3];
}
}
